SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/video/cfbcopyarea.c

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