?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: w1_netlink: New init/fini netlink callbacks.
[linux-2.6/verdex.git] / drivers / video / cfbfillrect.c
blobe4fc42b013ebdb7f3bab16ef7f33c0d4d7a2573f
1 /*
2 * Generic fillrect for frame buffers with packed pixels of any depth.
3 *
4 * Copyright (C) 2000 James Simmons (jsimmons@linux-fbdev.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 * The code for depths like 24 that don't have integer number of pixels per
13 * long is broken and needs to be fixed. For now I turned these types of
14 * mode off.
15 *
16 * Also need to add code to deal with cards endians that are different than
17 * the native cpu endians. I also need to deal with MSB position in the word.
18 *
19 */
20 #include <linux/config.h>
21 #include <linux/module.h>
22 #include <linux/string.h>
23 #include <linux/fb.h>
24 #include <asm/types.h>
25
26 #if BITS_PER_LONG == 32
27 # define FB_WRITEL fb_writel
28 # define FB_READL fb_readl
29 #else
30 # define FB_WRITEL fb_writeq
31 # define FB_READL fb_readq
32 #endif
33
34 /*
35 * Compose two values, using a bitmask as decision value
36 * This is equivalent to (a & mask) | (b & ~mask)
37 */
38
39 static inline unsigned long
40 comp(unsigned long a, unsigned long b, unsigned long mask)
41 {
42 return ((a ^ b) & mask) ^ b;
43 }
44
45 /*
46 * Create a pattern with the given pixel's color
47 */
48
49 #if BITS_PER_LONG == 64
50 static inline unsigned long
51 pixel_to_pat( u32 bpp, u32 pixel)
52 {
53 switch (bpp) {
54 case 1:
55 return 0xfffffffffffffffful*pixel;
56 case 2:
57 return 0x5555555555555555ul*pixel;
58 case 4:
59 return 0x1111111111111111ul*pixel;
60 case 8:
61 return 0x0101010101010101ul*pixel;
62 case 12:
63 return 0x0001001001001001ul*pixel;
64 case 16:
65 return 0x0001000100010001ul*pixel;
66 case 24:
67 return 0x0000000001000001ul*pixel;
68 case 32:
69 return 0x0000000100000001ul*pixel;
70 default:
71 panic("pixel_to_pat(): unsupported pixelformat\n");
72 }
73 }
74 #else
75 static inline unsigned long
76 pixel_to_pat( u32 bpp, u32 pixel)
77 {
78 switch (bpp) {
79 case 1:
80 return 0xfffffffful*pixel;
81 case 2:
82 return 0x55555555ul*pixel;
83 case 4:
84 return 0x11111111ul*pixel;
85 case 8:
86 return 0x01010101ul*pixel;
87 case 12:
88 return 0x00001001ul*pixel;
89 case 16:
90 return 0x00010001ul*pixel;
91 case 24:
92 return 0x00000001ul*pixel;
93 case 32:
94 return 0x00000001ul*pixel;
95 default:
96 panic("pixel_to_pat(): unsupported pixelformat\n");
97 }
98 }
99 #endif
100
101 /*
102 * Aligned pattern fill using 32/64-bit memory accesses
103 */
104
105 static void
106 bitfill_aligned(unsigned long __iomem *dst, int dst_idx, unsigned long pat, unsigned n, int bits)
107 {
108 unsigned long first, last;
109
110 if (!n)
111 return;
112
113 first = ~0UL >> dst_idx;
114 last = ~(~0UL >> ((dst_idx+n) % bits));
115
116 if (dst_idx+n <= bits) {
117 // Single word
118 if (last)
119 first &= last;
120 FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
121 } else {
122 // Multiple destination words
123
124 // Leading bits
125 if (first!= ~0UL) {
126 FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
127 dst++;
128 n -= bits - dst_idx;
129 }
130
131 // Main chunk
132 n /= bits;
133 while (n >= 8) {
134 FB_WRITEL(pat, dst++);
135 FB_WRITEL(pat, dst++);
136 FB_WRITEL(pat, dst++);
137 FB_WRITEL(pat, dst++);
138 FB_WRITEL(pat, dst++);
139 FB_WRITEL(pat, dst++);
140 FB_WRITEL(pat, dst++);
141 FB_WRITEL(pat, dst++);
142 n -= 8;
143 }
144 while (n--)
145 FB_WRITEL(pat, dst++);
146
147 // Trailing bits
148 if (last)
149 FB_WRITEL(comp(pat, FB_READL(dst), last), dst);
150 }
151 }
152
153
154 /*
155 * Unaligned generic pattern fill using 32/64-bit memory accesses
156 * The pattern must have been expanded to a full 32/64-bit value
157 * Left/right are the appropriate shifts to convert to the pattern to be
158 * used for the next 32/64-bit word
159 */
160
161 static void
162 bitfill_unaligned(unsigned long __iomem *dst, int dst_idx, unsigned long pat,
163 int left, int right, unsigned n, int bits)
164 {
165 unsigned long first, last;
166
167 if (!n)
168 return;
169
170 first = ~0UL >> dst_idx;
171 last = ~(~0UL >> ((dst_idx+n) % bits));
172
173 if (dst_idx+n <= bits) {
174 // Single word
175 if (last)
176 first &= last;
177 FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
178 } else {
179 // Multiple destination words
180 // Leading bits
181 if (first) {
182 FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
183 dst++;
184 pat = pat << left | pat >> right;
185 n -= bits - dst_idx;
186 }
187
188 // Main chunk
189 n /= bits;
190 while (n >= 4) {
191 FB_WRITEL(pat, dst++);
192 pat = pat << left | pat >> right;
193 FB_WRITEL(pat, dst++);
194 pat = pat << left | pat >> right;
195 FB_WRITEL(pat, dst++);
196 pat = pat << left | pat >> right;
197 FB_WRITEL(pat, dst++);
198 pat = pat << left | pat >> right;
199 n -= 4;
200 }
201 while (n--) {
202 FB_WRITEL(pat, dst++);
203 pat = pat << left | pat >> right;
204 }
205
206 // Trailing bits
207 if (last)
208 FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
209 }
210 }
211
212 /*
213 * Aligned pattern invert using 32/64-bit memory accesses
214 */
215 static void
216 bitfill_aligned_rev(unsigned long __iomem *dst, int dst_idx, unsigned long pat, unsigned n, int bits)
217 {
218 unsigned long val = pat, dat;
219 unsigned long first, last;
220
221 if (!n)
222 return;
223
224 first = ~0UL >> dst_idx;
225 last = ~(~0UL >> ((dst_idx+n) % bits));
226
227 if (dst_idx+n <= bits) {
228 // Single word
229 if (last)
230 first &= last;
231 dat = FB_READL(dst);
232 FB_WRITEL(comp(dat ^ val, dat, first), dst);
233 } else {
234 // Multiple destination words
235 // Leading bits
236 if (first!=0UL) {
237 dat = FB_READL(dst);
238 FB_WRITEL(comp(dat ^ val, dat, first), dst);
239 dst++;
240 n -= bits - dst_idx;
241 }
242
243 // Main chunk
244 n /= bits;
245 while (n >= 8) {
246 FB_WRITEL(FB_READL(dst) ^ val, dst);
247 dst++;
248 FB_WRITEL(FB_READL(dst) ^ val, dst);
249 dst++;
250 FB_WRITEL(FB_READL(dst) ^ val, dst);
251 dst++;
252 FB_WRITEL(FB_READL(dst) ^ val, dst);
253 dst++;
254 FB_WRITEL(FB_READL(dst) ^ val, dst);
255 dst++;
256 FB_WRITEL(FB_READL(dst) ^ val, dst);
257 dst++;
258 FB_WRITEL(FB_READL(dst) ^ val, dst);
259 dst++;
260 FB_WRITEL(FB_READL(dst) ^ val, dst);
261 dst++;
262 n -= 8;
263 }
264 while (n--) {
265 FB_WRITEL(FB_READL(dst) ^ val, dst);
266 dst++;
267 }
268 // Trailing bits
269 if (last) {
270 dat = FB_READL(dst);
271 FB_WRITEL(comp(dat ^ val, dat, last), dst);
272 }
273 }
274 }
275
276
277 /*
278 * Unaligned generic pattern invert using 32/64-bit memory accesses
279 * The pattern must have been expanded to a full 32/64-bit value
280 * Left/right are the appropriate shifts to convert to the pattern to be
281 * used for the next 32/64-bit word
282 */
283
284 static void
285 bitfill_unaligned_rev(unsigned long __iomem *dst, int dst_idx, unsigned long pat,
286 int left, int right, unsigned n, int bits)
287 {
288 unsigned long first, last, dat;
289
290 if (!n)
291 return;
292
293 first = ~0UL >> dst_idx;
294 last = ~(~0UL >> ((dst_idx+n) % bits));
295
296 if (dst_idx+n <= bits) {
297 // Single word
298 if (last)
299 first &= last;
300 dat = FB_READL(dst);
301 FB_WRITEL(comp(dat ^ pat, dat, first), dst);
302 } else {
303 // Multiple destination words
304
305 // Leading bits
306 if (first != 0UL) {
307 dat = FB_READL(dst);
308 FB_WRITEL(comp(dat ^ pat, dat, first), dst);
309 dst++;
310 pat = pat << left | pat >> right;
311 n -= bits - dst_idx;
312 }
313
314 // Main chunk
315 n /= bits;
316 while (n >= 4) {
317 FB_WRITEL(FB_READL(dst) ^ pat, dst);
318 dst++;
319 pat = pat << left | pat >> right;
320 FB_WRITEL(FB_READL(dst) ^ pat, dst);
321 dst++;
322 pat = pat << left | pat >> right;
323 FB_WRITEL(FB_READL(dst) ^ pat, dst);
324 dst++;
325 pat = pat << left | pat >> right;
326 FB_WRITEL(FB_READL(dst) ^ pat, dst);
327 dst++;
328 pat = pat << left | pat >> right;
329 n -= 4;
330 }
331 while (n--) {
332 FB_WRITEL(FB_READL(dst) ^ pat, dst);
333 dst++;
334 pat = pat << left | pat >> right;
335 }
336
337 // Trailing bits
338 if (last) {
339 dat = FB_READL(dst);
340 FB_WRITEL(comp(dat ^ pat, dat, last), dst);
341 }
342 }
343 }
344
345 void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
346 {
347 unsigned long x2, y2, vxres, vyres, height, width, pat, fg;
348 int bits = BITS_PER_LONG, bytes = bits >> 3;
349 u32 bpp = p->var.bits_per_pixel;
350 unsigned long __iomem *dst;
351 int dst_idx, left;
352
353 if (p->state != FBINFO_STATE_RUNNING)
354 return;
355
356 /* We want rotation but lack hardware to do it for us. */
357 if (!p->fbops->fb_rotate && p->var.rotate) {
358 }
359
360 vxres = p->var.xres_virtual;
361 vyres = p->var.yres_virtual;
362
363 if (!rect->width || !rect->height ||
364 rect->dx > vxres || rect->dy > vyres)
365 return;
366
367 /* We could use hardware clipping but on many cards you get around
368 * hardware clipping by writing to framebuffer directly. */
369
370 x2 = rect->dx + rect->width;
371 y2 = rect->dy + rect->height;
372 x2 = x2 < vxres ? x2 : vxres;
373 y2 = y2 < vyres ? y2 : vyres;
374 width = x2 - rect->dx;
375 height = y2 - rect->dy;
376
377 if (p->fix.visual == FB_VISUAL_TRUECOLOR ||
378 p->fix.visual == FB_VISUAL_DIRECTCOLOR )
379 fg = ((u32 *) (p->pseudo_palette))[rect->color];
380 else
381 fg = rect->color;
382
383 pat = pixel_to_pat( bpp, fg);
384
385 dst = (unsigned long __iomem *)((unsigned long)p->screen_base & ~(bytes-1));
386 dst_idx = ((unsigned long)p->screen_base & (bytes - 1))*8;
387 dst_idx += rect->dy*p->fix.line_length*8+rect->dx*bpp;
388 /* FIXME For now we support 1-32 bpp only */
389 left = bits % bpp;
390 if (p->fbops->fb_sync)
391 p->fbops->fb_sync(p);
392 if (!left) {
393 void (*fill_op32)(unsigned long __iomem *dst, int dst_idx,
394 unsigned long pat, unsigned n, int bits) = NULL;
395
396 switch (rect->rop) {
397 case ROP_XOR:
398 fill_op32 = bitfill_aligned_rev;
399 break;
400 case ROP_COPY:
401 fill_op32 = bitfill_aligned;
402 break;
403 default:
404 printk( KERN_ERR "cfb_fillrect(): unknown rop, defaulting to ROP_COPY\n");
405 fill_op32 = bitfill_aligned;
406 break;
407 }
408 while (height--) {
409 dst += dst_idx >> (ffs(bits) - 1);
410 dst_idx &= (bits - 1);
411 fill_op32(dst, dst_idx, pat, width*bpp, bits);
412 dst_idx += p->fix.line_length*8;
413 }
414 } else {
415 int right;
416 int r;
417 int rot = (left-dst_idx) % bpp;
418 void (*fill_op)(unsigned long __iomem *dst, int dst_idx,
419 unsigned long pat, int left, int right,
420 unsigned n, int bits) = NULL;
421
422 /* rotate pattern to correct start position */
423 pat = pat << rot | pat >> (bpp-rot);
424
425 right = bpp-left;
426 switch (rect->rop) {
427 case ROP_XOR:
428 fill_op = bitfill_unaligned_rev;
429 break;
430 case ROP_COPY:
431 fill_op = bitfill_unaligned;
432 break;
433 default:
434 printk( KERN_ERR "cfb_fillrect(): unknown rop, defaulting to ROP_COPY\n");
435 fill_op = bitfill_unaligned;
436 break;
437 }
438 while (height--) {
439 dst += dst_idx >> (ffs(bits) - 1);
440 dst_idx &= (bits - 1);
441 fill_op(dst, dst_idx, pat, left, right,
442 width*bpp, bits);
443 r = (p->fix.line_length*8) % bpp;
444 pat = pat << (bpp-r) | pat >> r;
445 dst_idx += p->fix.line_length*8;
446 }
447 }
448 }
449
450 EXPORT_SYMBOL(cfb_fillrect);
451
452 MODULE_AUTHOR("James Simmons <jsimmons@users.sf.net>");
453 MODULE_DESCRIPTION("Generic software accelerated fill rectangle");
454 MODULE_LICENSE("GPL");
Verdex Pro support