Root/
1 | /* |
2 | * Generic BitBLT function for frame buffer with packed pixels of any depth. |
3 | * |
4 | * Copyright (C) June 1999 James Simmons |
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 function copys a image from system memory to video memory. The |
13 | * image can be a bitmap where each 0 represents the background color and |
14 | * each 1 represents the foreground color. Great for font handling. It can |
15 | * also be a color image. This is determined by image_depth. The color image |
16 | * must be laid out exactly in the same format as the framebuffer. Yes I know |
17 | * their are cards with hardware that coverts images of various depths to the |
18 | * framebuffer depth. But not every card has this. All images must be rounded |
19 | * up to the nearest byte. For example a bitmap 12 bits wide must be two |
20 | * bytes width. |
21 | * |
22 | * Tony: |
23 | * Incorporate mask tables similar to fbcon-cfb*.c in 2.4 API. This speeds |
24 | * up the code significantly. |
25 | * |
26 | * Code for depths not multiples of BITS_PER_LONG is still kludgy, which is |
27 | * still processed a bit at a time. |
28 | * |
29 | * Also need to add code to deal with cards endians that are different than |
30 | * the native cpu endians. I also need to deal with MSB position in the word. |
31 | */ |
32 | #include <linux/module.h> |
33 | #include <linux/string.h> |
34 | #include <linux/fb.h> |
35 | #include <asm/types.h> |
36 | #include "fb_draw.h" |
37 | |
38 | #define DEBUG |
39 | |
40 | #ifdef DEBUG |
41 | #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt,__func__,## args) |
42 | #else |
43 | #define DPRINTK(fmt, args...) |
44 | #endif |
45 | |
46 | static const u32 cfb_tab8_be[] = { |
47 | 0x00000000,0x000000ff,0x0000ff00,0x0000ffff, |
48 | 0x00ff0000,0x00ff00ff,0x00ffff00,0x00ffffff, |
49 | 0xff000000,0xff0000ff,0xff00ff00,0xff00ffff, |
50 | 0xffff0000,0xffff00ff,0xffffff00,0xffffffff |
51 | }; |
52 | |
53 | static const u32 cfb_tab8_le[] = { |
54 | 0x00000000,0xff000000,0x00ff0000,0xffff0000, |
55 | 0x0000ff00,0xff00ff00,0x00ffff00,0xffffff00, |
56 | 0x000000ff,0xff0000ff,0x00ff00ff,0xffff00ff, |
57 | 0x0000ffff,0xff00ffff,0x00ffffff,0xffffffff |
58 | }; |
59 | |
60 | static const u32 cfb_tab16_be[] = { |
61 | 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff |
62 | }; |
63 | |
64 | static const u32 cfb_tab16_le[] = { |
65 | 0x00000000, 0xffff0000, 0x0000ffff, 0xffffffff |
66 | }; |
67 | |
68 | static const u32 cfb_tab32[] = { |
69 | 0x00000000, 0xffffffff |
70 | }; |
71 | |
72 | #define FB_WRITEL fb_writel |
73 | #define FB_READL fb_readl |
74 | |
75 | static inline void color_imageblit(const struct fb_image *image, |
76 | struct fb_info *p, u8 __iomem *dst1, |
77 | u32 start_index, |
78 | u32 pitch_index) |
79 | { |
80 | /* Draw the penguin */ |
81 | u32 __iomem *dst, *dst2; |
82 | u32 color = 0, val, shift; |
83 | int i, n, bpp = p->var.bits_per_pixel; |
84 | u32 null_bits = 32 - bpp; |
85 | u32 *palette = (u32 *) p->pseudo_palette; |
86 | const u8 *src = image->data; |
87 | u32 bswapmask = fb_compute_bswapmask(p); |
88 | |
89 | dst2 = (u32 __iomem *) dst1; |
90 | for (i = image->height; i--; ) { |
91 | n = image->width; |
92 | dst = (u32 __iomem *) dst1; |
93 | shift = 0; |
94 | val = 0; |
95 | |
96 | if (start_index) { |
97 | u32 start_mask = ~fb_shifted_pixels_mask_u32(p, |
98 | start_index, bswapmask); |
99 | val = FB_READL(dst) & start_mask; |
100 | shift = start_index; |
101 | } |
102 | while (n--) { |
103 | if (p->fix.visual == FB_VISUAL_TRUECOLOR || |
104 | p->fix.visual == FB_VISUAL_DIRECTCOLOR ) |
105 | color = palette[*src]; |
106 | else |
107 | color = *src; |
108 | color <<= FB_LEFT_POS(p, bpp); |
109 | val |= FB_SHIFT_HIGH(p, color, shift ^ bswapmask); |
110 | if (shift >= null_bits) { |
111 | FB_WRITEL(val, dst++); |
112 | |
113 | val = (shift == null_bits) ? 0 : |
114 | FB_SHIFT_LOW(p, color, 32 - shift); |
115 | } |
116 | shift += bpp; |
117 | shift &= (32 - 1); |
118 | src++; |
119 | } |
120 | if (shift) { |
121 | u32 end_mask = fb_shifted_pixels_mask_u32(p, shift, |
122 | bswapmask); |
123 | |
124 | FB_WRITEL((FB_READL(dst) & end_mask) | val, dst); |
125 | } |
126 | dst1 += p->fix.line_length; |
127 | if (pitch_index) { |
128 | dst2 += p->fix.line_length; |
129 | dst1 = (u8 __iomem *)((long __force)dst2 & ~(sizeof(u32) - 1)); |
130 | |
131 | start_index += pitch_index; |
132 | start_index &= 32 - 1; |
133 | } |
134 | } |
135 | } |
136 | |
137 | static inline void slow_imageblit(const struct fb_image *image, struct fb_info *p, |
138 | u8 __iomem *dst1, u32 fgcolor, |
139 | u32 bgcolor, |
140 | u32 start_index, |
141 | u32 pitch_index) |
142 | { |
143 | u32 shift, color = 0, bpp = p->var.bits_per_pixel; |
144 | u32 __iomem *dst, *dst2; |
145 | u32 val, pitch = p->fix.line_length; |
146 | u32 null_bits = 32 - bpp; |
147 | u32 spitch = (image->width+7)/8; |
148 | const u8 *src = image->data, *s; |
149 | u32 i, j, l; |
150 | u32 bswapmask = fb_compute_bswapmask(p); |
151 | |
152 | dst2 = (u32 __iomem *) dst1; |
153 | fgcolor <<= FB_LEFT_POS(p, bpp); |
154 | bgcolor <<= FB_LEFT_POS(p, bpp); |
155 | |
156 | for (i = image->height; i--; ) { |
157 | shift = val = 0; |
158 | l = 8; |
159 | j = image->width; |
160 | dst = (u32 __iomem *) dst1; |
161 | s = src; |
162 | |
163 | /* write leading bits */ |
164 | if (start_index) { |
165 | u32 start_mask = ~fb_shifted_pixels_mask_u32(p, |
166 | start_index, bswapmask); |
167 | val = FB_READL(dst) & start_mask; |
168 | shift = start_index; |
169 | } |
170 | |
171 | while (j--) { |
172 | l--; |
173 | color = (*s & (1 << l)) ? fgcolor : bgcolor; |
174 | val |= FB_SHIFT_HIGH(p, color, shift ^ bswapmask); |
175 | |
176 | /* Did the bitshift spill bits to the next long? */ |
177 | if (shift >= null_bits) { |
178 | FB_WRITEL(val, dst++); |
179 | val = (shift == null_bits) ? 0 : |
180 | FB_SHIFT_LOW(p, color, 32 - shift); |
181 | } |
182 | shift += bpp; |
183 | shift &= (32 - 1); |
184 | if (!l) { l = 8; s++; }; |
185 | } |
186 | |
187 | /* write trailing bits */ |
188 | if (shift) { |
189 | u32 end_mask = fb_shifted_pixels_mask_u32(p, shift, |
190 | bswapmask); |
191 | |
192 | FB_WRITEL((FB_READL(dst) & end_mask) | val, dst); |
193 | } |
194 | |
195 | dst1 += pitch; |
196 | src += spitch; |
197 | if (pitch_index) { |
198 | dst2 += pitch; |
199 | dst1 = (u8 __iomem *)((long __force)dst2 & ~(sizeof(u32) - 1)); |
200 | start_index += pitch_index; |
201 | start_index &= 32 - 1; |
202 | } |
203 | |
204 | } |
205 | } |
206 | |
207 | /* |
208 | * fast_imageblit - optimized monochrome color expansion |
209 | * |
210 | * Only if: bits_per_pixel == 8, 16, or 32 |
211 | * image->width is divisible by pixel/dword (ppw); |
212 | * fix->line_legth is divisible by 4; |
213 | * beginning and end of a scanline is dword aligned |
214 | */ |
215 | static inline void fast_imageblit(const struct fb_image *image, struct fb_info *p, |
216 | u8 __iomem *dst1, u32 fgcolor, |
217 | u32 bgcolor) |
218 | { |
219 | u32 fgx = fgcolor, bgx = bgcolor, bpp = p->var.bits_per_pixel; |
220 | u32 ppw = 32/bpp, spitch = (image->width + 7)/8; |
221 | u32 bit_mask, end_mask, eorx, shift; |
222 | const char *s = image->data, *src; |
223 | u32 __iomem *dst; |
224 | const u32 *tab = NULL; |
225 | int i, j, k; |
226 | |
227 | switch (bpp) { |
228 | case 8: |
229 | tab = fb_be_math(p) ? cfb_tab8_be : cfb_tab8_le; |
230 | break; |
231 | case 16: |
232 | tab = fb_be_math(p) ? cfb_tab16_be : cfb_tab16_le; |
233 | break; |
234 | case 32: |
235 | default: |
236 | tab = cfb_tab32; |
237 | break; |
238 | } |
239 | |
240 | for (i = ppw-1; i--; ) { |
241 | fgx <<= bpp; |
242 | bgx <<= bpp; |
243 | fgx |= fgcolor; |
244 | bgx |= bgcolor; |
245 | } |
246 | |
247 | bit_mask = (1 << ppw) - 1; |
248 | eorx = fgx ^ bgx; |
249 | k = image->width/ppw; |
250 | |
251 | for (i = image->height; i--; ) { |
252 | dst = (u32 __iomem *) dst1, shift = 8; src = s; |
253 | |
254 | for (j = k; j--; ) { |
255 | shift -= ppw; |
256 | end_mask = tab[(*src >> shift) & bit_mask]; |
257 | FB_WRITEL((end_mask & eorx)^bgx, dst++); |
258 | if (!shift) { shift = 8; src++; } |
259 | } |
260 | dst1 += p->fix.line_length; |
261 | s += spitch; |
262 | } |
263 | } |
264 | |
265 | void cfb_imageblit(struct fb_info *p, const struct fb_image *image) |
266 | { |
267 | u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0; |
268 | u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel; |
269 | u32 width = image->width; |
270 | u32 dx = image->dx, dy = image->dy; |
271 | u8 __iomem *dst1; |
272 | |
273 | if (p->state != FBINFO_STATE_RUNNING) |
274 | return; |
275 | |
276 | bitstart = (dy * p->fix.line_length * 8) + (dx * bpp); |
277 | start_index = bitstart & (32 - 1); |
278 | pitch_index = (p->fix.line_length & (bpl - 1)) * 8; |
279 | |
280 | bitstart /= 8; |
281 | bitstart &= ~(bpl - 1); |
282 | dst1 = p->screen_base + bitstart; |
283 | |
284 | if (p->fbops->fb_sync) |
285 | p->fbops->fb_sync(p); |
286 | |
287 | if (image->depth == 1) { |
288 | if (p->fix.visual == FB_VISUAL_TRUECOLOR || |
289 | p->fix.visual == FB_VISUAL_DIRECTCOLOR) { |
290 | fgcolor = ((u32*)(p->pseudo_palette))[image->fg_color]; |
291 | bgcolor = ((u32*)(p->pseudo_palette))[image->bg_color]; |
292 | } else { |
293 | fgcolor = image->fg_color; |
294 | bgcolor = image->bg_color; |
295 | } |
296 | |
297 | if (32 % bpp == 0 && !start_index && !pitch_index && |
298 | ((width & (32/bpp-1)) == 0) && |
299 | bpp >= 8 && bpp <= 32) |
300 | fast_imageblit(image, p, dst1, fgcolor, bgcolor); |
301 | else |
302 | slow_imageblit(image, p, dst1, fgcolor, bgcolor, |
303 | start_index, pitch_index); |
304 | } else |
305 | color_imageblit(image, p, dst1, start_index, pitch_index); |
306 | } |
307 | |
308 | EXPORT_SYMBOL(cfb_imageblit); |
309 | |
310 | MODULE_AUTHOR("James Simmons <jsimmons@users.sf.net>"); |
311 | MODULE_DESCRIPTION("Generic software accelerated imaging drawing"); |
312 | MODULE_LICENSE("GPL"); |
313 | |
314 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9