From 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Sat, 16 Apr 2005 15:20:36 -0700 Subject: Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip! --- drivers/video/cfbcopyarea.c | 441 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 441 insertions(+) create mode 100644 drivers/video/cfbcopyarea.c (limited to 'drivers/video/cfbcopyarea.c') diff --git a/drivers/video/cfbcopyarea.c b/drivers/video/cfbcopyarea.c new file mode 100644 index 000000000000..67711f7b11b1 --- /dev/null +++ b/drivers/video/cfbcopyarea.c @@ -0,0 +1,441 @@ +/* + * Generic function for frame buffer with packed pixels of any depth. + * + * Copyright (C) 1999-2005 James Simmons + * + * 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 +#include +#include +#include +#include +#include +#include +#include + +#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 = ~0UL >> dst_idx; + last = ~(~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<>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<>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<>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 = ~0UL << (bits - 1 - dst_idx); + last = ~(~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)<= 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)<>right | d1<= 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<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; + int x2, y2, vxres, vyres; + + if (p->state != FBINFO_STATE_RUNNING) + return; + + /* We want rotation but lack hardware to do it for us. */ + if (!p->fbops->fb_rotate && p->var.rotate) { + } + + vxres = p->var.xres_virtual; + vyres = p->var.yres_virtual; + + if (area->dx > vxres || area->sx > vxres || + area->dy > vyres || area->sy > vyres) + return; + + /* clip the destination + * We could use hardware clipping but on many cards you get around + * hardware clipping by writing to framebuffer directly. + */ + x2 = area->dx + area->width; + y2 = area->dy + area->height; + dx = area->dx > 0 ? area->dx : 0; + dy = area->dy > 0 ? area->dy : 0; + x2 = x2 < vxres ? x2 : vxres; + y2 = y2 < vyres ? y2 : vyres; + width = x2 - dx; + height = y2 - dy; + + if ((width==0) ||(height==0)) + return; + + /* update sx1,sy1 */ + sx += (dx - area->dx); + sy += (dy - area->dy); + + /* the source must be completely inside the virtual screen */ + if (sx < 0 || sy < 0 || (sx + width) > vxres || (sy + height) > vyres) + 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 "); +MODULE_DESCRIPTION("Generic software accelerated copyarea"); +MODULE_LICENSE("GPL"); + -- cgit v1.2.3