?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RT-AC56 3.0.0.4.374.37 core
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / video / cfbfillrect.c
blob7c0aeb04d25c69d89606755dce4c3e1875566f9a
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 * Also need to add code to deal with cards endians that are different than
13 * the native cpu endians. I also need to deal with MSB position in the word.
14 *
15 */
16 #include <linux/module.h>
17 #include <linux/string.h>
18 #include <linux/fb.h>
19 #include <asm/types.h>
20 #include "fb_draw.h"
21
22 #if BITS_PER_LONG == 32
23 # define FB_WRITEL fb_writel
24 # define FB_READL fb_readl
25 #else
26 # define FB_WRITEL fb_writeq
27 # define FB_READL fb_readq
28 #endif
29
30 /*
31 * Aligned pattern fill using 32/64-bit memory accesses
32 */
33
34 static void
35 bitfill_aligned(struct fb_info *p, unsigned long __iomem *dst, int dst_idx,
36 unsigned long pat, unsigned n, int bits, u32 bswapmask)
37 {
38 unsigned long first, last;
39
40 if (!n)
41 return;
42
43 first = fb_shifted_pixels_mask_long(p, dst_idx, bswapmask);
44 last = ~fb_shifted_pixels_mask_long(p, (dst_idx+n) % bits, bswapmask);
45
46 if (dst_idx+n <= bits) {
47 // Single word
48 if (last)
49 first &= last;
50 FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
51 } else {
52 // Multiple destination words
53
54 // Leading bits
55 if (first!= ~0UL) {
56 FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
57 dst++;
58 n -= bits - dst_idx;
59 }
60
61 // Main chunk
62 n /= bits;
63 while (n >= 8) {
64 FB_WRITEL(pat, dst++);
65 FB_WRITEL(pat, dst++);
66 FB_WRITEL(pat, dst++);
67 FB_WRITEL(pat, dst++);
68 FB_WRITEL(pat, dst++);
69 FB_WRITEL(pat, dst++);
70 FB_WRITEL(pat, dst++);
71 FB_WRITEL(pat, dst++);
72 n -= 8;
73 }
74 while (n--)
75 FB_WRITEL(pat, dst++);
76
77 // Trailing bits
78 if (last)
79 FB_WRITEL(comp(pat, FB_READL(dst), last), dst);
80 }
81 }
82
83
84 /*
85 * Unaligned generic pattern fill using 32/64-bit memory accesses
86 * The pattern must have been expanded to a full 32/64-bit value
87 * Left/right are the appropriate shifts to convert to the pattern to be
88 * used for the next 32/64-bit word
89 */
90
91 static void
92 bitfill_unaligned(struct fb_info *p, unsigned long __iomem *dst, int dst_idx,
93 unsigned long pat, int left, int right, unsigned n, int bits)
94 {
95 unsigned long first, last;
96
97 if (!n)
98 return;
99
100 first = FB_SHIFT_HIGH(p, ~0UL, dst_idx);
101 last = ~(FB_SHIFT_HIGH(p, ~0UL, (dst_idx+n) % bits));
102
103 if (dst_idx+n <= bits) {
104 // Single word
105 if (last)
106 first &= last;
107 FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
108 } else {
109 // Multiple destination words
110 // Leading bits
111 if (first) {
112 FB_WRITEL(comp(pat, FB_READL(dst), first), dst);
113 dst++;
114 pat = pat << left | pat >> right;
115 n -= bits - dst_idx;
116 }
117
118 // Main chunk
119 n /= bits;
120 while (n >= 4) {
121 FB_WRITEL(pat, dst++);
122 pat = pat << left | pat >> right;
123 FB_WRITEL(pat, dst++);
124 pat = pat << left | pat >> right;
125 FB_WRITEL(pat, dst++);
126 pat = pat << left | pat >> right;
127 FB_WRITEL(pat, dst++);
128 pat = pat << left | pat >> right;
129 n -= 4;
130 }
131 while (n--) {
132 FB_WRITEL(pat, dst++);
133 pat = pat << left | pat >> right;
134 }
135
136 // Trailing bits
137 if (last)
138 FB_WRITEL(comp(pat, FB_READL(dst), last), dst);
139 }
140 }
141
142 /*
143 * Aligned pattern invert using 32/64-bit memory accesses
144 */
145 static void
146 bitfill_aligned_rev(struct fb_info *p, unsigned long __iomem *dst,
147 int dst_idx, unsigned long pat, unsigned n, int bits,
148 u32 bswapmask)
149 {
150 unsigned long val = pat, dat;
151 unsigned long first, last;
152
153 if (!n)
154 return;
155
156 first = fb_shifted_pixels_mask_long(p, dst_idx, bswapmask);
157 last = ~fb_shifted_pixels_mask_long(p, (dst_idx+n) % bits, bswapmask);
158
159 if (dst_idx+n <= bits) {
160 // Single word
161 if (last)
162 first &= last;
163 dat = FB_READL(dst);
164 FB_WRITEL(comp(dat ^ val, dat, first), dst);
165 } else {
166 // Multiple destination words
167 // Leading bits
168 if (first!=0UL) {
169 dat = FB_READL(dst);
170 FB_WRITEL(comp(dat ^ val, dat, first), dst);
171 dst++;
172 n -= bits - dst_idx;
173 }
174
175 // Main chunk
176 n /= bits;
177 while (n >= 8) {
178 FB_WRITEL(FB_READL(dst) ^ val, dst);
179 dst++;
180 FB_WRITEL(FB_READL(dst) ^ val, dst);
181 dst++;
182 FB_WRITEL(FB_READL(dst) ^ val, dst);
183 dst++;
184 FB_WRITEL(FB_READL(dst) ^ val, dst);
185 dst++;
186 FB_WRITEL(FB_READL(dst) ^ val, dst);
187 dst++;
188 FB_WRITEL(FB_READL(dst) ^ val, dst);
189 dst++;
190 FB_WRITEL(FB_READL(dst) ^ val, dst);
191 dst++;
192 FB_WRITEL(FB_READL(dst) ^ val, dst);
193 dst++;
194 n -= 8;
195 }
196 while (n--) {
197 FB_WRITEL(FB_READL(dst) ^ val, dst);
198 dst++;
199 }
200 // Trailing bits
201 if (last) {
202 dat = FB_READL(dst);
203 FB_WRITEL(comp(dat ^ val, dat, last), dst);
204 }
205 }
206 }
207
208
209 /*
210 * Unaligned generic pattern invert using 32/64-bit memory accesses
211 * The pattern must have been expanded to a full 32/64-bit value
212 * Left/right are the appropriate shifts to convert to the pattern to be
213 * used for the next 32/64-bit word
214 */
215
216 static void
217 bitfill_unaligned_rev(struct fb_info *p, unsigned long __iomem *dst,
218 int dst_idx, unsigned long pat, int left, int right,
219 unsigned n, int bits)
220 {
221 unsigned long first, last, dat;
222
223 if (!n)
224 return;
225
226 first = FB_SHIFT_HIGH(p, ~0UL, dst_idx);
227 last = ~(FB_SHIFT_HIGH(p, ~0UL, (dst_idx+n) % bits));
228
229 if (dst_idx+n <= bits) {
230 // Single word
231 if (last)
232 first &= last;
233 dat = FB_READL(dst);
234 FB_WRITEL(comp(dat ^ pat, dat, first), dst);
235 } else {
236 // Multiple destination words
237
238 // Leading bits
239 if (first != 0UL) {
240 dat = FB_READL(dst);
241 FB_WRITEL(comp(dat ^ pat, dat, first), dst);
242 dst++;
243 pat = pat << left | pat >> right;
244 n -= bits - dst_idx;
245 }
246
247 // Main chunk
248 n /= bits;
249 while (n >= 4) {
250 FB_WRITEL(FB_READL(dst) ^ pat, dst);
251 dst++;
252 pat = pat << left | pat >> right;
253 FB_WRITEL(FB_READL(dst) ^ pat, dst);
254 dst++;
255 pat = pat << left | pat >> right;
256 FB_WRITEL(FB_READL(dst) ^ pat, dst);
257 dst++;
258 pat = pat << left | pat >> right;
259 FB_WRITEL(FB_READL(dst) ^ pat, dst);
260 dst++;
261 pat = pat << left | pat >> right;
262 n -= 4;
263 }
264 while (n--) {
265 FB_WRITEL(FB_READL(dst) ^ pat, dst);
266 dst++;
267 pat = pat << left | pat >> right;
268 }
269
270 // Trailing bits
271 if (last) {
272 dat = FB_READL(dst);
273 FB_WRITEL(comp(dat ^ pat, dat, last), dst);
274 }
275 }
276 }
277
278 void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
279 {
280 unsigned long pat, pat2, fg;
281 unsigned long width = rect->width, height = rect->height;
282 int bits = BITS_PER_LONG, bytes = bits >> 3;
283 u32 bpp = p->var.bits_per_pixel;
284 unsigned long __iomem *dst;
285 int dst_idx, left;
286
287 if (p->state != FBINFO_STATE_RUNNING)
288 return;
289
290 if (p->fix.visual == FB_VISUAL_TRUECOLOR ||
291 p->fix.visual == FB_VISUAL_DIRECTCOLOR )
292 fg = ((u32 *) (p->pseudo_palette))[rect->color];
293 else
294 fg = rect->color;
295
296 pat = pixel_to_pat(bpp, fg);
297
298 dst = (unsigned long __iomem *)((unsigned long)p->screen_base & ~(bytes-1));
299 dst_idx = ((unsigned long)p->screen_base & (bytes - 1))*8;
300 dst_idx += rect->dy*p->fix.line_length*8+rect->dx*bpp;
301 left = bits % bpp;
302 if (p->fbops->fb_sync)
303 p->fbops->fb_sync(p);
304 if (!left) {
305 u32 bswapmask = fb_compute_bswapmask(p);
306 void (*fill_op32)(struct fb_info *p,
307 unsigned long __iomem *dst, int dst_idx,
308 unsigned long pat, unsigned n, int bits,
309 u32 bswapmask) = NULL;
310
311 switch (rect->rop) {
312 case ROP_XOR:
313 fill_op32 = bitfill_aligned_rev;
314 break;
315 case ROP_COPY:
316 fill_op32 = bitfill_aligned;
317 break;
318 default:
319 printk( KERN_ERR "cfb_fillrect(): unknown rop, defaulting to ROP_COPY\n");
320 fill_op32 = bitfill_aligned;
321 break;
322 }
323 while (height--) {
324 dst += dst_idx >> (ffs(bits) - 1);
325 dst_idx &= (bits - 1);
326 fill_op32(p, dst, dst_idx, pat, width*bpp, bits,
327 bswapmask);
328 dst_idx += p->fix.line_length*8;
329 }
330 } else {
331 int right, r;
332 void (*fill_op)(struct fb_info *p, unsigned long __iomem *dst,
333 int dst_idx, unsigned long pat, int left,
334 int right, unsigned n, int bits) = NULL;
335 #ifdef __LITTLE_ENDIAN
336 right = left;
337 left = bpp - right;
338 #else
339 right = bpp - left;
340 #endif
341 switch (rect->rop) {
342 case ROP_XOR:
343 fill_op = bitfill_unaligned_rev;
344 break;
345 case ROP_COPY:
346 fill_op = bitfill_unaligned;
347 break;
348 default:
349 printk(KERN_ERR "cfb_fillrect(): unknown rop, defaulting to ROP_COPY\n");
350 fill_op = bitfill_unaligned;
351 break;
352 }
353 while (height--) {
354 dst += dst_idx / bits;
355 dst_idx &= (bits - 1);
356 r = dst_idx % bpp;
357 /* rotate pattern to the correct start position */
358 pat2 = le_long_to_cpu(rolx(cpu_to_le_long(pat), r, bpp));
359 fill_op(p, dst, dst_idx, pat2, left, right,
360 width*bpp, bits);
361 dst_idx += p->fix.line_length*8;
362 }
363 }
364 }
365
366 EXPORT_SYMBOL(cfb_fillrect);
367
368 MODULE_AUTHOR("James Simmons <jsimmons@users.sf.net>");
369 MODULE_DESCRIPTION("Generic software accelerated fill rectangle");
370 MODULE_LICENSE("GPL");
Tomato firmware and modifications.