Revert "[POWERPC] Rename get_property to of_get_property: drivers"
[linux-2.6] / drivers / video / cfbcopyarea.c
1 /*
2  *  Generic function for frame buffer with packed pixels of any depth.
3  *
4  *      Copyright (C)  1999-2005 James Simmons <jsimmons@www.infradead.org>
5  *
6  *  This file is subject to the terms and conditions of the GNU General Public
7  *  License.  See the file COPYING in the main directory of this archive for
8  *  more details.
9  *
10  * NOTES:
11  *
12  *  This is for cfb packed pixels. Iplan and such are incorporated in the
13  *  drivers that need them.
14  *
15  *  FIXME
16  *
17  *  Also need to add code to deal with cards endians that are different than
18  *  the native cpu endians. I also need to deal with MSB position in the word.
19  *
20  *  The two functions or copying forward and backward could be split up like
21  *  the ones for filling, i.e. in aligned and unaligned versions. This would
22  *  help moving some redundant computations and branches out of the loop, too.
23  */
24
25
26
27 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/string.h>
30 #include <linux/fb.h>
31 #include <linux/slab.h>
32 #include <asm/types.h>
33 #include <asm/io.h>
34
35 #if BITS_PER_LONG == 32
36 #  define FB_WRITEL fb_writel
37 #  define FB_READL  fb_readl
38 #else
39 #  define FB_WRITEL fb_writeq
40 #  define FB_READL  fb_readq
41 #endif
42
43     /*
44      *  Compose two values, using a bitmask as decision value
45      *  This is equivalent to (a & mask) | (b & ~mask)
46      */
47
48 static inline unsigned long
49 comp(unsigned long a, unsigned long b, unsigned long mask)
50 {
51     return ((a ^ b) & mask) ^ b;
52 }
53
54     /*
55      *  Generic bitwise copy algorithm
56      */
57
58 static void
59 bitcpy(unsigned long __iomem *dst, int dst_idx, const unsigned long __iomem *src,
60         int src_idx, int bits, unsigned n)
61 {
62         unsigned long first, last;
63         int const shift = dst_idx-src_idx;
64         int left, right;
65
66         first = FB_SHIFT_HIGH(~0UL, dst_idx);
67         last = ~(FB_SHIFT_HIGH(~0UL, (dst_idx+n) % bits));
68
69         if (!shift) {
70                 // Same alignment for source and dest
71
72                 if (dst_idx+n <= bits) {
73                         // Single word
74                         if (last)
75                                 first &= last;
76                         FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
77                 } else {
78                         // Multiple destination words
79
80                         // Leading bits
81                         if (first != ~0UL) {
82                                 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
83                                 dst++;
84                                 src++;
85                                 n -= bits - dst_idx;
86                         }
87
88                         // Main chunk
89                         n /= bits;
90                         while (n >= 8) {
91                                 FB_WRITEL(FB_READL(src++), dst++);
92                                 FB_WRITEL(FB_READL(src++), dst++);
93                                 FB_WRITEL(FB_READL(src++), dst++);
94                                 FB_WRITEL(FB_READL(src++), dst++);
95                                 FB_WRITEL(FB_READL(src++), dst++);
96                                 FB_WRITEL(FB_READL(src++), dst++);
97                                 FB_WRITEL(FB_READL(src++), dst++);
98                                 FB_WRITEL(FB_READL(src++), dst++);
99                                 n -= 8;
100                         }
101                         while (n--)
102                                 FB_WRITEL(FB_READL(src++), dst++);
103
104                         // Trailing bits
105                         if (last)
106                                 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), last), dst);
107                 }
108         } else {
109                 unsigned long d0, d1;
110                 int m;
111                 // Different alignment for source and dest
112
113                 right = shift & (bits - 1);
114                 left = -shift & (bits - 1);
115
116                 if (dst_idx+n <= bits) {
117                         // Single destination word
118                         if (last)
119                                 first &= last;
120                         if (shift > 0) {
121                                 // Single source word
122                                 FB_WRITEL( comp( FB_READL(src) >> right, FB_READL(dst), first), dst);
123                         } else if (src_idx+n <= bits) {
124                                 // Single source word
125                                 FB_WRITEL( comp(FB_READL(src) << left, FB_READL(dst), first), dst);
126                         } else {
127                                 // 2 source words
128                                 d0 = FB_READL(src++);
129                                 d1 = FB_READL(src);
130                                 FB_WRITEL( comp(d0<<left | d1>>right, FB_READL(dst), first), dst);
131                         }
132                 } else {
133                         // Multiple destination words
134                         /** We must always remember the last value read, because in case
135                         SRC and DST overlap bitwise (e.g. when moving just one pixel in
136                         1bpp), we always collect one full long for DST and that might
137                         overlap with the current long from SRC. We store this value in
138                         'd0'. */
139                         d0 = FB_READL(src++);
140                         // Leading bits
141                         if (shift > 0) {
142                                 // Single source word
143                                 FB_WRITEL( comp(d0 >> right, FB_READL(dst), first), dst);
144                                 dst++;
145                                 n -= bits - dst_idx;
146                         } else {
147                                 // 2 source words
148                                 d1 = FB_READL(src++);
149                                 FB_WRITEL( comp(d0<<left | d1>>right, FB_READL(dst), first), dst);
150                                 d0 = d1;
151                                 dst++;
152                                 n -= bits - dst_idx;
153                         }
154
155                         // Main chunk
156                         m = n % bits;
157                         n /= bits;
158                         while (n >= 4) {
159                                 d1 = FB_READL(src++);
160                                 FB_WRITEL(d0 << left | d1 >> right, dst++);
161                                 d0 = d1;
162                                 d1 = FB_READL(src++);
163                                 FB_WRITEL(d0 << left | d1 >> right, dst++);
164                                 d0 = d1;
165                                 d1 = FB_READL(src++);
166                                 FB_WRITEL(d0 << left | d1 >> right, dst++);
167                                 d0 = d1;
168                                 d1 = FB_READL(src++);
169                                 FB_WRITEL(d0 << left | d1 >> right, dst++);
170                                 d0 = d1;
171                                 n -= 4;
172                         }
173                         while (n--) {
174                                 d1 = FB_READL(src++);
175                                 FB_WRITEL(d0 << left | d1 >> right, dst++);
176                                 d0 = d1;
177                         }
178
179                         // Trailing bits
180                         if (last) {
181                                 if (m <= right) {
182                                         // Single source word
183                                         FB_WRITEL( comp(d0 << left, FB_READL(dst), last), dst);
184                                 } else {
185                                         // 2 source words
186                                         d1 = FB_READL(src);
187                                         FB_WRITEL( comp(d0<<left | d1>>right, FB_READL(dst), last), dst);
188                                 }
189                         }
190                 }
191         }
192 }
193
194     /*
195      *  Generic bitwise copy algorithm, operating backward
196      */
197
198 static void
199 bitcpy_rev(unsigned long __iomem *dst, int dst_idx, const unsigned long __iomem *src,
200                 int src_idx, int bits, unsigned n)
201 {
202         unsigned long first, last;
203         int shift;
204
205         dst += (n-1)/bits;
206         src += (n-1)/bits;
207         if ((n-1) % bits) {
208                 dst_idx += (n-1) % bits;
209                 dst += dst_idx >> (ffs(bits) - 1);
210                 dst_idx &= bits - 1;
211                 src_idx += (n-1) % bits;
212                 src += src_idx >> (ffs(bits) - 1);
213                 src_idx &= bits - 1;
214         }
215
216         shift = dst_idx-src_idx;
217
218         first = FB_SHIFT_LOW(~0UL, bits - 1 - dst_idx);
219         last = ~(FB_SHIFT_LOW(~0UL, bits - 1 - ((dst_idx-n) % bits)));
220
221         if (!shift) {
222                 // Same alignment for source and dest
223
224                 if ((unsigned long)dst_idx+1 >= n) {
225                         // Single word
226                         if (last)
227                                 first &= last;
228                         FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
229                 } else {
230                         // Multiple destination words
231
232                         // Leading bits
233                         if (first != ~0UL) {
234                                 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
235                                 dst--;
236                                 src--;
237                                 n -= dst_idx+1;
238                         }
239
240                         // Main chunk
241                         n /= bits;
242                         while (n >= 8) {
243                                 FB_WRITEL(FB_READL(src--), dst--);
244                                 FB_WRITEL(FB_READL(src--), dst--);
245                                 FB_WRITEL(FB_READL(src--), dst--);
246                                 FB_WRITEL(FB_READL(src--), dst--);
247                                 FB_WRITEL(FB_READL(src--), dst--);
248                                 FB_WRITEL(FB_READL(src--), dst--);
249                                 FB_WRITEL(FB_READL(src--), dst--);
250                                 FB_WRITEL(FB_READL(src--), dst--);
251                                 n -= 8;
252                         }
253                         while (n--)
254                                 FB_WRITEL(FB_READL(src--), dst--);
255
256                         // Trailing bits
257                         if (last)
258                                 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), last), dst);
259                 }
260         } else {
261                 // Different alignment for source and dest
262
263                 int const left = -shift & (bits-1);
264                 int const right = shift & (bits-1);
265
266                 if ((unsigned long)dst_idx+1 >= n) {
267                         // Single destination word
268                         if (last)
269                                 first &= last;
270                         if (shift < 0) {
271                                 // Single source word
272                                 FB_WRITEL( comp( FB_READL(src)<<left, FB_READL(dst), first), dst);
273                         } else if (1+(unsigned long)src_idx >= n) {
274                                 // Single source word
275                                 FB_WRITEL( comp( FB_READL(src)>>right, FB_READL(dst), first), dst);
276                         } else {
277                                 // 2 source words
278                                 FB_WRITEL( comp( (FB_READL(src)>>right | FB_READL(src-1)<<left), FB_READL(dst), first), dst);
279                         }
280                 } else {
281                         // Multiple destination words
282                         /** We must always remember the last value read, because in case
283                         SRC and DST overlap bitwise (e.g. when moving just one pixel in
284                         1bpp), we always collect one full long for DST and that might
285                         overlap with the current long from SRC. We store this value in
286                         'd0'. */
287                         unsigned long d0, d1;
288                         int m;
289
290                         d0 = FB_READL(src--);
291                         // Leading bits
292                         if (shift < 0) {
293                                 // Single source word
294                                 FB_WRITEL( comp( (d0 << left), FB_READL(dst), first), dst);
295                         } else {
296                                 // 2 source words
297                                 d1 = FB_READL(src--);
298                                 FB_WRITEL( comp( (d0>>right | d1<<left), FB_READL(dst), first), dst);
299                                 d0 = d1;
300                         }
301                         dst--;
302                         n -= dst_idx+1;
303
304                         // Main chunk
305                         m = n % bits;
306                         n /= bits;
307                         while (n >= 4) {
308                                 d1 = FB_READL(src--);
309                                 FB_WRITEL(d0 >> right | d1 << left, dst--);
310                                 d0 = d1;
311                                 d1 = FB_READL(src--);
312                                 FB_WRITEL(d0 >> right | d1 << left, dst--);
313                                 d0 = d1;
314                                 d1 = FB_READL(src--);
315                                 FB_WRITEL(d0 >> right | d1 << left, dst--);
316                                 d0 = d1;
317                                 d1 = FB_READL(src--);
318                                 FB_WRITEL(d0 >> right | d1 << left, dst--);
319                                 d0 = d1;
320                                 n -= 4;
321                         }
322                         while (n--) {
323                                 d1 = FB_READL(src--);
324                                 FB_WRITEL(d0 >> right | d1 << left, dst--);
325                                 d0 = d1;
326                         }
327
328                         // Trailing bits
329                         if (last) {
330                                 if (m <= left) {
331                                         // Single source word
332                                         FB_WRITEL( comp(d0 >> right, FB_READL(dst), last), dst);
333                                 } else {
334                                         // 2 source words
335                                         d1 = FB_READL(src);
336                                         FB_WRITEL( comp(d0>>right | d1<<left, FB_READL(dst), last), dst);
337                                 }
338                         }
339                 }
340         }
341 }
342
343 void cfb_copyarea(struct fb_info *p, const struct fb_copyarea *area)
344 {
345         u32 dx = area->dx, dy = area->dy, sx = area->sx, sy = area->sy;
346         u32 height = area->height, width = area->width;
347         unsigned long const bits_per_line = p->fix.line_length*8u;
348         unsigned long __iomem *dst = NULL, *src = NULL;
349         int bits = BITS_PER_LONG, bytes = bits >> 3;
350         int dst_idx = 0, src_idx = 0, rev_copy = 0;
351
352         if (p->state != FBINFO_STATE_RUNNING)
353                 return;
354
355         /* if the beginning of the target area might overlap with the end of
356         the source area, be have to copy the area reverse. */
357         if ((dy == sy && dx > sx) || (dy > sy)) {
358                 dy += height;
359                 sy += height;
360                 rev_copy = 1;
361         }
362
363         // split the base of the framebuffer into a long-aligned address and the
364         // index of the first bit
365         dst = src = (unsigned long __iomem *)((unsigned long)p->screen_base & ~(bytes-1));
366         dst_idx = src_idx = 8*((unsigned long)p->screen_base & (bytes-1));
367         // add offset of source and target area
368         dst_idx += dy*bits_per_line + dx*p->var.bits_per_pixel;
369         src_idx += sy*bits_per_line + sx*p->var.bits_per_pixel;
370
371         if (p->fbops->fb_sync)
372                 p->fbops->fb_sync(p);
373
374         if (rev_copy) {
375                 while (height--) {
376                         dst_idx -= bits_per_line;
377                         src_idx -= bits_per_line;
378                         dst += dst_idx >> (ffs(bits) - 1);
379                         dst_idx &= (bytes - 1);
380                         src += src_idx >> (ffs(bits) - 1);
381                         src_idx &= (bytes - 1);
382                         bitcpy_rev(dst, dst_idx, src, src_idx, bits,
383                                 width*p->var.bits_per_pixel);
384                 }
385         } else {
386                 while (height--) {
387                         dst += dst_idx >> (ffs(bits) - 1);
388                         dst_idx &= (bytes - 1);
389                         src += src_idx >> (ffs(bits) - 1);
390                         src_idx &= (bytes - 1);
391                         bitcpy(dst, dst_idx, src, src_idx, bits,
392                                 width*p->var.bits_per_pixel);
393                         dst_idx += bits_per_line;
394                         src_idx += bits_per_line;
395                 }
396         }
397 }
398
399 EXPORT_SYMBOL(cfb_copyarea);
400
401 MODULE_AUTHOR("James Simmons <jsimmons@users.sf.net>");
402 MODULE_DESCRIPTION("Generic software accelerated copyarea");
403 MODULE_LICENSE("GPL");
404