Blackfin arch: DMA operation cleanup
[linux-2.6.git] / arch / blackfin / kernel / bfin_dma_5xx.c
1 /*
2  * File:         arch/blackfin/kernel/bfin_dma_5xx.c
3  * Based on:
4  * Author:
5  *
6  * Created:
7  * Description:  This file contains the simple DMA Implementation for Blackfin
8  *
9  * Modified:
10  *               Copyright 2004-2006 Analog Devices Inc.
11  *
12  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, see the file COPYING, or write
26  * to the Free Software Foundation, Inc.,
27  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
28  */
29
30 #include <linux/errno.h>
31 #include <linux/module.h>
32 #include <linux/sched.h>
33 #include <linux/interrupt.h>
34 #include <linux/kernel.h>
35 #include <linux/param.h>
36
37 #include <asm/dma.h>
38 #include <asm/cacheflush.h>
39
40 /* Remove unused code not exported by symbol or internally called */
41 #define REMOVE_DEAD_CODE
42
43 /**************************************************************************
44  * Global Variables
45 ***************************************************************************/
46
47 static struct dma_channel dma_ch[MAX_BLACKFIN_DMA_CHANNEL];
48 #if defined (CONFIG_BF561)
49 static struct dma_register *base_addr[MAX_BLACKFIN_DMA_CHANNEL] = {
50         (struct dma_register *) DMA1_0_NEXT_DESC_PTR,
51         (struct dma_register *) DMA1_1_NEXT_DESC_PTR,
52         (struct dma_register *) DMA1_2_NEXT_DESC_PTR,
53         (struct dma_register *) DMA1_3_NEXT_DESC_PTR,
54         (struct dma_register *) DMA1_4_NEXT_DESC_PTR,
55         (struct dma_register *) DMA1_5_NEXT_DESC_PTR,
56         (struct dma_register *) DMA1_6_NEXT_DESC_PTR,
57         (struct dma_register *) DMA1_7_NEXT_DESC_PTR,
58         (struct dma_register *) DMA1_8_NEXT_DESC_PTR,
59         (struct dma_register *) DMA1_9_NEXT_DESC_PTR,
60         (struct dma_register *) DMA1_10_NEXT_DESC_PTR,
61         (struct dma_register *) DMA1_11_NEXT_DESC_PTR,
62         (struct dma_register *) DMA2_0_NEXT_DESC_PTR,
63         (struct dma_register *) DMA2_1_NEXT_DESC_PTR,
64         (struct dma_register *) DMA2_2_NEXT_DESC_PTR,
65         (struct dma_register *) DMA2_3_NEXT_DESC_PTR,
66         (struct dma_register *) DMA2_4_NEXT_DESC_PTR,
67         (struct dma_register *) DMA2_5_NEXT_DESC_PTR,
68         (struct dma_register *) DMA2_6_NEXT_DESC_PTR,
69         (struct dma_register *) DMA2_7_NEXT_DESC_PTR,
70         (struct dma_register *) DMA2_8_NEXT_DESC_PTR,
71         (struct dma_register *) DMA2_9_NEXT_DESC_PTR,
72         (struct dma_register *) DMA2_10_NEXT_DESC_PTR,
73         (struct dma_register *) DMA2_11_NEXT_DESC_PTR,
74         (struct dma_register *) MDMA1_D0_NEXT_DESC_PTR,
75         (struct dma_register *) MDMA1_S0_NEXT_DESC_PTR,
76         (struct dma_register *) MDMA1_D1_NEXT_DESC_PTR,
77         (struct dma_register *) MDMA1_S1_NEXT_DESC_PTR,
78         (struct dma_register *) MDMA2_D0_NEXT_DESC_PTR,
79         (struct dma_register *) MDMA2_S0_NEXT_DESC_PTR,
80         (struct dma_register *) MDMA2_D1_NEXT_DESC_PTR,
81         (struct dma_register *) MDMA2_S1_NEXT_DESC_PTR,
82         (struct dma_register *) IMDMA_D0_NEXT_DESC_PTR,
83         (struct dma_register *) IMDMA_S0_NEXT_DESC_PTR,
84         (struct dma_register *) IMDMA_D1_NEXT_DESC_PTR,
85         (struct dma_register *) IMDMA_S1_NEXT_DESC_PTR,
86 };
87 #else
88 static struct dma_register *base_addr[MAX_BLACKFIN_DMA_CHANNEL] = {
89         (struct dma_register *) DMA0_NEXT_DESC_PTR,
90         (struct dma_register *) DMA1_NEXT_DESC_PTR,
91         (struct dma_register *) DMA2_NEXT_DESC_PTR,
92         (struct dma_register *) DMA3_NEXT_DESC_PTR,
93         (struct dma_register *) DMA4_NEXT_DESC_PTR,
94         (struct dma_register *) DMA5_NEXT_DESC_PTR,
95         (struct dma_register *) DMA6_NEXT_DESC_PTR,
96         (struct dma_register *) DMA7_NEXT_DESC_PTR,
97 #if (defined(CONFIG_BF537) || defined(CONFIG_BF534) || defined(CONFIG_BF536))
98         (struct dma_register *) DMA8_NEXT_DESC_PTR,
99         (struct dma_register *) DMA9_NEXT_DESC_PTR,
100         (struct dma_register *) DMA10_NEXT_DESC_PTR,
101         (struct dma_register *) DMA11_NEXT_DESC_PTR,
102 #endif
103         (struct dma_register *) MDMA_D0_NEXT_DESC_PTR,
104         (struct dma_register *) MDMA_S0_NEXT_DESC_PTR,
105         (struct dma_register *) MDMA_D1_NEXT_DESC_PTR,
106         (struct dma_register *) MDMA_S1_NEXT_DESC_PTR,
107 };
108 #endif
109
110 /*------------------------------------------------------------------------------
111  *       Set the Buffer Clear bit in the Configuration register of specific DMA
112  *       channel. This will stop the descriptor based DMA operation.
113  *-----------------------------------------------------------------------------*/
114 static void clear_dma_buffer(unsigned int channel)
115 {
116         dma_ch[channel].regs->cfg |= RESTART;
117         SSYNC();
118         dma_ch[channel].regs->cfg &= ~RESTART;
119         SSYNC();
120 }
121
122 static int __init blackfin_dma_init(void)
123 {
124         int i;
125
126         printk(KERN_INFO "Blackfin DMA Controller\n");
127
128         for (i = 0; i < MAX_BLACKFIN_DMA_CHANNEL; i++) {
129                 dma_ch[i].chan_status = DMA_CHANNEL_FREE;
130                 dma_ch[i].regs = base_addr[i];
131                 mutex_init(&(dma_ch[i].dmalock));
132         }
133         /* Mark MEMDMA Channel 0 as requested since we're using it internally */
134         dma_ch[CH_MEM_STREAM0_DEST].chan_status = DMA_CHANNEL_REQUESTED;
135         dma_ch[CH_MEM_STREAM0_SRC].chan_status = DMA_CHANNEL_REQUESTED;
136         return 0;
137 }
138
139 arch_initcall(blackfin_dma_init);
140
141 /*
142  *      Form the channel find the irq number for that channel.
143  */
144 #if !defined(CONFIG_BF561)
145
146 static int bf533_channel2irq(unsigned int channel)
147 {
148         int ret_irq = -1;
149
150         switch (channel) {
151         case CH_PPI:
152                 ret_irq = IRQ_PPI;
153                 break;
154
155 #if (defined(CONFIG_BF537) || defined(CONFIG_BF534) || defined(CONFIG_BF536))
156         case CH_EMAC_RX:
157                 ret_irq = IRQ_MAC_RX;
158                 break;
159
160         case CH_EMAC_TX:
161                 ret_irq = IRQ_MAC_TX;
162                 break;
163
164         case CH_UART1_RX:
165                 ret_irq = IRQ_UART1_RX;
166                 break;
167
168         case CH_UART1_TX:
169                 ret_irq = IRQ_UART1_TX;
170                 break;
171 #endif
172
173         case CH_SPORT0_RX:
174                 ret_irq = IRQ_SPORT0_RX;
175                 break;
176
177         case CH_SPORT0_TX:
178                 ret_irq = IRQ_SPORT0_TX;
179                 break;
180
181         case CH_SPORT1_RX:
182                 ret_irq = IRQ_SPORT1_RX;
183                 break;
184
185         case CH_SPORT1_TX:
186                 ret_irq = IRQ_SPORT1_TX;
187                 break;
188
189         case CH_SPI:
190                 ret_irq = IRQ_SPI;
191                 break;
192
193         case CH_UART_RX:
194                 ret_irq = IRQ_UART_RX;
195                 break;
196
197         case CH_UART_TX:
198                 ret_irq = IRQ_UART_TX;
199                 break;
200
201         case CH_MEM_STREAM0_SRC:
202         case CH_MEM_STREAM0_DEST:
203                 ret_irq = IRQ_MEM_DMA0;
204                 break;
205
206         case CH_MEM_STREAM1_SRC:
207         case CH_MEM_STREAM1_DEST:
208                 ret_irq = IRQ_MEM_DMA1;
209                 break;
210         }
211         return ret_irq;
212 }
213
214 # define channel2irq(channel) bf533_channel2irq(channel)
215
216 #else
217
218 static int bf561_channel2irq(unsigned int channel)
219 {
220         int ret_irq = -1;
221
222         switch (channel) {
223         case CH_PPI0:
224                 ret_irq = IRQ_PPI0;
225                 break;
226         case CH_PPI1:
227                 ret_irq = IRQ_PPI1;
228                 break;
229         case CH_SPORT0_RX:
230                 ret_irq = IRQ_SPORT0_RX;
231                 break;
232         case CH_SPORT0_TX:
233                 ret_irq = IRQ_SPORT0_TX;
234                 break;
235         case CH_SPORT1_RX:
236                 ret_irq = IRQ_SPORT1_RX;
237                 break;
238         case CH_SPORT1_TX:
239                 ret_irq = IRQ_SPORT1_TX;
240                 break;
241         case CH_SPI:
242                 ret_irq = IRQ_SPI;
243                 break;
244         case CH_UART_RX:
245                 ret_irq = IRQ_UART_RX;
246                 break;
247         case CH_UART_TX:
248                 ret_irq = IRQ_UART_TX;
249                 break;
250
251         case CH_MEM_STREAM0_SRC:
252         case CH_MEM_STREAM0_DEST:
253                 ret_irq = IRQ_MEM_DMA0;
254                 break;
255         case CH_MEM_STREAM1_SRC:
256         case CH_MEM_STREAM1_DEST:
257                 ret_irq = IRQ_MEM_DMA1;
258                 break;
259         case CH_MEM_STREAM2_SRC:
260         case CH_MEM_STREAM2_DEST:
261                 ret_irq = IRQ_MEM_DMA2;
262                 break;
263         case CH_MEM_STREAM3_SRC:
264         case CH_MEM_STREAM3_DEST:
265                 ret_irq = IRQ_MEM_DMA3;
266                 break;
267
268         case CH_IMEM_STREAM0_SRC:
269         case CH_IMEM_STREAM0_DEST:
270                 ret_irq = IRQ_IMEM_DMA0;
271                 break;
272         case CH_IMEM_STREAM1_SRC:
273         case CH_IMEM_STREAM1_DEST:
274                 ret_irq = IRQ_IMEM_DMA1;
275                 break;
276         }
277         return ret_irq;
278 }
279
280 # define channel2irq(channel) bf561_channel2irq(channel)
281
282 #endif
283
284 /*------------------------------------------------------------------------------
285  *      Request the specific DMA channel from the system.
286  *-----------------------------------------------------------------------------*/
287 int request_dma(unsigned int channel, char *device_id)
288 {
289
290         pr_debug("request_dma() : BEGIN \n");
291         mutex_lock(&(dma_ch[channel].dmalock));
292
293         if ((dma_ch[channel].chan_status == DMA_CHANNEL_REQUESTED)
294             || (dma_ch[channel].chan_status == DMA_CHANNEL_ENABLED)) {
295                 mutex_unlock(&(dma_ch[channel].dmalock));
296                 pr_debug("DMA CHANNEL IN USE  \n");
297                 return -EBUSY;
298         } else {
299                 dma_ch[channel].chan_status = DMA_CHANNEL_REQUESTED;
300                 pr_debug("DMA CHANNEL IS ALLOCATED  \n");
301         }
302
303         mutex_unlock(&(dma_ch[channel].dmalock));
304
305         dma_ch[channel].device_id = device_id;
306         dma_ch[channel].irq_callback = NULL;
307
308         /* This is to be enabled by putting a restriction -
309          * you have to request DMA, before doing any operations on
310          * descriptor/channel
311          */
312         pr_debug("request_dma() : END  \n");
313         return channel;
314 }
315 EXPORT_SYMBOL(request_dma);
316
317 int set_dma_callback(unsigned int channel, dma_interrupt_t callback, void *data)
318 {
319         int ret_irq = 0;
320
321         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
322                && channel < MAX_BLACKFIN_DMA_CHANNEL));
323
324         if (callback != NULL) {
325                 int ret_val;
326                 ret_irq = channel2irq(channel);
327
328                 dma_ch[channel].data = data;
329
330                 ret_val =
331                     request_irq(ret_irq, (void *)callback, IRQF_DISABLED,
332                                 dma_ch[channel].device_id, data);
333                 if (ret_val) {
334                         printk(KERN_NOTICE
335                                "Request irq in DMA engine failed.\n");
336                         return -EPERM;
337                 }
338                 dma_ch[channel].irq_callback = callback;
339         }
340         return 0;
341 }
342 EXPORT_SYMBOL(set_dma_callback);
343
344 void free_dma(unsigned int channel)
345 {
346         int ret_irq;
347
348         pr_debug("freedma() : BEGIN \n");
349         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
350                && channel < MAX_BLACKFIN_DMA_CHANNEL));
351
352         /* Halt the DMA */
353         disable_dma(channel);
354         clear_dma_buffer(channel);
355
356         if (dma_ch[channel].irq_callback != NULL) {
357                 ret_irq = channel2irq(channel);
358                 free_irq(ret_irq, dma_ch[channel].data);
359         }
360
361         /* Clear the DMA Variable in the Channel */
362         mutex_lock(&(dma_ch[channel].dmalock));
363         dma_ch[channel].chan_status = DMA_CHANNEL_FREE;
364         mutex_unlock(&(dma_ch[channel].dmalock));
365
366         pr_debug("freedma() : END \n");
367 }
368 EXPORT_SYMBOL(free_dma);
369
370 void dma_enable_irq(unsigned int channel)
371 {
372         int ret_irq;
373
374         pr_debug("dma_enable_irq() : BEGIN \n");
375         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
376                && channel < MAX_BLACKFIN_DMA_CHANNEL));
377
378         ret_irq = channel2irq(channel);
379         enable_irq(ret_irq);
380 }
381 EXPORT_SYMBOL(dma_enable_irq);
382
383 void dma_disable_irq(unsigned int channel)
384 {
385         int ret_irq;
386
387         pr_debug("dma_disable_irq() : BEGIN \n");
388         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
389                && channel < MAX_BLACKFIN_DMA_CHANNEL));
390
391         ret_irq = channel2irq(channel);
392         disable_irq(ret_irq);
393 }
394 EXPORT_SYMBOL(dma_disable_irq);
395
396 int dma_channel_active(unsigned int channel)
397 {
398         if (dma_ch[channel].chan_status == DMA_CHANNEL_FREE) {
399                 return 0;
400         } else {
401                 return 1;
402         }
403 }
404 EXPORT_SYMBOL(dma_channel_active);
405
406 /*------------------------------------------------------------------------------
407 *       stop the specific DMA channel.
408 *-----------------------------------------------------------------------------*/
409 void disable_dma(unsigned int channel)
410 {
411         pr_debug("stop_dma() : BEGIN \n");
412
413         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
414                && channel < MAX_BLACKFIN_DMA_CHANNEL));
415
416         dma_ch[channel].regs->cfg &= ~DMAEN;    /* Clean the enable bit */
417         SSYNC();
418         dma_ch[channel].chan_status = DMA_CHANNEL_REQUESTED;
419         /* Needs to be enabled Later */
420         pr_debug("stop_dma() : END \n");
421         return;
422 }
423 EXPORT_SYMBOL(disable_dma);
424
425 void enable_dma(unsigned int channel)
426 {
427         pr_debug("enable_dma() : BEGIN \n");
428
429         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
430                && channel < MAX_BLACKFIN_DMA_CHANNEL));
431
432         dma_ch[channel].chan_status = DMA_CHANNEL_ENABLED;
433         dma_ch[channel].regs->curr_x_count = 0;
434         dma_ch[channel].regs->curr_y_count = 0;
435
436         dma_ch[channel].regs->cfg |= DMAEN;     /* Set the enable bit */
437         SSYNC();
438         pr_debug("enable_dma() : END \n");
439         return;
440 }
441 EXPORT_SYMBOL(enable_dma);
442
443 /*------------------------------------------------------------------------------
444 *               Set the Start Address register for the specific DMA channel
445 *               This function can be used for register based DMA,
446 *               to setup the start address
447 *               addr:           Starting address of the DMA Data to be transferred.
448 *-----------------------------------------------------------------------------*/
449 void set_dma_start_addr(unsigned int channel, unsigned long addr)
450 {
451         pr_debug("set_dma_start_addr() : BEGIN \n");
452
453         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
454                && channel < MAX_BLACKFIN_DMA_CHANNEL));
455
456         dma_ch[channel].regs->start_addr = addr;
457         SSYNC();
458         pr_debug("set_dma_start_addr() : END\n");
459 }
460 EXPORT_SYMBOL(set_dma_start_addr);
461
462 void set_dma_next_desc_addr(unsigned int channel, unsigned long addr)
463 {
464         pr_debug("set_dma_next_desc_addr() : BEGIN \n");
465
466         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
467                && channel < MAX_BLACKFIN_DMA_CHANNEL));
468
469         dma_ch[channel].regs->next_desc_ptr = addr;
470         SSYNC();
471         pr_debug("set_dma_start_addr() : END\n");
472 }
473 EXPORT_SYMBOL(set_dma_next_desc_addr);
474
475 void set_dma_x_count(unsigned int channel, unsigned short x_count)
476 {
477         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
478                && channel < MAX_BLACKFIN_DMA_CHANNEL));
479
480         dma_ch[channel].regs->x_count = x_count;
481         SSYNC();
482 }
483 EXPORT_SYMBOL(set_dma_x_count);
484
485 void set_dma_y_count(unsigned int channel, unsigned short y_count)
486 {
487         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
488                && channel < MAX_BLACKFIN_DMA_CHANNEL));
489
490         dma_ch[channel].regs->y_count = y_count;
491         SSYNC();
492 }
493 EXPORT_SYMBOL(set_dma_y_count);
494
495 void set_dma_x_modify(unsigned int channel, short x_modify)
496 {
497         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
498                && channel < MAX_BLACKFIN_DMA_CHANNEL));
499
500         dma_ch[channel].regs->x_modify = x_modify;
501         SSYNC();
502 }
503 EXPORT_SYMBOL(set_dma_x_modify);
504
505 void set_dma_y_modify(unsigned int channel, short y_modify)
506 {
507         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
508                && channel < MAX_BLACKFIN_DMA_CHANNEL));
509
510         dma_ch[channel].regs->y_modify = y_modify;
511         SSYNC();
512 }
513 EXPORT_SYMBOL(set_dma_y_modify);
514
515 void set_dma_config(unsigned int channel, unsigned short config)
516 {
517         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
518                && channel < MAX_BLACKFIN_DMA_CHANNEL));
519
520         dma_ch[channel].regs->cfg = config;
521         SSYNC();
522 }
523 EXPORT_SYMBOL(set_dma_config);
524
525 unsigned short
526 set_bfin_dma_config(char direction, char flow_mode,
527                     char intr_mode, char dma_mode, char width)
528 {
529         unsigned short config;
530
531         config =
532             ((direction << 1) | (width << 2) | (dma_mode << 4) |
533              (intr_mode << 6) | (flow_mode << 12) | RESTART);
534         return config;
535 }
536 EXPORT_SYMBOL(set_bfin_dma_config);
537
538 void set_dma_sg(unsigned int channel, struct dmasg * sg, int nr_sg)
539 {
540         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
541                && channel < MAX_BLACKFIN_DMA_CHANNEL));
542
543         dma_ch[channel].regs->cfg |= ((nr_sg & 0x0F) << 8);
544
545         dma_ch[channel].regs->next_desc_ptr = (unsigned int)sg;
546
547         SSYNC();
548 }
549 EXPORT_SYMBOL(set_dma_sg);
550
551 /*------------------------------------------------------------------------------
552  *      Get the DMA status of a specific DMA channel from the system.
553  *-----------------------------------------------------------------------------*/
554 unsigned short get_dma_curr_irqstat(unsigned int channel)
555 {
556         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
557                && channel < MAX_BLACKFIN_DMA_CHANNEL));
558
559         return dma_ch[channel].regs->irq_status;
560 }
561 EXPORT_SYMBOL(get_dma_curr_irqstat);
562
563 /*------------------------------------------------------------------------------
564  *      Clear the DMA_DONE bit in DMA status. Stop the DMA completion interrupt.
565  *-----------------------------------------------------------------------------*/
566 void clear_dma_irqstat(unsigned int channel)
567 {
568         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
569                && channel < MAX_BLACKFIN_DMA_CHANNEL));
570         dma_ch[channel].regs->irq_status |= 3;
571 }
572 EXPORT_SYMBOL(clear_dma_irqstat);
573
574 /*------------------------------------------------------------------------------
575  *      Get current DMA xcount of a specific DMA channel from the system.
576  *-----------------------------------------------------------------------------*/
577 unsigned short get_dma_curr_xcount(unsigned int channel)
578 {
579         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
580                && channel < MAX_BLACKFIN_DMA_CHANNEL));
581
582         return dma_ch[channel].regs->curr_x_count;
583 }
584 EXPORT_SYMBOL(get_dma_curr_xcount);
585
586 /*------------------------------------------------------------------------------
587  *      Get current DMA ycount of a specific DMA channel from the system.
588  *-----------------------------------------------------------------------------*/
589 unsigned short get_dma_curr_ycount(unsigned int channel)
590 {
591         BUG_ON(!(dma_ch[channel].chan_status != DMA_CHANNEL_FREE
592                && channel < MAX_BLACKFIN_DMA_CHANNEL));
593
594         return dma_ch[channel].regs->curr_y_count;
595 }
596 EXPORT_SYMBOL(get_dma_curr_ycount);
597
598 void *dma_memcpy(void *dest, const void *src, size_t size)
599 {
600         int direction;  /* 1 - address decrease, 0 - address increase */
601         int flag_align; /* 1 - address aligned,  0 - address unaligned */
602         int flag_2D;    /* 1 - 2D DMA needed,    0 - 1D DMA needed */
603         unsigned long flags;
604
605         if (size <= 0)
606                 return NULL;
607         
608         local_irq_save(flags);
609
610         if ((unsigned long)src < memory_end)
611                 blackfin_dcache_flush_range((unsigned int)src,
612                                             (unsigned int)(src + size));
613
614         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
615
616         if ((unsigned long)src < (unsigned long)dest)
617                 direction = 1;
618         else
619                 direction = 0;
620
621         if ((((unsigned long)dest % 2) == 0) && (((unsigned long)src % 2) == 0)
622             && ((size % 2) == 0))
623                 flag_align = 1;
624         else
625                 flag_align = 0;
626
627         if (size > 0x10000)     /* size > 64K */
628                 flag_2D = 1;
629         else
630                 flag_2D = 0;
631
632         /* Setup destination and source start address */
633         if (direction) {
634                 if (flag_align) {
635                         bfin_write_MDMA_D0_START_ADDR(dest + size - 2);
636                         bfin_write_MDMA_S0_START_ADDR(src + size - 2);
637                 } else {
638                         bfin_write_MDMA_D0_START_ADDR(dest + size - 1);
639                         bfin_write_MDMA_S0_START_ADDR(src + size - 1);
640                 }
641         } else {
642                 bfin_write_MDMA_D0_START_ADDR(dest);
643                 bfin_write_MDMA_S0_START_ADDR(src);
644         }
645
646         /* Setup destination and source xcount */
647         if (flag_2D) {
648                 if (flag_align) {
649                         bfin_write_MDMA_D0_X_COUNT(1024 / 2);
650                         bfin_write_MDMA_S0_X_COUNT(1024 / 2);
651                 } else {
652                         bfin_write_MDMA_D0_X_COUNT(1024);
653                         bfin_write_MDMA_S0_X_COUNT(1024);
654                 }
655                 bfin_write_MDMA_D0_Y_COUNT(size >> 10);
656                 bfin_write_MDMA_S0_Y_COUNT(size >> 10);
657         } else {
658                 if (flag_align) {
659                         bfin_write_MDMA_D0_X_COUNT(size / 2);
660                         bfin_write_MDMA_S0_X_COUNT(size / 2);
661                 } else {
662                         bfin_write_MDMA_D0_X_COUNT(size);
663                         bfin_write_MDMA_S0_X_COUNT(size);
664                 }
665         }
666
667         /* Setup destination and source xmodify and ymodify */
668         if (direction) {
669                 if (flag_align) {
670                         bfin_write_MDMA_D0_X_MODIFY(-2);
671                         bfin_write_MDMA_S0_X_MODIFY(-2);
672                         if (flag_2D) {
673                                 bfin_write_MDMA_D0_Y_MODIFY(-2);
674                                 bfin_write_MDMA_S0_Y_MODIFY(-2);
675                         }
676                 } else {
677                         bfin_write_MDMA_D0_X_MODIFY(-1);
678                         bfin_write_MDMA_S0_X_MODIFY(-1);
679                         if (flag_2D) {
680                                 bfin_write_MDMA_D0_Y_MODIFY(-1);
681                                 bfin_write_MDMA_S0_Y_MODIFY(-1);
682                         }
683                 }
684         } else {
685                 if (flag_align) {
686                         bfin_write_MDMA_D0_X_MODIFY(2);
687                         bfin_write_MDMA_S0_X_MODIFY(2);
688                         if (flag_2D) {
689                                 bfin_write_MDMA_D0_Y_MODIFY(2);
690                                 bfin_write_MDMA_S0_Y_MODIFY(2);
691                         }
692                 } else {
693                         bfin_write_MDMA_D0_X_MODIFY(1);
694                         bfin_write_MDMA_S0_X_MODIFY(1);
695                         if (flag_2D) {
696                                 bfin_write_MDMA_D0_Y_MODIFY(1);
697                                 bfin_write_MDMA_S0_Y_MODIFY(1);
698                         }
699                 }
700         }
701
702         /* Enable source DMA */
703         if (flag_2D) {
704                 if (flag_align) {
705                         bfin_write_MDMA_S0_CONFIG(DMAEN | DMA2D | WDSIZE_16);
706                         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN | DMA2D | WDSIZE_16);
707                 } else {
708                         bfin_write_MDMA_S0_CONFIG(DMAEN | DMA2D);
709                         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN | DMA2D);
710                 }
711         } else {
712                 if (flag_align) {
713                         bfin_write_MDMA_S0_CONFIG(DMAEN | WDSIZE_16);
714                         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN | WDSIZE_16);
715                 } else {
716                         bfin_write_MDMA_S0_CONFIG(DMAEN);
717                         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN);
718                 }
719         }
720
721         while (!(bfin_read_MDMA_D0_IRQ_STATUS() & DMA_DONE))
722                 ;
723
724         bfin_write_MDMA_D0_IRQ_STATUS(bfin_read_MDMA_D0_IRQ_STATUS() |
725                                       (DMA_DONE | DMA_ERR));
726
727         bfin_write_MDMA_S0_CONFIG(0);
728         bfin_write_MDMA_D0_CONFIG(0);
729
730         if ((unsigned long)dest < memory_end)
731                 blackfin_dcache_invalidate_range((unsigned int)dest,
732                                                  (unsigned int)(dest + size));
733         local_irq_restore(flags);
734
735         return dest;
736 }
737 EXPORT_SYMBOL(dma_memcpy);
738
739 void *safe_dma_memcpy(void *dest, const void *src, size_t size)
740 {
741         void *addr;
742         addr = dma_memcpy(dest, src, size);
743         return addr;
744 }
745 EXPORT_SYMBOL(safe_dma_memcpy);
746
747 void dma_outsb(void __iomem *addr, const void *buf, unsigned short len)
748 {
749
750         unsigned long flags;
751         
752         local_irq_save(flags);
753         
754         blackfin_dcache_flush_range((unsigned int)buf,(unsigned int)(buf) + len);
755
756         bfin_write_MDMA_D0_START_ADDR(addr);
757         bfin_write_MDMA_D0_X_COUNT(len);
758         bfin_write_MDMA_D0_X_MODIFY(0);
759         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
760
761         bfin_write_MDMA_S0_START_ADDR(buf);
762         bfin_write_MDMA_S0_X_COUNT(len);
763         bfin_write_MDMA_S0_X_MODIFY(1);
764         bfin_write_MDMA_S0_IRQ_STATUS(DMA_DONE | DMA_ERR);
765
766         bfin_write_MDMA_S0_CONFIG(DMAEN | WDSIZE_8);
767         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN | WDSIZE_8);
768
769         while (!(bfin_read_MDMA_D0_IRQ_STATUS() & DMA_DONE));
770
771         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
772
773         bfin_write_MDMA_S0_CONFIG(0);
774         bfin_write_MDMA_D0_CONFIG(0);
775         local_irq_restore(flags);
776
777 }
778 EXPORT_SYMBOL(dma_outsb);
779
780
781 void dma_insb(const void __iomem *addr, void *buf, unsigned short len)
782 {
783         unsigned long flags;
784                 
785         local_irq_save(flags);
786         bfin_write_MDMA_D0_START_ADDR(buf);
787         bfin_write_MDMA_D0_X_COUNT(len);
788         bfin_write_MDMA_D0_X_MODIFY(1);
789         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
790
791         bfin_write_MDMA_S0_START_ADDR(addr);
792         bfin_write_MDMA_S0_X_COUNT(len);
793         bfin_write_MDMA_S0_X_MODIFY(0);
794         bfin_write_MDMA_S0_IRQ_STATUS(DMA_DONE | DMA_ERR);
795
796         bfin_write_MDMA_S0_CONFIG(DMAEN | WDSIZE_8);
797         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN | WDSIZE_8);
798
799         blackfin_dcache_invalidate_range((unsigned int)buf, (unsigned int)(buf) + len);
800
801         while (!(bfin_read_MDMA_D0_IRQ_STATUS() & DMA_DONE));
802
803         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
804
805         bfin_write_MDMA_S0_CONFIG(0);
806         bfin_write_MDMA_D0_CONFIG(0);
807         local_irq_restore(flags);
808
809 }
810 EXPORT_SYMBOL(dma_insb);
811
812 void dma_outsw(void __iomem *addr, const void  *buf, unsigned short len)
813 {
814         unsigned long flags;
815         
816         local_irq_save(flags);
817                 
818         blackfin_dcache_flush_range((unsigned int)buf,(unsigned int)(buf) + len);
819
820         bfin_write_MDMA_D0_START_ADDR(addr);
821         bfin_write_MDMA_D0_X_COUNT(len);
822         bfin_write_MDMA_D0_X_MODIFY(0);
823         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
824
825         bfin_write_MDMA_S0_START_ADDR(buf);
826         bfin_write_MDMA_S0_X_COUNT(len);
827         bfin_write_MDMA_S0_X_MODIFY(2);
828         bfin_write_MDMA_S0_IRQ_STATUS(DMA_DONE | DMA_ERR);
829
830         bfin_write_MDMA_S0_CONFIG(DMAEN | WDSIZE_16);
831         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN | WDSIZE_16);
832
833         while (!(bfin_read_MDMA_D0_IRQ_STATUS() & DMA_DONE));
834
835         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
836
837         bfin_write_MDMA_S0_CONFIG(0);
838         bfin_write_MDMA_D0_CONFIG(0);
839         local_irq_restore(flags);
840
841 }
842 EXPORT_SYMBOL(dma_outsw);
843
844 void dma_insw(const void __iomem *addr, void *buf, unsigned short len)
845 {
846         unsigned long flags;
847                 
848         local_irq_save(flags);
849         
850         bfin_write_MDMA_D0_START_ADDR(buf);
851         bfin_write_MDMA_D0_X_COUNT(len);
852         bfin_write_MDMA_D0_X_MODIFY(2);
853         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
854
855         bfin_write_MDMA_S0_START_ADDR(addr);
856         bfin_write_MDMA_S0_X_COUNT(len);
857         bfin_write_MDMA_S0_X_MODIFY(0);
858         bfin_write_MDMA_S0_IRQ_STATUS(DMA_DONE | DMA_ERR);
859
860         bfin_write_MDMA_S0_CONFIG(DMAEN | WDSIZE_16);
861         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN | WDSIZE_16);
862
863         blackfin_dcache_invalidate_range((unsigned int)buf, (unsigned int)(buf) + len);
864
865         while (!(bfin_read_MDMA_D0_IRQ_STATUS() & DMA_DONE));
866
867         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
868
869         bfin_write_MDMA_S0_CONFIG(0);
870         bfin_write_MDMA_D0_CONFIG(0);
871         local_irq_restore(flags);
872
873 }
874 EXPORT_SYMBOL(dma_insw);
875
876 void dma_outsl(void __iomem *addr, const void *buf, unsigned short len)
877 {
878         unsigned long flags;
879         
880         local_irq_save(flags);
881         
882         blackfin_dcache_flush_range((unsigned int)buf,(unsigned int)(buf) + len);
883
884         bfin_write_MDMA_D0_START_ADDR(addr);
885         bfin_write_MDMA_D0_X_COUNT(len);
886         bfin_write_MDMA_D0_X_MODIFY(0);
887         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
888
889         bfin_write_MDMA_S0_START_ADDR(buf);
890         bfin_write_MDMA_S0_X_COUNT(len);
891         bfin_write_MDMA_S0_X_MODIFY(4);
892         bfin_write_MDMA_S0_IRQ_STATUS(DMA_DONE | DMA_ERR);
893
894         bfin_write_MDMA_S0_CONFIG(DMAEN | WDSIZE_32);
895         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN | WDSIZE_32);
896
897         while (!(bfin_read_MDMA_D0_IRQ_STATUS() & DMA_DONE));
898
899         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
900
901         bfin_write_MDMA_S0_CONFIG(0);
902         bfin_write_MDMA_D0_CONFIG(0);
903         local_irq_restore(flags);
904
905 }
906 EXPORT_SYMBOL(dma_outsl);
907
908 void dma_insl(const void __iomem *addr, void *buf, unsigned short len)
909 {
910         unsigned long flags;
911         
912         local_irq_save(flags);
913         
914         bfin_write_MDMA_D0_START_ADDR(buf);
915         bfin_write_MDMA_D0_X_COUNT(len);
916         bfin_write_MDMA_D0_X_MODIFY(4);
917         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
918
919         bfin_write_MDMA_S0_START_ADDR(addr);
920         bfin_write_MDMA_S0_X_COUNT(len);
921         bfin_write_MDMA_S0_X_MODIFY(0);
922         bfin_write_MDMA_S0_IRQ_STATUS(DMA_DONE | DMA_ERR);
923
924         bfin_write_MDMA_S0_CONFIG(DMAEN | WDSIZE_32);
925         bfin_write_MDMA_D0_CONFIG(WNR | DI_EN | DMAEN | WDSIZE_32);
926
927         blackfin_dcache_invalidate_range((unsigned int)buf, (unsigned int)(buf) + len);
928
929         while (!(bfin_read_MDMA_D0_IRQ_STATUS() & DMA_DONE));
930
931         bfin_write_MDMA_D0_IRQ_STATUS(DMA_DONE | DMA_ERR);
932
933         bfin_write_MDMA_S0_CONFIG(0);
934         bfin_write_MDMA_D0_CONFIG(0);
935         local_irq_restore(flags);
936
937 }
938 EXPORT_SYMBOL(dma_insl);