kernel/drivers/video/fbdev/core/syscopyarea.c

   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