[linux-block.git] / drivers / video / cfbcopyarea.c

/*
 *  Generic function for frame buffer with packed pixels of any depth.
 *
 *      Copyright (C)  1999-2005 James Simmons <jsimmons@www.infradead.org>
 *
 *  This file is subject to the terms and conditions of the GNU General Public
 *  License.  See the file COPYING in the main directory of this archive for
 *  more details.
 *
 * NOTES:
 *
 *  This is for cfb packed pixels. Iplan and such are incorporated in the
 *  drivers that need them.
 *
 *  FIXME
 *
 *  Also need to add code to deal with cards endians that are different than
 *  the native cpu endians. I also need to deal with MSB position in the word.
 *
 *  The two functions or copying forward and backward could be split up like
 *  the ones for filling, i.e. in aligned and unaligned versions. This would
 *  help moving some redundant computations and branches out of the loop, too.
 */


#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/fb.h>
#include <linux/slab.h>
#include <asm/types.h>
#include <asm/io.h>

#if BITS_PER_LONG == 32
#  define FB_WRITEL fb_writel
#  define FB_READL  fb_readl
#else
#  define FB_WRITEL fb_writeq
#  define FB_READL  fb_readq
#endif

    /*
     *  Compose two values, using a bitmask as decision value
     *  This is equivalent to (a & mask) | (b & ~mask)
     */

static inline unsigned long
comp(unsigned long a, unsigned long b, unsigned long mask)
{
    return ((a ^ b) & mask) ^ b;
}

    /*
     *  Generic bitwise copy algorithm
     */

static void
bitcpy(unsigned long __iomem *dst, int dst_idx, const unsigned long __iomem *src,
	int src_idx, int bits, unsigned n)
{
	unsigned long first, last;
	int const shift = dst_idx-src_idx;
	int left, right;

	first = FB_SHIFT_HIGH(~0UL, dst_idx);
	last = ~(FB_SHIFT_HIGH(~0UL, (dst_idx+n) % bits));

	if (!shift) {
		// Same alignment for source and dest

		if (dst_idx+n <= bits) {
			// Single word
			if (last)
				first &= last;
			FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
		} else {
			// Multiple destination words

			// Leading bits
			if (first != ~0UL) {
				FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
				dst++;
				src++;
				n -= bits - dst_idx;
			}

			// Main chunk
			n /= bits;
			while (n >= 8) {
				FB_WRITEL(FB_READL(src++), dst++);
				FB_WRITEL(FB_READL(src++), dst++);
				FB_WRITEL(FB_READL(src++), dst++);
				FB_WRITEL(FB_READL(src++), dst++);
				FB_WRITEL(FB_READL(src++), dst++);
				FB_WRITEL(FB_READL(src++), dst++);
				FB_WRITEL(FB_READL(src++), dst++);
				FB_WRITEL(FB_READL(src++), dst++);
				n -= 8;
			}
			while (n--)
				FB_WRITEL(FB_READL(src++), dst++);

			// Trailing bits
			if (last)
				FB_WRITEL( comp( FB_READL(src), FB_READL(dst), last), dst);
		}
	} else {
		unsigned long d0, d1;
		int m;
		// Different alignment for source and dest

		right = shift & (bits - 1);
		left = -shift & (bits - 1);

		if (dst_idx+n <= bits) {
			// Single destination word
			if (last)
				first &= last;
			if (shift > 0) {
				// Single source word
				FB_WRITEL( comp( FB_READL(src) >> right, FB_READL(dst), first), dst);
			} else if (src_idx+n <= bits) {
				// Single source word
				FB_WRITEL( comp(FB_READL(src) << left, FB_READL(dst), first), dst);
			} else {
				// 2 source words
				d0 = FB_READL(src++);
				d1 = FB_READL(src);
				FB_WRITEL( comp(d0<<left | d1>>right, FB_READL(dst), first), dst);
			}
		} else {
			// Multiple destination words
			/** We must always remember the last value read, because in case
			SRC and DST overlap bitwise (e.g. when moving just one pixel in
			1bpp), we always collect one full long for DST and that might
			overlap with the current long from SRC. We store this value in
			'd0'. */
			d0 = FB_READL(src++);
			// Leading bits
			if (shift > 0) {
				// Single source word
				FB_WRITEL( comp(d0 >> right, FB_READL(dst), first), dst);
				dst++;
				n -= bits - dst_idx;
			} else {
				// 2 source words
				d1 = FB_READL(src++);
				FB_WRITEL( comp(d0<<left | d1>>right, FB_READL(dst), first), dst);
				d0 = d1;
				dst++;
				n -= bits - dst_idx;
			}

			// Main chunk
			m = n % bits;
			n /= bits;
			while (n >= 4) {
				d1 = FB_READL(src++);
				FB_WRITEL(d0 << left | d1 >> right, dst++);
				d0 = d1;
				d1 = FB_READL(src++);
				FB_WRITEL(d0 << left | d1 >> right, dst++);
				d0 = d1;
				d1 = FB_READL(src++);
				FB_WRITEL(d0 << left | d1 >> right, dst++);
				d0 = d1;
				d1 = FB_READL(src++);
				FB_WRITEL(d0 << left | d1 >> right, dst++);
				d0 = d1;
				n -= 4;
			}
			while (n--) {
				d1 = FB_READL(src++);
				FB_WRITEL(d0 << left | d1 >> right, dst++);
				d0 = d1;
			}

			// Trailing bits
			if (last) {
				if (m <= right) {
					// Single source word
					FB_WRITEL( comp(d0 << left, FB_READL(dst), last), dst);
				} else {
					// 2 source words
					d1 = FB_READL(src);
					FB_WRITEL( comp(d0<<left | d1>>right, FB_READL(dst), last), dst);
				}
			}
		}
	}
}

    /*
     *  Generic bitwise copy algorithm, operating backward
     */

