?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: move U300 GPIO driver to drivers/gpio
[linux-2.6/libata-dev.git] / drivers / video / cfbcopyarea.c
blobbb5a96b1645dc4a46600ee38f387e6d4267f3618
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 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/string.h>
28 #include <linux/fb.h>
29 #include <asm/types.h>
30 #include <asm/io.h>
31 #include "fb_draw.h"
32
33 #if BITS_PER_LONG == 32
34 # define FB_WRITEL fb_writel
35 # define FB_READL fb_readl
36 #else
37 # define FB_WRITEL fb_writeq
38 # define FB_READL fb_readq
39 #endif
40
41 /*
42 * Generic bitwise copy algorithm
43 */
44
45 static void
46 bitcpy(struct fb_info *p, unsigned long __iomem *dst, int dst_idx,
47 const unsigned long __iomem *src, int src_idx, int bits,
48 unsigned n, u32 bswapmask)
49 {
50 unsigned long first, last;
51 int const shift = dst_idx-src_idx;
52 int left, right;
53
54 first = fb_shifted_pixels_mask_long(p, dst_idx, bswapmask);
55 last = ~fb_shifted_pixels_mask_long(p, (dst_idx+n) % bits, bswapmask);
56
57 if (!shift) {
58 // Same alignment for source and dest
59
60 if (dst_idx+n <= bits) {
61 // Single word
62 if (last)
63 first &= last;
64 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
65 } else {
66 // Multiple destination words
67
68 // Leading bits
69 if (first != ~0UL) {
70 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
71 dst++;
72 src++;
73 n -= bits - dst_idx;
74 }
75
76 // Main chunk
77 n /= bits;
78 while (n >= 8) {
79 FB_WRITEL(FB_READL(src++), dst++);
80 FB_WRITEL(FB_READL(src++), dst++);
81 FB_WRITEL(FB_READL(src++), dst++);
82 FB_WRITEL(FB_READL(src++), dst++);
83 FB_WRITEL(FB_READL(src++), dst++);
84 FB_WRITEL(FB_READL(src++), dst++);
85 FB_WRITEL(FB_READL(src++), dst++);
86 FB_WRITEL(FB_READL(src++), dst++);
87 n -= 8;
88 }
89 while (n--)
90 FB_WRITEL(FB_READL(src++), dst++);
91
92 // Trailing bits
93 if (last)
94 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), last), dst);
95 }
96 } else {
97 /* Different alignment for source and dest */
98 unsigned long d0, d1;
99 int m;
100
101 right = shift & (bits - 1);
102 left = -shift & (bits - 1);
103 bswapmask &= shift;
104
105 if (dst_idx+n <= bits) {
106 // Single destination word
107 if (last)
108 first &= last;
109 d0 = FB_READL(src);
110 d0 = fb_rev_pixels_in_long(d0, bswapmask);
111 if (shift > 0) {
112 // Single source word
113 d0 >>= right;
114 } else if (src_idx+n <= bits) {
115 // Single source word
116 d0 <<= left;
117 } else {
118 // 2 source words
119 d1 = FB_READL(src + 1);
120 d1 = fb_rev_pixels_in_long(d1, bswapmask);
121 d0 = d0<<left | d1>>right;
122 }
123 d0 = fb_rev_pixels_in_long(d0, bswapmask);
124 FB_WRITEL(comp(d0, FB_READL(dst), first), dst);
125 } else {
126 // Multiple destination words
127 /** We must always remember the last value read, because in case
128 SRC and DST overlap bitwise (e.g. when moving just one pixel in
129 1bpp), we always collect one full long for DST and that might
130 overlap with the current long from SRC. We store this value in
131 'd0'. */
132 d0 = FB_READL(src++);
133 d0 = fb_rev_pixels_in_long(d0, bswapmask);
134 // Leading bits
135 if (shift > 0) {
136 // Single source word
137 d1 = d0;
138 d0 >>= right;
139 dst++;
140 n -= bits - dst_idx;
141 } else {
142 // 2 source words
143 d1 = FB_READL(src++);
144 d1 = fb_rev_pixels_in_long(d1, bswapmask);
145
146 d0 = d0<<left | d1>>right;
147 dst++;
148 n -= bits - dst_idx;
149 }
150 d0 = fb_rev_pixels_in_long(d0, bswapmask);
151 FB_WRITEL(comp(d0, FB_READL(dst), first), dst);
152 d0 = d1;
153
154 // Main chunk
155 m = n % bits;
156 n /= bits;
157 while ((n >= 4) && !bswapmask) {
158 d1 = FB_READL(src++);
159 FB_WRITEL(d0 << left | d1 >> right, dst++);
160 d0 = d1;
161 d1 = FB_READL(src++);
162 FB_WRITEL(d0 << left | d1 >> right, dst++);
163 d0 = d1;
164 d1 = FB_READL(src++);
165 FB_WRITEL(d0 << left | d1 >> right, dst++);
166 d0 = d1;
167 d1 = FB_READL(src++);
168 FB_WRITEL(d0 << left | d1 >> right, dst++);
169 d0 = d1;
170 n -= 4;
171 }
172 while (n--) {
173 d1 = FB_READL(src++);
174 d1 = fb_rev_pixels_in_long(d1, bswapmask);
175 d0 = d0 << left | d1 >> right;
176 d0 = fb_rev_pixels_in_long(d0, bswapmask);
177 FB_WRITEL(d0, dst++);
178 d0 = d1;
179 }
180
181 // Trailing bits
182 if (last) {
183 if (m <= right) {
184 // Single source word
185 d0 <<= left;
186 } else {
187 // 2 source words
188 d1 = FB_READL(src);
189 d1 = fb_rev_pixels_in_long(d1,
190 bswapmask);
191 d0 = d0<<left | d1>>right;
192 }
193 d0 = fb_rev_pixels_in_long(d0, bswapmask);
194 FB_WRITEL(comp(d0, FB_READL(dst), last), dst);
195 }
196 }
197 }
198 }
199
200 /*
201 * Generic bitwise copy algorithm, operating backward
202 */
203
204 static void
205 bitcpy_rev(struct fb_info *p, unsigned long __iomem *dst, int dst_idx,
206 const unsigned long __iomem *src, int src_idx, int bits,
207 unsigned n, u32 bswapmask)
208 {
209 unsigned long first, last;
210 int shift;
211
212 dst += (n-1)/bits;
213 src += (n-1)/bits;
214 if ((n-1) % bits) {
215 dst_idx += (n-1) % bits;
216 dst += dst_idx >> (ffs(bits) - 1);
217 dst_idx &= bits - 1;
218 src_idx += (n-1) % bits;
219 src += src_idx >> (ffs(bits) - 1);
220 src_idx &= bits - 1;
221 }
222
223 shift = dst_idx-src_idx;
224
225 first = fb_shifted_pixels_mask_long(p, bits - 1 - dst_idx, bswapmask);
226 last = ~fb_shifted_pixels_mask_long(p, bits - 1 - ((dst_idx-n) % bits),
227 bswapmask);
228
229 if (!shift) {
230 // Same alignment for source and dest
231
232 if ((unsigned long)dst_idx+1 >= n) {
233 // Single word
234 if (last)
235 first &= last;
236 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
237 } else {
238 // Multiple destination words
239
240 // Leading bits
241 if (first != ~0UL) {
242 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
243 dst--;
244 src--;
245 n -= dst_idx+1;
246 }
247
248 // Main chunk
249 n /= bits;
250 while (n >= 8) {
251 FB_WRITEL(FB_READL(src--), dst--);
252 FB_WRITEL(FB_READL(src--), dst--);
253 FB_WRITEL(FB_READL(src--), dst--);
254 FB_WRITEL(FB_READL(src--), dst--);
255 FB_WRITEL(FB_READL(src--), dst--);
256 FB_WRITEL(FB_READL(src--), dst--);
257 FB_WRITEL(FB_READL(src--), dst--);
258 FB_WRITEL(FB_READL(src--), dst--);
259 n -= 8;
260 }
261 while (n--)
262 FB_WRITEL(FB_READL(src--), dst--);
263
264 // Trailing bits
265 if (last)
266 FB_WRITEL( comp( FB_READL(src), FB_READL(dst), last), dst);
267 }
268 } else {
269 // Different alignment for source and dest
270 unsigned long d0, d1;
271 int m;
272
273 int const left = -shift & (bits-1);
274 int const right = shift & (bits-1);
275 bswapmask &= shift;
276
277 if ((unsigned long)dst_idx+1 >= n) {
278 // Single destination word
279 if (last)
280 first &= last;
281 d0 = FB_READL(src);
282 if (shift < 0) {
283 // Single source word
284 d0 <<= left;
285 } else if (1+(unsigned long)src_idx >= n) {
286 // Single source word
287 d0 >>= right;
288 } else {
289 // 2 source words
290 d1 = FB_READL(src - 1);
291 d1 = fb_rev_pixels_in_long(d1, bswapmask);
292 d0 = d0>>right | d1<<left;
293 }
294 d0 = fb_rev_pixels_in_long(d0, bswapmask);
295 FB_WRITEL(comp(d0, FB_READL(dst), first), dst);
296 } else {
297 // Multiple destination words
298 /** We must always remember the last value read, because in case
299 SRC and DST overlap bitwise (e.g. when moving just one pixel in
300 1bpp), we always collect one full long for DST and that might
301 overlap with the current long from SRC. We store this value in
302 'd0'. */
303
304 d0 = FB_READL(src--);
305 d0 = fb_rev_pixels_in_long(d0, bswapmask);
306 // Leading bits
307 if (shift < 0) {
308 // Single source word
309 d1 = d0;
310 d0 <<= left;
311 } else {
312 // 2 source words
313 d1 = FB_READL(src--);
314 d1 = fb_rev_pixels_in_long(d1, bswapmask);
315 d0 = d0>>right | d1<<left;
316 }
317 d0 = fb_rev_pixels_in_long(d0, bswapmask);
318 FB_WRITEL(comp(d0, FB_READL(dst), first), dst);
319 d0 = d1;
320 dst--;
321 n -= dst_idx+1;
322
323 // Main chunk
324 m = n % bits;
325 n /= bits;
326 while ((n >= 4) && !bswapmask) {
327 d1 = FB_READL(src--);
328 FB_WRITEL(d0 >> right | d1 << left, dst--);
329 d0 = d1;
330 d1 = FB_READL(src--);
331 FB_WRITEL(d0 >> right | d1 << left, dst--);
332 d0 = d1;
333 d1 = FB_READL(src--);
334 FB_WRITEL(d0 >> right | d1 << left, dst--);
335 d0 = d1;
336 d1 = FB_READL(src--);
337 FB_WRITEL(d0 >> right | d1 << left, dst--);
338 d0 = d1;
339 n -= 4;
340 }
341 while (n--) {
342 d1 = FB_READL(src--);
343 d1 = fb_rev_pixels_in_long(d1, bswapmask);
344 d0 = d0 >> right | d1 << left;
345 d0 = fb_rev_pixels_in_long(d0, bswapmask);
346 FB_WRITEL(d0, dst--);
347 d0 = d1;
348 }
349
350 // Trailing bits
351 if (last) {
352 if (m <= left) {
353 // Single source word
354 d0 >>= right;
355 } else {
356 // 2 source words
357 d1 = FB_READL(src);
358 d1 = fb_rev_pixels_in_long(d1,
359 bswapmask);
360 d0 = d0>>right | d1<<left;
361 }
362 d0 = fb_rev_pixels_in_long(d0, bswapmask);
363 FB_WRITEL(comp(d0, FB_READL(dst), last), dst);
364 }
365 }
366 }
367 }
368
369 void cfb_copyarea(struct fb_info *p, const struct fb_copyarea *area)
370 {
371 u32 dx = area->dx, dy = area->dy, sx = area->sx, sy = area->sy;
372 u32 height = area->height, width = area->width;
373 unsigned long const bits_per_line = p->fix.line_length*8u;
374 unsigned long __iomem *dst = NULL, *src = NULL;
375 int bits = BITS_PER_LONG, bytes = bits >> 3;
376 int dst_idx = 0, src_idx = 0, rev_copy = 0;
377 u32 bswapmask = fb_compute_bswapmask(p);
378
379 if (p->state != FBINFO_STATE_RUNNING)
380 return;
381
382 /* if the beginning of the target area might overlap with the end of
383 the source area, be have to copy the area reverse. */
384 if ((dy == sy && dx > sx) || (dy > sy)) {
385 dy += height;
386 sy += height;
387 rev_copy = 1;
388 }
389
390 // split the base of the framebuffer into a long-aligned address and the
391 // index of the first bit
392 dst = src = (unsigned long __iomem *)((unsigned long)p->screen_base & ~(bytes-1));
393 dst_idx = src_idx = 8*((unsigned long)p->screen_base & (bytes-1));
394 // add offset of source and target area
395 dst_idx += dy*bits_per_line + dx*p->var.bits_per_pixel;
396 src_idx += sy*bits_per_line + sx*p->var.bits_per_pixel;
397
398 if (p->fbops->fb_sync)
399 p->fbops->fb_sync(p);
400
401 if (rev_copy) {
402 while (height--) {
403 dst_idx -= bits_per_line;
404 src_idx -= bits_per_line;
405 dst += dst_idx >> (ffs(bits) - 1);
406 dst_idx &= (bytes - 1);
407 src += src_idx >> (ffs(bits) - 1);
408 src_idx &= (bytes - 1);
409 bitcpy_rev(p, dst, dst_idx, src, src_idx, bits,
410 width*p->var.bits_per_pixel, bswapmask);
411 }
412 } else {
413 while (height--) {
414 dst += dst_idx >> (ffs(bits) - 1);
415 dst_idx &= (bytes - 1);
416 src += src_idx >> (ffs(bits) - 1);
417 src_idx &= (bytes - 1);
418 bitcpy(p, dst, dst_idx, src, src_idx, bits,
419 width*p->var.bits_per_pixel, bswapmask);
420 dst_idx += bits_per_line;
421 src_idx += bits_per_line;
422 }
423 }
424 }
425
426 EXPORT_SYMBOL(cfb_copyarea);
427
428 MODULE_AUTHOR("James Simmons <jsimmons@users.sf.net>");
429 MODULE_DESCRIPTION("Generic software accelerated copyarea");
430 MODULE_LICENSE("GPL");
431
Linux 2.6 libata-dev (mirror)