1 /*
2 * Generic Bit Block Transfer for frame buffers located in system RAM with
3 * packed pixels of any depth.
4 *
5 * Based almost entirely from cfbcopyarea.c (which is based almost entirely
6 * on Geert Uytterhoeven's copyarea routine)
7 *
8 * Copyright (C) 2007 Antonino Daplas <adaplas@pol.net>
9 *
10 * This file is subject to the terms and conditions of the GNU General Public
11 * License. See the file COPYING in the main directory of this archive for
12 * more details.
13 *
14 */
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/string.h>
18 #include <linux/fb.h>
19 #include <asm/types.h>
20 #include <asm/io.h>
21 #include "fb_draw.h"
22
23 /*
24 * Generic bitwise copy algorithm
25 */
26
27 static void
28 bitcpy(struct fb_info *p, unsigned long *dst, unsigned dst_idx,
29 const unsigned long *src, unsigned src_idx, int bits, unsigned n)
30 {
31 unsigned long first, last;
32 int const shift = dst_idx-src_idx;
33 int left, right;
34
35 first = FB_SHIFT_HIGH(p, ~0UL, dst_idx);
36 last = ~(FB_SHIFT_HIGH(p, ~0UL, (dst_idx+n) % bits));
37
38 if (!shift) {
39 /* Same alignment for source and dest */
40 if (dst_idx+n <= bits) {
41 /* Single word */
42 if (last)
43 first &= last;
44 *dst = comp(*src, *dst, first);
45 } else {
46 /* Multiple destination words */
47 /* Leading bits */
48 if (first != ~0UL) {
49 *dst = comp(*src, *dst, first);
50 dst++;
51 src++;
52 n -= bits - dst_idx;
53 }
54
55 /* Main chunk */
56 n /= bits;
57 while (n >= 8) {
58 *dst++ = *src++;
59 *dst++ = *src++;
60 *dst++ = *src++;
61 *dst++ = *src++;
62 *dst++ = *src++;
63 *dst++ = *src++;
64 *dst++ = *src++;
65 *dst++ = *src++;
66 n -= 8;
67 }
68 while (n--)
69 *dst++ = *src++;
70
71 /* Trailing bits */
72 if (last)
73 *dst = comp(*src, *dst, last);
74 }
75 } else {
76 unsigned long d0, d1;
77 int m;
78
79 /* Different alignment for source and dest */
80 right = shift & (bits - 1);
81 left = -shift & (bits - 1);
82
83 if (dst_idx+n <= bits) {
84 /* Single destination word */
85 if (last)
86 first &= last;
87 if (shift > 0) {
88 /* Single source word */
89 *dst = comp(*src << left, *dst, first);
90 } else if (src_idx+n <= bits) {
91 /* Single source word */
92 *dst = comp(*src >> right, *dst, first);
93 } else {
94 /* 2 source words */
95 d0 = *src++;
96 d1 = *src;
97 *dst = comp(d0 >> right | d1 << left, *dst,
98 first);
99 }
100 } else {
101 /* Multiple destination words */
102 /** We must always remember the last value read,
103 because in case SRC and DST overlap bitwise (e.g.
104 when moving just one pixel in 1bpp), we always
105 collect one full long for DST and that might
106 overlap with the current long from SRC. We store
107 this value in 'd0'. */
108 d0 = *src++;
109 /* Leading bits */
110 if (shift > 0) {
111 /* Single source word */
112 *dst = comp(d0 << left, *dst, first);
113 dst++;
114 n -= bits - dst_idx;
115 } else {
116 /* 2 source words */
117 d1 = *src++;
118 *dst = comp(d0 >> right | d1 << left, *dst,
119 first);
120 d0 = d1;
121 dst++;
122 n -= bits - dst_idx;
123 }
124
125 /* Main chunk */
126 m = n % bits;
127 n /= bits;
128 while (n >= 4) {
129 d1 = *src++;
130 *dst++ = d0 >> right | d1 << left;
131 d0 = d1;
132 d1 = *src++;
133 *dst++ = d0 >> right | d1 << left;
134 d0 = d1;
135 d1 = *src++;
136 *dst++ = d0 >> right | d1 << left;
137 d0 = d1;
138 d1 = *src++;
139 *dst++ = d0 >> right | d1 << left;
140 d0 = d1;
141 n -= 4;
142 }
143 while (n--) {
144 d1 = *src++;
145 *dst++ = d0 >> right | d1 << left;
146 d0 = d1;
147 }
148
149 /* Trailing bits */
150 if (m) {
151 if (m <= bits - right) {
152 /* Single source word */
153 d0 >>= right;
154 } else {
155 /* 2 source words */
156 d1 = *src;
157 d0 = d0 >> right | d1 << left;
158 }
159 *dst = comp(d0, *dst, last);
160 }
161 }
162 }
163 }
164
165 /*
166 * Generic bitwise copy algorithm, operating backward
167 */
168
169 static void
170 bitcpy_rev(struct fb_info *p, unsigned long *dst, unsigned dst_idx,
171 const unsigned long *src, unsigned src_idx, unsigned bits,
172 unsigned n)
173 {
174 unsigned long first, last;
175 int shift;
176
177 dst += (dst_idx + n - 1) / bits;
178 src += (src_idx + n - 1) / bits;
179 dst_idx = (dst_idx + n - 1) % bits;
180 src_idx = (src_idx + n - 1) % bits;
181
182 shift = dst_idx-src_idx;
183
184 first = ~FB_SHIFT_HIGH(p, ~0UL, (dst_idx + 1) % bits);
185 last = FB_SHIFT_HIGH(p, ~0UL, (bits + dst_idx + 1 - n) % bits);
186
187 if (!shift) {
188 /* Same alignment for source and dest */
189 if ((unsigned long)dst_idx+1 >= n) {
190 /* Single word */
191 if (first)
192 last &= first;
193 *dst = comp(*src, *dst, last);
194 } else {
195 /* Multiple destination words */
196
197 /* Leading bits */
198 if (first) {
199 *dst = comp(*src, *dst, first);
200 dst--;
201 src--;
202 n -= dst_idx+1;
203 }
204
205 /* Main chunk */
206 n /= bits;
207 while (n >= 8) {
208 *dst-- = *src--;
209 *dst-- = *src--;
210 *dst-- = *src--;
211 *dst-- = *src--;
212 *dst-- = *src--;
213 *dst-- = *src--;
214 *dst-- = *src--;
215 *dst-- = *src--;
216 n -= 8;
217 }
218 while (n--)
219 *dst-- = *src--;
220 /* Trailing bits */
221 if (last != -1UL)
222 *dst = comp(*src, *dst, last);
223 }
224 } else {
225 /* Different alignment for source and dest */
226
227 int const left = shift & (bits-1);
228 int const right = -shift & (bits-1);
229
230 if ((unsigned long)dst_idx+1 >= n) {
231 /* Single destination word */
232 if (first)
233 last &= first;
234 if (shift < 0) {
235 /* Single source word */
236 *dst = comp(*src >> right, *dst, last);
237 } else if (1+(unsigned long)src_idx >= n) {
238 /* Single source word */
239 *dst = comp(*src << left, *dst, last);
240 } else {
241 /* 2 source words */
242 *dst = comp(*src << left | *(src-1) >> right,
243 *dst, last);
244 }
245 } else {
246 /* Multiple destination words */
247 /** We must always remember the last value read,
248 because in case SRC and DST overlap bitwise (e.g.
249 when moving just one pixel in 1bpp), we always
250 collect one full long for DST and that might
251 overlap with the current long from SRC. We store
252 this value in 'd0'. */
253 unsigned long d0, d1;
254 int m;
255
256 d0 = *src--;
257 /* Leading bits */
258 if (shift < 0) {
259 /* Single source word */
260 d1 = d0;
261 d0 >>= right;
262 } else {
263 /* 2 source words */
264 d1 = *src--;
265 d0 = d0 << left | d1 >> right;
266 }
267 if (!first)
268 *dst = d0;
269 else
270 *dst = comp(d0, *dst, first);
271 d0 = d1;
272 dst--;
273 n -= dst_idx+1;
274
275 /* Main chunk */
276 m = n % bits;
277 n /= bits;
278 while (n >= 4) {
279 d1 = *src--;
280 *dst-- = d0 << left | d1 >> right;
281 d0 = d1;
282 d1 = *src--;
283 *dst-- = d0 << left | d1 >> right;
284 d0 = d1;
285 d1 = *src--;
286 *dst-- = d0 << left | d1 >> right;
287 d0 = d1;
288 d1 = *src--;
289 *dst-- = d0 << left | d1 >> right;
290 d0 = d1;
291 n -= 4;
292 }
293 while (n--) {
294 d1 = *src--;
295 *dst-- = d0 << left | d1 >> right;
296 d0 = d1;
297 }
298
299 /* Trailing bits */
300 if (m) {
301 if (m <= bits - left) {
302 /* Single source word */
303 d0 <<= left;
304 } else {
305 /* 2 source words */
306 d1 = *src;
307 d0 = d0 << left | d1 >> right;
308 }
309 *dst = comp(d0, *dst, last);
310 }
311 }
312 }
313 }
314
315 void sys_copyarea(struct fb_info *p, const struct fb_copyarea *area)
316 {
317 u32 dx = area->dx, dy = area->dy, sx = area->sx, sy = area->sy;
318 u32 height = area->height, width = area->width;
319 unsigned long const bits_per_line = p->fix.line_length*8u;
320 unsigned long *base = NULL;
321 int bits = BITS_PER_LONG, bytes = bits >> 3;
322 unsigned dst_idx = 0, src_idx = 0, rev_copy = 0;
323
324 if (p->state != FBINFO_STATE_RUNNING)
325 return;
326
327 /* if the beginning of the target area might overlap with the end of
328 the source area, be have to copy the area reverse. */
329 if ((dy == sy && dx > sx) || (dy > sy)) {
330 dy += height;
331 sy += height;
332 rev_copy = 1;
333 }
334
335 /* split the base of the framebuffer into a long-aligned address and
336 the index of the first bit */
337 base = (unsigned long *)((unsigned long)p->screen_base & ~(bytes-1));
338 dst_idx = src_idx = 8*((unsigned long)p->screen_base & (bytes-1));
339 /* add offset of source and target area */
340 dst_idx += dy*bits_per_line + dx*p->var.bits_per_pixel;
341 src_idx += sy*bits_per_line + sx*p->var.bits_per_pixel;
342
343 if (p->fbops->fb_sync)
344 p->fbops->fb_sync(p);
345
346 if (rev_copy) {
347 while (height--) {
348 dst_idx -= bits_per_line;
349 src_idx -= bits_per_line;
350 bitcpy_rev(p, base + (dst_idx / bits), dst_idx % bits,
351 base + (src_idx / bits), src_idx % bits, bits,
352 width*p->var.bits_per_pixel);
353 }
354 } else {
355 while (height--) {
356 bitcpy(p, base + (dst_idx / bits), dst_idx % bits,
357 base + (src_idx / bits), src_idx % bits, bits,
358 width*p->var.bits_per_pixel);
359 dst_idx += bits_per_line;
360 src_idx += bits_per_line;
361 }
362 }
363 }
364
365 EXPORT_SYMBOL(sys_copyarea);
366
367 MODULE_AUTHOR("Antonino Daplas <adaplas@pol.net>");
368 MODULE_DESCRIPTION("Generic copyarea (sys-to-sys)");
369 MODULE_LICENSE("GPL");
370