static void
bitcpy_rev(unsigned long __iomem *dst, int dst_idx, const unsigned long __iomem *src,
		int src_idx, int bits, unsigned n)
{
	unsigned long first, last;
	int shift;

	dst += (n-1)/bits;
	src += (n-1)/bits;
	if ((n-1) % bits) {
		dst_idx += (n-1) % bits;
		dst += dst_idx >> (ffs(bits) - 1);
		dst_idx &= bits - 1;
		src_idx += (n-1) % bits;
		src += src_idx >> (ffs(bits) - 1);
		src_idx &= bits - 1;
	}

	shift = dst_idx-src_idx;

	first = FB_SHIFT_LOW(~0UL, bits - 1 - dst_idx);
	last = ~(FB_SHIFT_LOW(~0UL, bits - 1 - ((dst_idx-n) % bits)));

	if (!shift) {
		// Same alignment for source and dest

		if ((unsigned long)dst_idx+1 >= n) {
			// Single word
			if (last)
				first &= last;
			FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
		} else {
			// Multiple destination words

			// Leading bits
			if (first != ~0UL) {
				FB_WRITEL( comp( FB_READL(src), FB_READL(dst), first), dst);
				dst--;
				src--;
				n -= dst_idx+1;
			}

			// Main chunk
			n /= bits;
			while (n >= 8) {
				FB_WRITEL(FB_READL(src--), dst--);
				FB_WRITEL(FB_READL(src--), dst--);
				FB_WRITEL(FB_READL(src--), dst--);
				FB_WRITEL(FB_READL(src--), dst--);
				FB_WRITEL(FB_READL(src--), dst--);
				FB_WRITEL(FB_READL(src--), dst--);
				FB_WRITEL(FB_READL(src--), dst--);
				FB_WRITEL(FB_READL(src--), dst--);
				n -= 8;
			}
			while (n--)
				FB_WRITEL(FB_READL(src--), dst--);

			// Trailing bits
			if (last)
				FB_WRITEL( comp( FB_READL(src), FB_READL(dst), last), dst);
		}
	} else {
		// Different alignment for source and dest

		int const left = -shift & (bits-1);
		int const right = shift & (bits-1);

		if ((unsigned long)dst_idx+1 >= n) {
			// Single destination word
			if (last)
				first &= last;
			if (shift < 0) {
				// Single source word
				FB_WRITEL( comp( FB_READL(src)<<left, FB_READL(dst), first), dst);
			} else if (1+(unsigned long)src_idx >= n) {
				// Single source word
				FB_WRITEL( comp( FB_READL(src)>>right, FB_READL(dst), first), dst);
			} else {
				// 2 source words
				FB_WRITEL( comp( (FB_READL(src)>>right | FB_READL(src-1)<<left), FB_READL(dst), first), dst);
			}
		} else {
			// Multiple destination words
			/** We must always remember the last value read, because in case
			SRC and DST overlap bitwise (e.g. when moving just one pixel in
			1bpp), we always collect one full long for DST and that might
			overlap with the current long from SRC. We store this value in
			'd0'. */
			unsigned long d0, d1;
			int m;

			d0 = FB_READL(src--);
			// Leading bits
			if (shift < 0) {
				// Single source word
				FB_WRITEL( comp( (d0 << left), FB_READL(dst), first), dst);
			} else {
				// 2 source words
				d1 = FB_READL(src--);
				FB_WRITEL( comp( (d0>>right | d1<<left), FB_READL(dst), first), dst);
				d0 = d1;
			}
			dst--;
			n -= dst_idx+1;

			// Main chunk
			m = n % bits;
			n /= bits;
			while (n >= 4) {
				d1 = FB_READL(src--);
				FB_WRITEL(d0 >> right | d1 << left, dst--);
				d0 = d1;
				d1 = FB_READL(src--);
				FB_WRITEL(d0 >> right | d1 << left, dst--);
				d0 = d1;
				d1 = FB_READL(src--);
				FB_WRITEL(d0 >> right | d1 << left, dst--);
				d0 = d1;
				d1 = FB_READL(src--);
				FB_WRITEL(d0 >> right | d1 << left, dst--);
				d0 = d1;
				n -= 4;
			}
			while (n--) {
				d1 = FB_READL(src--);
				FB_WRITEL(d0 >> right | d1 << left, dst--);
				d0 = d1;
			}

			// Trailing bits
			if (last) {
				if (m <= left) {
					// Single source word
					FB_WRITEL( comp(d0 >> right, FB_READL(dst), last), dst);
				} else {
					// 2 source words
					d1 = FB_READL(src);
					FB_WRITEL( comp(d0>>right | d1<<left, FB_READL(dst), last), dst);
				}
			}
		}
	}
}

