Branch data Line data Source code
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 : 0 : int i, n, bpp = p->var.bits_per_pixel;
84 : 0 : u32 null_bits = 32 - bpp;
85 : 0 : u32 *palette = (u32 *) p->pseudo_palette;
86 : 0 : const u8 *src = image->data;
87 : : u32 bswapmask = fb_compute_bswapmask(p);
88 : :
89 : : dst2 = (u32 __iomem *) dst1;
90 [ # # ]: 0 : for (i = image->height; i--; ) {
91 : 0 : n = image->width;
92 : : dst = (u32 __iomem *) dst1;
93 : : shift = 0;
94 : : val = 0;
95 : :
96 [ # # ]: 0 : if (start_index) {
97 : 0 : u32 start_mask = ~fb_shifted_pixels_mask_u32(p,
98 : : start_index, bswapmask);
99 : 0 : val = FB_READL(dst) & start_mask;
100 : : shift = start_index;
101 : : }
102 [ # # ]: 0 : while (n--) {
103 [ # # ]: 0 : if (p->fix.visual == FB_VISUAL_TRUECOLOR ||
104 : : p->fix.visual == FB_VISUAL_DIRECTCOLOR )
105 : 0 : color = palette[*src];
106 : : else
107 : 0 : color = *src;
108 : : color <<= FB_LEFT_POS(p, bpp);
109 : 0 : val |= FB_SHIFT_HIGH(p, color, shift ^ bswapmask);
110 [ # # ]: 0 : if (shift >= null_bits) {
111 : 0 : FB_WRITEL(val, dst++);
112 : :
113 [ # # ]: 0 : val = (shift == null_bits) ? 0 :
114 : 0 : FB_SHIFT_LOW(p, color, 32 - shift);
115 : : }
116 : 0 : shift += bpp;
117 : 0 : shift &= (32 - 1);
118 : 0 : src++;
119 : : }
120 [ # # ]: 0 : if (shift) {
121 : 0 : u32 end_mask = fb_shifted_pixels_mask_u32(p, shift,
122 : : bswapmask);
123 : :
124 : 0 : FB_WRITEL((FB_READL(dst) & end_mask) | val, dst);
125 : : }
126 : 0 : dst1 += p->fix.line_length;
127 [ # # ]: 0 : if (pitch_index) {
128 : 0 : dst2 += p->fix.line_length;
129 : 0 : dst1 = (u8 __iomem *)((long __force)dst2 & ~(sizeof(u32) - 1));
130 : :
131 : 0 : start_index += pitch_index;
132 : 0 : 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 : 0 : u32 null_bits = 32 - bpp;
147 : 0 : u32 spitch = (image->width+7)/8;
148 : 0 : 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 [ # # ]: 0 : for (i = image->height; i--; ) {
157 : : shift = val = 0;
158 : : l = 8;
159 : 0 : j = image->width;
160 : : dst = (u32 __iomem *) dst1;
161 : : s = src;
162 : :
163 : : /* write leading bits */
164 [ # # ]: 0 : if (start_index) {
165 : 0 : u32 start_mask = ~fb_shifted_pixels_mask_u32(p,
166 : : start_index, bswapmask);
167 : 0 : val = FB_READL(dst) & start_mask;
168 : : shift = start_index;
169 : : }
170 : :
171 [ # # ]: 0 : while (j--) {
172 : 0 : l--;
173 [ # # ]: 0 : color = (*s & (1 << l)) ? fgcolor : bgcolor;
174 : 0 : val |= FB_SHIFT_HIGH(p, color, shift ^ bswapmask);
175 : :
176 : : /* Did the bitshift spill bits to the next long? */
177 [ # # ]: 0 : if (shift >= null_bits) {
178 : 0 : FB_WRITEL(val, dst++);
179 [ # # ]: 0 : val = (shift == null_bits) ? 0 :
180 : 0 : FB_SHIFT_LOW(p, color, 32 - shift);
181 : : }
182 : 0 : shift += bpp;
183 : 0 : shift &= (32 - 1);
184 [ # # ]: 0 : if (!l) { l = 8; s++; }
185 : : }
186 : :
187 : : /* write trailing bits */
188 [ # # ]: 0 : if (shift) {
189 : 0 : u32 end_mask = fb_shifted_pixels_mask_u32(p, shift,
190 : : bswapmask);
191 : :
192 : 0 : FB_WRITEL((FB_READL(dst) & end_mask) | val, dst);
193 : : }
194 : :
195 : 0 : dst1 += pitch;
196 : 0 : src += spitch;
197 [ # # ]: 0 : if (pitch_index) {
198 : 0 : dst2 += pitch;
199 : 0 : dst1 = (u8 __iomem *)((long __force)dst2 & ~(sizeof(u32) - 1));
200 : 0 : start_index += pitch_index;
201 : 0 : 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 : 0 : u32 ppw = 32/bpp, spitch = (image->width + 7)/8;
221 : : u32 bit_mask, end_mask, eorx, shift;
222 : 0 : const char *s = image->data, *src;
223 : : u32 __iomem *dst;
224 : : const u32 *tab = NULL;
225 : : int i, j, k;
226 : :
227 [ # # # ]: 0 : 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 [ # # ]: 0 : for (i = ppw-1; i--; ) {
241 : 0 : fgx <<= bpp;
242 : 0 : bgx <<= bpp;
243 : 0 : fgx |= fgcolor;
244 : 0 : bgx |= bgcolor;
245 : : }
246 : :
247 : 0 : bit_mask = (1 << ppw) - 1;
248 : 0 : eorx = fgx ^ bgx;
249 : 0 : k = image->width/ppw;
250 : :
251 [ # # ]: 0 : for (i = image->height; i--; ) {
252 : : dst = (u32 __iomem *) dst1, shift = 8; src = s;
253 : :
254 [ # # ]: 0 : for (j = k; j--; ) {
255 : 0 : shift -= ppw;
256 : 0 : end_mask = tab[(*src >> shift) & bit_mask];
257 : 0 : FB_WRITEL((end_mask & eorx)^bgx, dst++);
258 [ # # ]: 0 : if (!shift) { shift = 8; src++; }
259 : : }
260 : 0 : dst1 += p->fix.line_length;
261 : 0 : s += spitch;
262 : : }
263 : : }
264 : :
265 : 0 : void cfb_imageblit(struct fb_info *p, const struct fb_image *image)
266 : : {
267 : : u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0;
268 : 0 : u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel;
269 : 0 : u32 width = image->width;
270 : 0 : u32 dx = image->dx, dy = image->dy;
271 : : u8 __iomem *dst1;
272 : :
273 [ # # ]: 0 : if (p->state != FBINFO_STATE_RUNNING)
274 : 0 : return;
275 : :
276 : 0 : bitstart = (dy * p->fix.line_length * 8) + (dx * bpp);
277 : 0 : start_index = bitstart & (32 - 1);
278 : 0 : pitch_index = (p->fix.line_length & (bpl - 1)) * 8;
279 : :
280 : 0 : bitstart /= 8;
281 : 0 : bitstart &= ~(bpl - 1);
282 : 0 : dst1 = p->screen_base + bitstart;
283 : :
284 [ # # ]: 0 : if (p->fbops->fb_sync)
285 : 0 : p->fbops->fb_sync(p);
286 : :
287 [ # # ]: 0 : if (image->depth == 1) {
288 [ # # ]: 0 : if (p->fix.visual == FB_VISUAL_TRUECOLOR ||
289 : : p->fix.visual == FB_VISUAL_DIRECTCOLOR) {
290 : 0 : fgcolor = ((u32*)(p->pseudo_palette))[image->fg_color];
291 : 0 : bgcolor = ((u32*)(p->pseudo_palette))[image->bg_color];
292 : : } else {
293 : 0 : fgcolor = image->fg_color;
294 : 0 : bgcolor = image->bg_color;
295 : : }
296 : :
297 [ # # ][ # # ]: 0 : if (32 % bpp == 0 && !start_index && !pitch_index &&
298 : 0 : ((width & (32/bpp-1)) == 0) &&
299 [ # # ]: 0 : 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 : :
|
