?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / video / cfbcopyarea.c
blobb4b286a4cfb12e61d9b3821df21d0dcfdfb577bd
1 /*
2 * Generic function for frame buffer with packed pixels of any depth.
3 *
4 * Copyright (C) June 1999 James Simmons
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 * The code for 24 bit is horrible. It copies byte by byte size instead of
17 * longs like the other sizes. Needs to be optimized.
18 *
19 * Also need to add code to deal with cards endians that are different than
20 * the native cpu endians. I also need to deal with MSB position in the word.
21 *
22 */
23 #include <linux/config.h>
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/string.h>
27 #include <linux/fb.h>
28 #include <linux/slab.h>
29 #include <asm/types.h>
30 #include <asm/io.h>
31
32 #define LONG_MASK (BITS_PER_LONG - 1)
33
34 #if BITS_PER_LONG == 32
35 #define FB_WRITEL fb_writel
36 #define FB_READL fb_readl
37 #define SHIFT_PER_LONG 5
38 #define BYTES_PER_LONG 4
39 #else
40 #define FB_WRITEL fb_writeq
41 #define FB_READL fb_readq
42 #define SHIFT_PER_LONG 6
43 #define BYTES_PER_LONG 8
44 #endif
45
46 static void bitcpy(unsigned long __iomem *dst, int dst_idx,
47 const unsigned long __iomem *src, int src_idx,
48 unsigned long n)
49 {
50 unsigned long first, last;
51 int shift = dst_idx-src_idx, left, right;
52 unsigned long d0, d1;
53 int m;
54
55 if (!n)
56 return;
57
58 shift = dst_idx-src_idx;
59 first = ~0UL >> dst_idx;
60 last = ~(~0UL >> ((dst_idx+n) % BITS_PER_LONG));
61
62 if (!shift) {
63 // Same alignment for source and dest
64
65 if (dst_idx+n <= BITS_PER_LONG) {
66 // Single word
67 if (last)
68 first &= last;
69 FB_WRITEL((FB_READL(src) & first) | (FB_READL(dst) & ~first), dst);
70 } else {
71 // Multiple destination words
72 // Leading bits
73 if (first) {
74
75 FB_WRITEL((FB_READL(src) & first) |
76 (FB_READL(dst) & ~first), dst);
77 dst++;
78 src++;
79 n -= BITS_PER_LONG-dst_idx;
80 }
81
82 // Main chunk
83 n /= BITS_PER_LONG;
84 while (n >= 8) {
85 FB_WRITEL(FB_READL(src++), dst++);
86 FB_WRITEL(FB_READL(src++), dst++);
87 FB_WRITEL(FB_READL(src++), dst++);
88 FB_WRITEL(FB_READL(src++), dst++);
89 FB_WRITEL(FB_READL(src++), dst++);
90 FB_WRITEL(FB_READL(src++), dst++);
91 FB_WRITEL(FB_READL(src++), dst++);
92 FB_WRITEL(FB_READL(src++), dst++);
93 n -= 8;
94 }
95 while (n--)
96 FB_WRITEL(FB_READL(src++), dst++);
97 // Trailing bits
98 if (last)
99 FB_WRITEL((FB_READL(src) & last) | (FB_READL(dst) & ~last), dst);
100 }
101 } else {
102 // Different alignment for source and dest
103
104 right = shift & (BITS_PER_LONG-1);
105 left = -shift & (BITS_PER_LONG-1);
106
107 if (dst_idx+n <= BITS_PER_LONG) {
108 // Single destination word
109 if (last)
110 first &= last;
111 if (shift > 0) {
112 // Single source word
113 FB_WRITEL(((FB_READL(src) >> right) & first) |
114 (FB_READL(dst) & ~first), dst);
115 } else if (src_idx+n <= BITS_PER_LONG) {
116 // Single source word
117 FB_WRITEL(((FB_READL(src) << left) & first) |
118 (FB_READL(dst) & ~first), dst);
119 } else {
120 // 2 source words
121 d0 = FB_READL(src++);
122 d1 = FB_READL(src);
123 FB_WRITEL(((d0<<left | d1>>right) & first) |
124 (FB_READL(dst) & ~first), dst);
125 }
126 } else {
127 // Multiple destination words
128 d0 = FB_READL(src++);
129 // Leading bits
130 if (shift > 0) {
131 // Single source word
132 FB_WRITEL(((d0 >> right) & first) |
133 (FB_READL(dst) & ~first), dst);
134 dst++;
135 n -= BITS_PER_LONG-dst_idx;
136 } else {
137 // 2 source words
138 d1 = FB_READL(src++);
139 FB_WRITEL(((d0<<left | d1>>right) & first) |
140 (FB_READL(dst) & ~first), dst);
141 d0 = d1;
142 dst++;
143 n -= BITS_PER_LONG-dst_idx;
144 }
145
146 // Main chunk
147 m = n % BITS_PER_LONG;
148 n /= BITS_PER_LONG;
149 while (n >= 4) {
150 d1 = FB_READL(src++);
151 FB_WRITEL(d0 << left | d1 >> right, dst++);
152 d0 = d1;
153 d1 = FB_READL(src++);
154 FB_WRITEL(d0 << left | d1 >> right, dst++);
155 d0 = d1;
156 d1 = FB_READL(src++);
157 FB_WRITEL(d0 << left | d1 >> right, dst++);
158 d0 = d1;
159 d1 = FB_READL(src++);
160 FB_WRITEL(d0 << left | d1 >> right, dst++);
161 d0 = d1;
162 n -= 4;
163 }
164 while (n--) {
165 d1 = FB_READL(src++);
166 FB_WRITEL(d0 << left | d1 >> right, dst++);
167 d0 = d1;
168 }
169
170 // Trailing bits
171 if (last) {
172 if (m <= right) {
173 // Single source word
174 FB_WRITEL(((d0 << left) & last) |
175 (FB_READL(dst) & ~last),
176 dst);
177 } else {
178 // 2 source words
179 d1 = FB_READL(src);
180 FB_WRITEL(((d0<<left | d1>>right) &
181 last) | (FB_READL(dst) &
182 ~last), dst);
183 }
184 }
185 }
186 }
187 }
188
189 static void bitcpy_rev(unsigned long __iomem *dst, int dst_idx,
190 const unsigned long __iomem *src, int src_idx, unsigned long n)
191 {
192 unsigned long first, last;
193 int shift = dst_idx-src_idx, left, right;
194 unsigned long d0, d1;
195 int m;
196
197 if (!n)
198 return;
199
200 dst += (n-1)/BITS_PER_LONG;
201 src += (n-1)/BITS_PER_LONG;
202 if ((n-1) % BITS_PER_LONG) {
203 dst_idx += (n-1) % BITS_PER_LONG;
204 dst += dst_idx >> SHIFT_PER_LONG;
205 dst_idx &= BITS_PER_LONG-1;
206 src_idx += (n-1) % BITS_PER_LONG;
207 src += src_idx >> SHIFT_PER_LONG;
208 src_idx &= BITS_PER_LONG-1;
209 }
210
211 shift = dst_idx-src_idx;
212 first = ~0UL << (BITS_PER_LONG-1-dst_idx);
213 last = ~(~0UL << (BITS_PER_LONG-1-((dst_idx-n) % BITS_PER_LONG)));
214
215 if (!shift) {
216 // Same alignment for source and dest
217
218 if ((unsigned long)dst_idx+1 >= n) {
219 // Single word
220 if (last)
221 first &= last;
222 FB_WRITEL((FB_READL(src) & first) | (FB_READL(dst) & ~first), dst);
223 } else {
224 // Multiple destination words
225 // Leading bits
226 if (first) {
227 FB_WRITEL((FB_READL(src) & first) | (FB_READL(dst) & ~first), dst);
228 dst--;
229 src--;
230 n -= dst_idx+1;
231 }
232
233 // Main chunk
234 n /= BITS_PER_LONG;
235 while (n >= 8) {
236 FB_WRITEL(FB_READL(src--), dst--);
237 FB_WRITEL(FB_READL(src--), dst--);
238 FB_WRITEL(FB_READL(src--), dst--);
239 FB_WRITEL(FB_READL(src--), dst--);
240 FB_WRITEL(FB_READL(src--), dst--);
241 FB_WRITEL(FB_READL(src--), dst--);
242 FB_WRITEL(FB_READL(src--), dst--);
243 FB_WRITEL(FB_READL(src--), dst--);
244 n -= 8;
245 }
246 while (n--)
247 FB_WRITEL(FB_READL(src--), dst--);
248
249 // Trailing bits
250 if (last)
251 FB_WRITEL((FB_READL(src) & last) | (FB_READL(dst) & ~last), dst);
252 }
253 } else {
254 // Different alignment for source and dest
255
256 right = shift & (BITS_PER_LONG-1);
257 left = -shift & (BITS_PER_LONG-1);
258
259 if ((unsigned long)dst_idx+1 >= n) {
260 // Single destination word
261 if (last)
262 first &= last;
263 if (shift < 0) {
264 // Single source word
265 FB_WRITEL((FB_READL(src) << left & first) |
266 (FB_READL(dst) & ~first), dst);
267 } else if (1+(unsigned long)src_idx >= n) {
268 // Single source word
269 FB_WRITEL(((FB_READL(src) >> right) & first) |
270 (FB_READL(dst) & ~first), dst);
271 } else {
272 // 2 source words
273 d0 = FB_READL(src--);
274 d1 = FB_READL(src);
275 FB_WRITEL(((d0>>right | d1<<left) & first) |
276 (FB_READL(dst) & ~first), dst);
277 }
278 } else {
279 // Multiple destination words
280 d0 = FB_READL(src--);
281 // Leading bits
282 if (shift < 0) {
283 // Single source word
284 FB_WRITEL(((d0 << left) & first) |
285 (FB_READL(dst) & ~first), dst);
286 dst--;
287 n -= dst_idx+1;
288 } else {
289 // 2 source words
290 d1 = FB_READL(src--);
291 FB_WRITEL(((d0>>right | d1<<left) & first) |
292 (FB_READL(dst) & ~first), dst);
293 d0 = d1;
294 dst--;
295 n -= dst_idx+1;
296 }
297
298 // Main chunk
299 m = n % BITS_PER_LONG;
300 n /= BITS_PER_LONG;
301 while (n >= 4) {
302 d1 = FB_READL(src--);
303 FB_WRITEL(d0 >> right | d1 << left, dst--);
304 d0 = d1;
305 d1 = FB_READL(src--);
306 FB_WRITEL(d0 >> right | d1 << left, dst--);
307 d0 = d1;
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 n -= 4;
315 }
316 while (n--) {
317 d1 = FB_READL(src--);
318 FB_WRITEL(d0 >> right | d1 << left, dst--);
319 d0 = d1;
320 }
321
322 // Trailing bits
323 if (last) {
324 if (m <= left) {
325 // Single source word
326 FB_WRITEL(((d0 >> right) & last) |
327 (FB_READL(dst) & ~last),
328 dst);
329 } else {
330 // 2 source words
331 d1 = FB_READL(src);
332 FB_WRITEL(((d0>>right | d1<<left) &
333 last) | (FB_READL(dst) &
334 ~last), dst);
335 }
336 }
337 }
338 }
339 }
340
341 void cfb_copyarea(struct fb_info *p, const struct fb_copyarea *area)
342 {
343 u32 dx = area->dx, dy = area->dy, sx = area->sx, sy = area->sy;
344 u32 height = area->height, width = area->width;
345 int x2, y2, old_dx, old_dy, vxres, vyres;
346 unsigned long next_line = p->fix.line_length;
347 int dst_idx = 0, src_idx = 0, rev_copy = 0;
348 unsigned long __iomem *dst = NULL, *src = NULL;
349
350 if (p->state != FBINFO_STATE_RUNNING)
351 return;
352
353 /* We want rotation but lack hardware to do it for us. */
354 if (!p->fbops->fb_rotate && p->var.rotate) {
355 }
356
357 vxres = p->var.xres_virtual;
358 vyres = p->var.yres_virtual;
359
360 if (area->dx > vxres || area->sx > vxres ||
361 area->dy > vyres || area->sy > vyres)
362 return;
363
364 /* clip the destination */
365 old_dx = area->dx;
366 old_dy = area->dy;
367
368 /*
369 * We could use hardware clipping but on many cards you get around
370 * hardware clipping by writing to framebuffer directly.
371 */
372 x2 = area->dx + area->width;
373 y2 = area->dy + area->height;
374 dx = area->dx > 0 ? area->dx : 0;
375 dy = area->dy > 0 ? area->dy : 0;
376 x2 = x2 < vxres ? x2 : vxres;
377 y2 = y2 < vyres ? y2 : vyres;
378 width = x2 - dx;
379 height = y2 - dy;
380
381 /* update sx1,sy1 */
382 sx += (dx - old_dx);
383 sy += (dy - old_dy);
384
385 /* the source must be completely inside the virtual screen */
386 if (sx < 0 || sy < 0 ||
387 (sx + width) > vxres ||
388 (sy + height) > vyres)
389 return;
390
391 if ((dy == sy && dx > sx) ||
392 (dy > sy)) {
393 dy += height;
394 sy += height;
395 rev_copy = 1;
396 }
397
398 dst = src = (unsigned long __iomem *)((unsigned long)p->screen_base &
399 ~(BYTES_PER_LONG-1));
400 dst_idx = src_idx = (unsigned long)p->screen_base & (BYTES_PER_LONG-1);
401 dst_idx += dy*next_line*8 + dx*p->var.bits_per_pixel;
402 src_idx += sy*next_line*8 + sx*p->var.bits_per_pixel;
403
404 if (p->fbops->fb_sync)
405 p->fbops->fb_sync(p);
406 if (rev_copy) {
407 while (height--) {
408 dst_idx -= next_line*8;
409 src_idx -= next_line*8;
410 dst += dst_idx >> SHIFT_PER_LONG;
411 dst_idx &= (BYTES_PER_LONG-1);
412 src += src_idx >> SHIFT_PER_LONG;
413 src_idx &= (BYTES_PER_LONG-1);
414 bitcpy_rev(dst, dst_idx, src, src_idx,
415 width*p->var.bits_per_pixel);
416 }
417 } else {
418 while (height--) {
419 dst += dst_idx >> SHIFT_PER_LONG;
420 dst_idx &= (BYTES_PER_LONG-1);
421 src += src_idx >> SHIFT_PER_LONG;
422 src_idx &= (BYTES_PER_LONG-1);
423 bitcpy(dst, dst_idx, src, src_idx,
424 width*p->var.bits_per_pixel);
425 dst_idx += next_line*8;
426 src_idx += next_line*8;
427 }
428 }
429 }
430
431 EXPORT_SYMBOL(cfb_copyarea);
432
433 MODULE_AUTHOR("James Simmons <jsimmons@users.sf.net>");
434 MODULE_DESCRIPTION("Generic software accelerated copyarea");
435 MODULE_LICENSE("GPL");
436
MOXA 2.6.9 from sdlinux-moxaart.tgz