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