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 long 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