void cfb_copyarea(struct fb_info *p, const struct fb_copyarea *area)
{
	u32 dx = area->dx, dy = area->dy, sx = area->sx, sy = area->sy;
	u32 height = area->height, width = area->width;
	unsigned long const bits_per_line = p->fix.line_length*8u;
	unsigned long __iomem *dst = NULL, *src = NULL;
	int bits = BITS_PER_LONG, bytes = bits >> 3;
	int dst_idx = 0, src_idx = 0, rev_copy = 0;

	if (p->state != FBINFO_STATE_RUNNING)
		return;

	/* if the beginning of the target area might overlap with the end of
	the source area, be have to copy the area reverse. */
	if ((dy == sy && dx > sx) || (dy > sy)) {
		dy += height;
		sy += height;
		rev_copy = 1;
	}

	// split the base of the framebuffer into a long-aligned address and the
	// index of the first bit
	dst = src = (unsigned long __iomem *)((unsigned long)p->screen_base & ~(bytes-1));
	dst_idx = src_idx = 8*((unsigned long)p->screen_base & (bytes-1));
	// add offset of source and target area
	dst_idx += dy*bits_per_line + dx*p->var.bits_per_pixel;
	src_idx += sy*bits_per_line + sx*p->var.bits_per_pixel;

	if (p->fbops->fb_sync)
		p->fbops->fb_sync(p);

	if (rev_copy) {
		while (height--) {
			dst_idx -= bits_per_line;
			src_idx -= bits_per_line;
			dst += dst_idx >> (ffs(bits) - 1);
			dst_idx &= (bytes - 1);
			src += src_idx >> (ffs(bits) - 1);
			src_idx &= (bytes - 1);
			bitcpy_rev(dst, dst_idx, src, src_idx, bits,
				width*p->var.bits_per_pixel);
		}
	} else {
		while (height--) {
			dst += dst_idx >> (ffs(bits) - 1);
			dst_idx &= (bytes - 1);
			src += src_idx >> (ffs(bits) - 1);
			src_idx &= (bytes - 1);
			bitcpy(dst, dst_idx, src, src_idx, bits,
				width*p->var.bits_per_pixel);
			dst_idx += bits_per_line;
			src_idx += bits_per_line;
		}
	}
}

EXPORT_SYMBOL(cfb_copyarea);

MODULE_AUTHOR("James Simmons <jsimmons@users.sf.net>");
MODULE_DESCRIPTION("Generic software accelerated copyarea");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	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
1da177e4 LT	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
be0d9b6c AD	66	first = FB_SHIFT_HIGH(~0UL, dst_idx);
be0d9b6c AD	67	last = ~(FB_SHIFT_HIGH(~0UL, (dst_idx+n) % bits));
1da177e4 LT	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
be0d9b6c AD	218	first = FB_SHIFT_LOW(~0UL, bits - 1 - dst_idx);
be0d9b6c AD	219	last = ~(FB_SHIFT_LOW(~0UL, bits - 1 - ((dst_idx-n) % bits)));
1da177e4 LT	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;
1da177e4 LT	351
	352	if (p->state != FBINFO_STATE_RUNNING)
	353	return;
	354
1da177e4 LT	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 += dybits_per_line + dxp->var.bits_per_pixel;
	369	src_idx += sybits_per_line + sxp->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