ARM: OMAP1: DMA: Moving OMAP1 DMA channel definitions to mach-omap1
[muen/linux.git] / arch / arm / mach-omap1 / lcd_dma.c
1 /*
2  * linux/arch/arm/mach-omap1/lcd_dma.c
3  *
4  * Extracted from arch/arm/plat-omap/dma.c
5  * Copyright (C) 2003 - 2008 Nokia Corporation
6  * Author: Juha Yrjölä <juha.yrjola@nokia.com>
7  * DMA channel linking for 1610 by Samuel Ortiz <samuel.ortiz@nokia.com>
8  * Graphics DMA and LCD DMA graphics tranformations
9  * by Imre Deak <imre.deak@nokia.com>
10  * OMAP2/3 support Copyright (C) 2004-2007 Texas Instruments, Inc.
11  * Merged to support both OMAP1 and OMAP2 by Tony Lindgren <tony@atomide.com>
12  * Some functions based on earlier dma-omap.c Copyright (C) 2001 RidgeRun, Inc.
13  *
14  * Copyright (C) 2009 Texas Instruments
15  * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
16  *
17  * Support functions for the OMAP internal DMA channels.
18  *
19  * This program is free software; you can redistribute it and/or modify
20  * it under the terms of the GNU General Public License version 2 as
21  * published by the Free Software Foundation.
22  *
23  */
24
25 #include <linux/module.h>
26 #include <linux/spinlock.h>
27 #include <linux/interrupt.h>
28 #include <linux/io.h>
29
30 #include <plat/dma.h>
31
32 #include <mach/hardware.h>
33 #include <mach/lcdc.h>
34
35 #include "dma.h"
36
37 int omap_lcd_dma_running(void)
38 {
39         /*
40          * On OMAP1510, internal LCD controller will start the transfer
41          * when it gets enabled, so assume DMA running if LCD enabled.
42          */
43         if (cpu_is_omap15xx())
44                 if (omap_readw(OMAP_LCDC_CONTROL) & OMAP_LCDC_CTRL_LCD_EN)
45                         return 1;
46
47         /* Check if LCD DMA is running */
48         if (cpu_is_omap16xx())
49                 if (omap_readw(OMAP1610_DMA_LCD_CCR) & OMAP_DMA_CCR_EN)
50                         return 1;
51
52         return 0;
53 }
54
55 static struct lcd_dma_info {
56         spinlock_t lock;
57         int reserved;
58         void (*callback)(u16 status, void *data);
59         void *cb_data;
60
61         int active;
62         unsigned long addr;
63         int rotate, data_type, xres, yres;
64         int vxres;
65         int mirror;
66         int xscale, yscale;
67         int ext_ctrl;
68         int src_port;
69         int single_transfer;
70 } lcd_dma;
71
72 void omap_set_lcd_dma_b1(unsigned long addr, u16 fb_xres, u16 fb_yres,
73                          int data_type)
74 {
75         lcd_dma.addr = addr;
76         lcd_dma.data_type = data_type;
77         lcd_dma.xres = fb_xres;
78         lcd_dma.yres = fb_yres;
79 }
80 EXPORT_SYMBOL(omap_set_lcd_dma_b1);
81
82 void omap_set_lcd_dma_ext_controller(int external)
83 {
84         lcd_dma.ext_ctrl = external;
85 }
86 EXPORT_SYMBOL(omap_set_lcd_dma_ext_controller);
87
88 void omap_set_lcd_dma_single_transfer(int single)
89 {
90         lcd_dma.single_transfer = single;
91 }
92 EXPORT_SYMBOL(omap_set_lcd_dma_single_transfer);
93
94 void omap_set_lcd_dma_b1_rotation(int rotate)
95 {
96         if (cpu_is_omap15xx()) {
97                 printk(KERN_ERR "DMA rotation is not supported in 1510 mode\n");
98                 BUG();
99                 return;
100         }
101         lcd_dma.rotate = rotate;
102 }
103 EXPORT_SYMBOL(omap_set_lcd_dma_b1_rotation);
104
105 void omap_set_lcd_dma_b1_mirror(int mirror)
106 {
107         if (cpu_is_omap15xx()) {
108                 printk(KERN_ERR "DMA mirror is not supported in 1510 mode\n");
109                 BUG();
110         }
111         lcd_dma.mirror = mirror;
112 }
113 EXPORT_SYMBOL(omap_set_lcd_dma_b1_mirror);
114
115 void omap_set_lcd_dma_b1_vxres(unsigned long vxres)
116 {
117         if (cpu_is_omap15xx()) {
118                 pr_err("DMA virtual resolution is not supported in 1510 mode\n");
119                 BUG();
120         }
121         lcd_dma.vxres = vxres;
122 }
123 EXPORT_SYMBOL(omap_set_lcd_dma_b1_vxres);
124
125 void omap_set_lcd_dma_b1_scale(unsigned int xscale, unsigned int yscale)
126 {
127         if (cpu_is_omap15xx()) {
128                 printk(KERN_ERR "DMA scale is not supported in 1510 mode\n");
129                 BUG();
130         }
131         lcd_dma.xscale = xscale;
132         lcd_dma.yscale = yscale;
133 }
134 EXPORT_SYMBOL(omap_set_lcd_dma_b1_scale);
135
136 static void set_b1_regs(void)
137 {
138         unsigned long top, bottom;
139         int es;
140         u16 w;
141         unsigned long en, fn;
142         long ei, fi;
143         unsigned long vxres;
144         unsigned int xscale, yscale;
145
146         switch (lcd_dma.data_type) {
147         case OMAP_DMA_DATA_TYPE_S8:
148                 es = 1;
149                 break;
150         case OMAP_DMA_DATA_TYPE_S16:
151                 es = 2;
152                 break;
153         case OMAP_DMA_DATA_TYPE_S32:
154                 es = 4;
155                 break;
156         default:
157                 BUG();
158                 return;
159         }
160
161         vxres = lcd_dma.vxres ? lcd_dma.vxres : lcd_dma.xres;
162         xscale = lcd_dma.xscale ? lcd_dma.xscale : 1;
163         yscale = lcd_dma.yscale ? lcd_dma.yscale : 1;
164         BUG_ON(vxres < lcd_dma.xres);
165
166 #define PIXADDR(x, y) (lcd_dma.addr +                                   \
167                 ((y) * vxres * yscale + (x) * xscale) * es)
168 #define PIXSTEP(sx, sy, dx, dy) (PIXADDR(dx, dy) - PIXADDR(sx, sy) - es + 1)
169
170         switch (lcd_dma.rotate) {
171         case 0:
172                 if (!lcd_dma.mirror) {
173                         top = PIXADDR(0, 0);
174                         bottom = PIXADDR(lcd_dma.xres - 1, lcd_dma.yres - 1);
175                         /* 1510 DMA requires the bottom address to be 2 more
176                          * than the actual last memory access location. */
177                         if (cpu_is_omap15xx() &&
178                                 lcd_dma.data_type == OMAP_DMA_DATA_TYPE_S32)
179                                         bottom += 2;
180                         ei = PIXSTEP(0, 0, 1, 0);
181                         fi = PIXSTEP(lcd_dma.xres - 1, 0, 0, 1);
182                 } else {
183                         top = PIXADDR(lcd_dma.xres - 1, 0);
184                         bottom = PIXADDR(0, lcd_dma.yres - 1);
185                         ei = PIXSTEP(1, 0, 0, 0);
186                         fi = PIXSTEP(0, 0, lcd_dma.xres - 1, 1);
187                 }
188                 en = lcd_dma.xres;
189                 fn = lcd_dma.yres;
190                 break;
191         case 90:
192                 if (!lcd_dma.mirror) {
193                         top = PIXADDR(0, lcd_dma.yres - 1);
194                         bottom = PIXADDR(lcd_dma.xres - 1, 0);
195                         ei = PIXSTEP(0, 1, 0, 0);
196                         fi = PIXSTEP(0, 0, 1, lcd_dma.yres - 1);
197                 } else {
198                         top = PIXADDR(lcd_dma.xres - 1, lcd_dma.yres - 1);
199                         bottom = PIXADDR(0, 0);
200                         ei = PIXSTEP(0, 1, 0, 0);
201                         fi = PIXSTEP(1, 0, 0, lcd_dma.yres - 1);
202                 }
203                 en = lcd_dma.yres;
204                 fn = lcd_dma.xres;
205                 break;
206         case 180:
207                 if (!lcd_dma.mirror) {
208                         top = PIXADDR(lcd_dma.xres - 1, lcd_dma.yres - 1);
209                         bottom = PIXADDR(0, 0);
210                         ei = PIXSTEP(1, 0, 0, 0);
211                         fi = PIXSTEP(0, 1, lcd_dma.xres - 1, 0);
212                 } else {
213                         top = PIXADDR(0, lcd_dma.yres - 1);
214                         bottom = PIXADDR(lcd_dma.xres - 1, 0);
215                         ei = PIXSTEP(0, 0, 1, 0);
216                         fi = PIXSTEP(lcd_dma.xres - 1, 1, 0, 0);
217                 }
218                 en = lcd_dma.xres;
219                 fn = lcd_dma.yres;
220                 break;
221         case 270:
222                 if (!lcd_dma.mirror) {
223                         top = PIXADDR(lcd_dma.xres - 1, 0);
224                         bottom = PIXADDR(0, lcd_dma.yres - 1);
225                         ei = PIXSTEP(0, 0, 0, 1);
226                         fi = PIXSTEP(1, lcd_dma.yres - 1, 0, 0);
227                 } else {
228                         top = PIXADDR(0, 0);
229                         bottom = PIXADDR(lcd_dma.xres - 1, lcd_dma.yres - 1);
230                         ei = PIXSTEP(0, 0, 0, 1);
231                         fi = PIXSTEP(0, lcd_dma.yres - 1, 1, 0);
232                 }
233                 en = lcd_dma.yres;
234                 fn = lcd_dma.xres;
235                 break;
236         default:
237                 BUG();
238                 return; /* Suppress warning about uninitialized vars */
239         }
240
241         if (cpu_is_omap15xx()) {
242                 omap_writew(top >> 16, OMAP1510_DMA_LCD_TOP_F1_U);
243                 omap_writew(top, OMAP1510_DMA_LCD_TOP_F1_L);
244                 omap_writew(bottom >> 16, OMAP1510_DMA_LCD_BOT_F1_U);
245                 omap_writew(bottom, OMAP1510_DMA_LCD_BOT_F1_L);
246
247                 return;
248         }
249
250         /* 1610 regs */
251         omap_writew(top >> 16, OMAP1610_DMA_LCD_TOP_B1_U);
252         omap_writew(top, OMAP1610_DMA_LCD_TOP_B1_L);
253         omap_writew(bottom >> 16, OMAP1610_DMA_LCD_BOT_B1_U);
254         omap_writew(bottom, OMAP1610_DMA_LCD_BOT_B1_L);
255
256         omap_writew(en, OMAP1610_DMA_LCD_SRC_EN_B1);
257         omap_writew(fn, OMAP1610_DMA_LCD_SRC_FN_B1);
258
259         w = omap_readw(OMAP1610_DMA_LCD_CSDP);
260         w &= ~0x03;
261         w |= lcd_dma.data_type;
262         omap_writew(w, OMAP1610_DMA_LCD_CSDP);
263
264         w = omap_readw(OMAP1610_DMA_LCD_CTRL);
265         /* Always set the source port as SDRAM for now*/
266         w &= ~(0x03 << 6);
267         if (lcd_dma.callback != NULL)
268                 w |= 1 << 1;            /* Block interrupt enable */
269         else
270                 w &= ~(1 << 1);
271         omap_writew(w, OMAP1610_DMA_LCD_CTRL);
272
273         if (!(lcd_dma.rotate || lcd_dma.mirror ||
274               lcd_dma.vxres || lcd_dma.xscale || lcd_dma.yscale))
275                 return;
276
277         w = omap_readw(OMAP1610_DMA_LCD_CCR);
278         /* Set the double-indexed addressing mode */
279         w |= (0x03 << 12);
280         omap_writew(w, OMAP1610_DMA_LCD_CCR);
281
282         omap_writew(ei, OMAP1610_DMA_LCD_SRC_EI_B1);
283         omap_writew(fi >> 16, OMAP1610_DMA_LCD_SRC_FI_B1_U);
284         omap_writew(fi, OMAP1610_DMA_LCD_SRC_FI_B1_L);
285 }
286
287 static irqreturn_t lcd_dma_irq_handler(int irq, void *dev_id)
288 {
289         u16 w;
290
291         w = omap_readw(OMAP1610_DMA_LCD_CTRL);
292         if (unlikely(!(w & (1 << 3)))) {
293                 printk(KERN_WARNING "Spurious LCD DMA IRQ\n");
294                 return IRQ_NONE;
295         }
296         /* Ack the IRQ */
297         w |= (1 << 3);
298         omap_writew(w, OMAP1610_DMA_LCD_CTRL);
299         lcd_dma.active = 0;
300         if (lcd_dma.callback != NULL)
301                 lcd_dma.callback(w, lcd_dma.cb_data);
302
303         return IRQ_HANDLED;
304 }
305
306 int omap_request_lcd_dma(void (*callback)(u16 status, void *data),
307                          void *data)
308 {
309         spin_lock_irq(&lcd_dma.lock);
310         if (lcd_dma.reserved) {
311                 spin_unlock_irq(&lcd_dma.lock);
312                 printk(KERN_ERR "LCD DMA channel already reserved\n");
313                 BUG();
314                 return -EBUSY;
315         }
316         lcd_dma.reserved = 1;
317         spin_unlock_irq(&lcd_dma.lock);
318         lcd_dma.callback = callback;
319         lcd_dma.cb_data = data;
320         lcd_dma.active = 0;
321         lcd_dma.single_transfer = 0;
322         lcd_dma.rotate = 0;
323         lcd_dma.vxres = 0;
324         lcd_dma.mirror = 0;
325         lcd_dma.xscale = 0;
326         lcd_dma.yscale = 0;
327         lcd_dma.ext_ctrl = 0;
328         lcd_dma.src_port = 0;
329
330         return 0;
331 }
332 EXPORT_SYMBOL(omap_request_lcd_dma);
333
334 void omap_free_lcd_dma(void)
335 {
336         spin_lock(&lcd_dma.lock);
337         if (!lcd_dma.reserved) {
338                 spin_unlock(&lcd_dma.lock);
339                 printk(KERN_ERR "LCD DMA is not reserved\n");
340                 BUG();
341                 return;
342         }
343         if (!cpu_is_omap15xx())
344                 omap_writew(omap_readw(OMAP1610_DMA_LCD_CCR) & ~1,
345                             OMAP1610_DMA_LCD_CCR);
346         lcd_dma.reserved = 0;
347         spin_unlock(&lcd_dma.lock);
348 }
349 EXPORT_SYMBOL(omap_free_lcd_dma);
350
351 void omap_enable_lcd_dma(void)
352 {
353         u16 w;
354
355         /*
356          * Set the Enable bit only if an external controller is
357          * connected. Otherwise the OMAP internal controller will
358          * start the transfer when it gets enabled.
359          */
360         if (cpu_is_omap15xx() || !lcd_dma.ext_ctrl)
361                 return;
362
363         w = omap_readw(OMAP1610_DMA_LCD_CTRL);
364         w |= 1 << 8;
365         omap_writew(w, OMAP1610_DMA_LCD_CTRL);
366
367         lcd_dma.active = 1;
368
369         w = omap_readw(OMAP1610_DMA_LCD_CCR);
370         w |= 1 << 7;
371         omap_writew(w, OMAP1610_DMA_LCD_CCR);
372 }
373 EXPORT_SYMBOL(omap_enable_lcd_dma);
374
375 void omap_setup_lcd_dma(void)
376 {
377         BUG_ON(lcd_dma.active);
378         if (!cpu_is_omap15xx()) {
379                 /* Set some reasonable defaults */
380                 omap_writew(0x5440, OMAP1610_DMA_LCD_CCR);
381                 omap_writew(0x9102, OMAP1610_DMA_LCD_CSDP);
382                 omap_writew(0x0004, OMAP1610_DMA_LCD_LCH_CTRL);
383         }
384         set_b1_regs();
385         if (!cpu_is_omap15xx()) {
386                 u16 w;
387
388                 w = omap_readw(OMAP1610_DMA_LCD_CCR);
389                 /*
390                  * If DMA was already active set the end_prog bit to have
391                  * the programmed register set loaded into the active
392                  * register set.
393                  */
394                 w |= 1 << 11;           /* End_prog */
395                 if (!lcd_dma.single_transfer)
396                         w |= (3 << 8);  /* Auto_init, repeat */
397                 omap_writew(w, OMAP1610_DMA_LCD_CCR);
398         }
399 }
400 EXPORT_SYMBOL(omap_setup_lcd_dma);
401
402 void omap_stop_lcd_dma(void)
403 {
404         u16 w;
405
406         lcd_dma.active = 0;
407         if (cpu_is_omap15xx() || !lcd_dma.ext_ctrl)
408                 return;
409
410         w = omap_readw(OMAP1610_DMA_LCD_CCR);
411         w &= ~(1 << 7);
412         omap_writew(w, OMAP1610_DMA_LCD_CCR);
413
414         w = omap_readw(OMAP1610_DMA_LCD_CTRL);
415         w &= ~(1 << 8);
416         omap_writew(w, OMAP1610_DMA_LCD_CTRL);
417 }
418 EXPORT_SYMBOL(omap_stop_lcd_dma);
419
420 static int __init omap_init_lcd_dma(void)
421 {
422         int r;
423
424         if (!cpu_class_is_omap1())
425                 return -ENODEV;
426
427         if (cpu_is_omap16xx()) {
428                 u16 w;
429
430                 /* this would prevent OMAP sleep */
431                 w = omap_readw(OMAP1610_DMA_LCD_CTRL);
432                 w &= ~(1 << 8);
433                 omap_writew(w, OMAP1610_DMA_LCD_CTRL);
434         }
435
436         spin_lock_init(&lcd_dma.lock);
437
438         r = request_irq(INT_DMA_LCD, lcd_dma_irq_handler, 0,
439                         "LCD DMA", NULL);
440         if (r != 0)
441                 pr_err("unable to request IRQ for LCD DMA (error %d)\n", r);
442
443         return r;
444 }
445
446 arch_initcall(omap_init_lcd_dma);
447