]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/drivers/video/console/bitblit.c -- BitBlitting Operation | |
3 | * | |
4 | * Originally from the 'accel_*' routines in drivers/video/console/fbcon.c | |
5 | * | |
6 | * Copyright (C) 2004 Antonino Daplas <adaplas @pol.net> | |
7 | * | |
8 | * This file is subject to the terms and conditions of the GNU General Public | |
9 | * License. See the file COPYING in the main directory of this archive for | |
10 | * more details. | |
11 | */ | |
12 | ||
1da177e4 | 13 | #include <linux/module.h> |
5a0e3ad6 | 14 | #include <linux/slab.h> |
1da177e4 LT |
15 | #include <linux/string.h> |
16 | #include <linux/fb.h> | |
17 | #include <linux/vt_kern.h> | |
18 | #include <linux/console.h> | |
19 | #include <asm/types.h> | |
20 | #include "fbcon.h" | |
21 | ||
22 | /* | |
23 | * Accelerated handlers. | |
24 | */ | |
26c5be3c | 25 | static void update_attr(u8 *dst, u8 *src, int attribute, |
1da177e4 LT |
26 | struct vc_data *vc) |
27 | { | |
28 | int i, offset = (vc->vc_font.height < 10) ? 1 : 2; | |
9a4a83d2 | 29 | int width = DIV_ROUND_UP(vc->vc_font.width, 8); |
1da177e4 LT |
30 | unsigned int cellsize = vc->vc_font.height * width; |
31 | u8 c; | |
32 | ||
33 | offset = cellsize - (offset * width); | |
34 | for (i = 0; i < cellsize; i++) { | |
35 | c = src[i]; | |
36 | if (attribute & FBCON_ATTRIBUTE_UNDERLINE && i >= offset) | |
37 | c = 0xff; | |
38 | if (attribute & FBCON_ATTRIBUTE_BOLD) | |
39 | c |= c >> 1; | |
40 | if (attribute & FBCON_ATTRIBUTE_REVERSE) | |
41 | c = ~c; | |
42 | dst[i] = c; | |
43 | } | |
44 | } | |
45 | ||
46 | static void bit_bmove(struct vc_data *vc, struct fb_info *info, int sy, | |
47 | int sx, int dy, int dx, int height, int width) | |
48 | { | |
49 | struct fb_copyarea area; | |
50 | ||
51 | area.sx = sx * vc->vc_font.width; | |
52 | area.sy = sy * vc->vc_font.height; | |
53 | area.dx = dx * vc->vc_font.width; | |
54 | area.dy = dy * vc->vc_font.height; | |
55 | area.height = height * vc->vc_font.height; | |
56 | area.width = width * vc->vc_font.width; | |
57 | ||
58 | info->fbops->fb_copyarea(info, &area); | |
59 | } | |
60 | ||
61 | static void bit_clear(struct vc_data *vc, struct fb_info *info, int sy, | |
62 | int sx, int height, int width) | |
63 | { | |
64 | int bgshift = (vc->vc_hi_font_mask) ? 13 : 12; | |
65 | struct fb_fillrect region; | |
66 | ||
91c43132 | 67 | region.color = attr_bgcol_ec(bgshift, vc, info); |
1da177e4 LT |
68 | region.dx = sx * vc->vc_font.width; |
69 | region.dy = sy * vc->vc_font.height; | |
70 | region.width = width * vc->vc_font.width; | |
71 | region.height = height * vc->vc_font.height; | |
72 | region.rop = ROP_COPY; | |
73 | ||
74 | info->fbops->fb_fillrect(info, ®ion); | |
75 | } | |
76 | ||
829e79b6 AD |
77 | static inline void bit_putcs_aligned(struct vc_data *vc, struct fb_info *info, |
78 | const u16 *s, u32 attr, u32 cnt, | |
79 | u32 d_pitch, u32 s_pitch, u32 cellsize, | |
80 | struct fb_image *image, u8 *buf, u8 *dst) | |
81 | { | |
82 | u16 charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff; | |
83 | u32 idx = vc->vc_font.width >> 3; | |
84 | u8 *src; | |
85 | ||
86 | while (cnt--) { | |
87 | src = vc->vc_font.data + (scr_readw(s++)& | |
88 | charmask)*cellsize; | |
89 | ||
90 | if (attr) { | |
91 | update_attr(buf, src, attr, vc); | |
92 | src = buf; | |
93 | } | |
94 | ||
95 | if (likely(idx == 1)) | |
96 | __fb_pad_aligned_buffer(dst, d_pitch, src, idx, | |
97 | image->height); | |
98 | else | |
99 | fb_pad_aligned_buffer(dst, d_pitch, src, idx, | |
100 | image->height); | |
101 | ||
102 | dst += s_pitch; | |
103 | } | |
104 | ||
105 | info->fbops->fb_imageblit(info, image); | |
106 | } | |
107 | ||
108 | static inline void bit_putcs_unaligned(struct vc_data *vc, | |
109 | struct fb_info *info, const u16 *s, | |
110 | u32 attr, u32 cnt, u32 d_pitch, | |
111 | u32 s_pitch, u32 cellsize, | |
112 | struct fb_image *image, u8 *buf, | |
113 | u8 *dst) | |
114 | { | |
115 | u16 charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff; | |
116 | u32 shift_low = 0, mod = vc->vc_font.width % 8; | |
117 | u32 shift_high = 8; | |
118 | u32 idx = vc->vc_font.width >> 3; | |
119 | u8 *src; | |
120 | ||
121 | while (cnt--) { | |
122 | src = vc->vc_font.data + (scr_readw(s++)& | |
123 | charmask)*cellsize; | |
124 | ||
125 | if (attr) { | |
126 | update_attr(buf, src, attr, vc); | |
127 | src = buf; | |
128 | } | |
129 | ||
130 | fb_pad_unaligned_buffer(dst, d_pitch, src, idx, | |
131 | image->height, shift_high, | |
132 | shift_low, mod); | |
133 | shift_low += mod; | |
134 | dst += (shift_low >= 8) ? s_pitch : s_pitch - 1; | |
135 | shift_low &= 7; | |
136 | shift_high = 8 - shift_low; | |
137 | } | |
138 | ||
139 | info->fbops->fb_imageblit(info, image); | |
140 | ||
141 | } | |
142 | ||
1da177e4 LT |
143 | static void bit_putcs(struct vc_data *vc, struct fb_info *info, |
144 | const unsigned short *s, int count, int yy, int xx, | |
145 | int fg, int bg) | |
146 | { | |
1da177e4 | 147 | struct fb_image image; |
9a4a83d2 | 148 | u32 width = DIV_ROUND_UP(vc->vc_font.width, 8); |
829e79b6 AD |
149 | u32 cellsize = width * vc->vc_font.height; |
150 | u32 maxcnt = info->pixmap.size/cellsize; | |
151 | u32 scan_align = info->pixmap.scan_align - 1; | |
152 | u32 buf_align = info->pixmap.buf_align - 1; | |
153 | u32 mod = vc->vc_font.width % 8, cnt, pitch, size; | |
154 | u32 attribute = get_attribute(info, scr_readw(s)); | |
155 | u8 *dst, *buf = NULL; | |
1da177e4 LT |
156 | |
157 | image.fg_color = fg; | |
158 | image.bg_color = bg; | |
1da177e4 LT |
159 | image.dx = xx * vc->vc_font.width; |
160 | image.dy = yy * vc->vc_font.height; | |
161 | image.height = vc->vc_font.height; | |
162 | image.depth = 1; | |
163 | ||
829e79b6 AD |
164 | if (attribute) { |
165 | buf = kmalloc(cellsize, GFP_KERNEL); | |
166 | if (!buf) | |
167 | return; | |
168 | } | |
169 | ||
1da177e4 LT |
170 | while (count) { |
171 | if (count > maxcnt) | |
829e79b6 | 172 | cnt = maxcnt; |
1da177e4 | 173 | else |
829e79b6 | 174 | cnt = count; |
1da177e4 LT |
175 | |
176 | image.width = vc->vc_font.width * cnt; | |
9a4a83d2 | 177 | pitch = DIV_ROUND_UP(image.width, 8) + scan_align; |
1da177e4 LT |
178 | pitch &= ~scan_align; |
179 | size = pitch * image.height + buf_align; | |
180 | size &= ~buf_align; | |
181 | dst = fb_get_buffer_offset(info, &info->pixmap, size); | |
182 | image.data = dst; | |
829e79b6 AD |
183 | |
184 | if (!mod) | |
185 | bit_putcs_aligned(vc, info, s, attribute, cnt, pitch, | |
186 | width, cellsize, &image, buf, dst); | |
187 | else | |
188 | bit_putcs_unaligned(vc, info, s, attribute, cnt, | |
189 | pitch, width, cellsize, &image, | |
190 | buf, dst); | |
191 | ||
1da177e4 LT |
192 | image.dx += cnt * vc->vc_font.width; |
193 | count -= cnt; | |
829e79b6 | 194 | s += cnt; |
1da177e4 LT |
195 | } |
196 | ||
197 | /* buf is always NULL except when in monochrome mode, so in this case | |
198 | it's a gain to check buf against NULL even though kfree() handles | |
199 | NULL pointers just fine */ | |
200 | if (unlikely(buf)) | |
201 | kfree(buf); | |
829e79b6 | 202 | |
1da177e4 LT |
203 | } |
204 | ||
205 | static void bit_clear_margins(struct vc_data *vc, struct fb_info *info, | |
206 | int bottom_only) | |
207 | { | |
208 | int bgshift = (vc->vc_hi_font_mask) ? 13 : 12; | |
209 | unsigned int cw = vc->vc_font.width; | |
210 | unsigned int ch = vc->vc_font.height; | |
211 | unsigned int rw = info->var.xres - (vc->vc_cols*cw); | |
212 | unsigned int bh = info->var.yres - (vc->vc_rows*ch); | |
213 | unsigned int rs = info->var.xres - rw; | |
214 | unsigned int bs = info->var.yres - bh; | |
215 | struct fb_fillrect region; | |
216 | ||
91c43132 | 217 | region.color = attr_bgcol_ec(bgshift, vc, info); |
1da177e4 LT |
218 | region.rop = ROP_COPY; |
219 | ||
220 | if (rw && !bottom_only) { | |
221 | region.dx = info->var.xoffset + rs; | |
222 | region.dy = 0; | |
223 | region.width = rw; | |
224 | region.height = info->var.yres_virtual; | |
225 | info->fbops->fb_fillrect(info, ®ion); | |
226 | } | |
227 | ||
228 | if (bh) { | |
229 | region.dx = info->var.xoffset; | |
230 | region.dy = info->var.yoffset + bs; | |
231 | region.width = rs; | |
232 | region.height = bh; | |
233 | info->fbops->fb_fillrect(info, ®ion); | |
234 | } | |
235 | } | |
236 | ||
b73deed3 AD |
237 | static void bit_cursor(struct vc_data *vc, struct fb_info *info, int mode, |
238 | int softback_lines, int fg, int bg) | |
1da177e4 LT |
239 | { |
240 | struct fb_cursor cursor; | |
b73deed3 | 241 | struct fbcon_ops *ops = info->fbcon_par; |
1da177e4 | 242 | unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff; |
9a4a83d2 | 243 | int w = DIV_ROUND_UP(vc->vc_font.width, 8), c; |
b73deed3 | 244 | int y = real_y(ops->p, vc->vc_y); |
1da177e4 | 245 | int attribute, use_sw = (vc->vc_cursor_type & 0x10); |
c465e05a | 246 | int err = 1; |
1da177e4 LT |
247 | char *src; |
248 | ||
249 | cursor.set = 0; | |
250 | ||
251 | if (softback_lines) { | |
252 | if (y + softback_lines >= vc->vc_rows) { | |
253 | mode = CM_ERASE; | |
254 | ops->cursor_flash = 0; | |
255 | return; | |
256 | } else | |
257 | y += softback_lines; | |
258 | } | |
259 | ||
260 | c = scr_readw((u16 *) vc->vc_pos); | |
261 | attribute = get_attribute(info, c); | |
262 | src = vc->vc_font.data + ((c & charmask) * (w * vc->vc_font.height)); | |
263 | ||
264 | if (ops->cursor_state.image.data != src || | |
265 | ops->cursor_reset) { | |
266 | ops->cursor_state.image.data = src; | |
267 | cursor.set |= FB_CUR_SETIMAGE; | |
268 | } | |
269 | ||
270 | if (attribute) { | |
271 | u8 *dst; | |
272 | ||
273 | dst = kmalloc(w * vc->vc_font.height, GFP_ATOMIC); | |
274 | if (!dst) | |
275 | return; | |
276 | kfree(ops->cursor_data); | |
277 | ops->cursor_data = dst; | |
278 | update_attr(dst, src, attribute, vc); | |
279 | src = dst; | |
280 | } | |
281 | ||
282 | if (ops->cursor_state.image.fg_color != fg || | |
283 | ops->cursor_state.image.bg_color != bg || | |
284 | ops->cursor_reset) { | |
285 | ops->cursor_state.image.fg_color = fg; | |
286 | ops->cursor_state.image.bg_color = bg; | |
287 | cursor.set |= FB_CUR_SETCMAP; | |
288 | } | |
289 | ||
290 | if ((ops->cursor_state.image.dx != (vc->vc_font.width * vc->vc_x)) || | |
291 | (ops->cursor_state.image.dy != (vc->vc_font.height * y)) || | |
292 | ops->cursor_reset) { | |
293 | ops->cursor_state.image.dx = vc->vc_font.width * vc->vc_x; | |
294 | ops->cursor_state.image.dy = vc->vc_font.height * y; | |
295 | cursor.set |= FB_CUR_SETPOS; | |
296 | } | |
297 | ||
298 | if (ops->cursor_state.image.height != vc->vc_font.height || | |
299 | ops->cursor_state.image.width != vc->vc_font.width || | |
300 | ops->cursor_reset) { | |
301 | ops->cursor_state.image.height = vc->vc_font.height; | |
302 | ops->cursor_state.image.width = vc->vc_font.width; | |
303 | cursor.set |= FB_CUR_SETSIZE; | |
304 | } | |
305 | ||
306 | if (ops->cursor_state.hot.x || ops->cursor_state.hot.y || | |
307 | ops->cursor_reset) { | |
308 | ops->cursor_state.hot.x = cursor.hot.y = 0; | |
309 | cursor.set |= FB_CUR_SETHOT; | |
310 | } | |
311 | ||
312 | if (cursor.set & FB_CUR_SETSIZE || | |
b73deed3 | 313 | vc->vc_cursor_type != ops->p->cursor_shape || |
1da177e4 LT |
314 | ops->cursor_state.mask == NULL || |
315 | ops->cursor_reset) { | |
316 | char *mask = kmalloc(w*vc->vc_font.height, GFP_ATOMIC); | |
317 | int cur_height, size, i = 0; | |
318 | u8 msk = 0xff; | |
319 | ||
320 | if (!mask) | |
321 | return; | |
322 | ||
323 | kfree(ops->cursor_state.mask); | |
324 | ops->cursor_state.mask = mask; | |
325 | ||
b73deed3 | 326 | ops->p->cursor_shape = vc->vc_cursor_type; |
1da177e4 LT |
327 | cursor.set |= FB_CUR_SETSHAPE; |
328 | ||
b73deed3 | 329 | switch (ops->p->cursor_shape & CUR_HWMASK) { |
1da177e4 LT |
330 | case CUR_NONE: |
331 | cur_height = 0; | |
332 | break; | |
333 | case CUR_UNDERLINE: | |
334 | cur_height = (vc->vc_font.height < 10) ? 1 : 2; | |
335 | break; | |
336 | case CUR_LOWER_THIRD: | |
337 | cur_height = vc->vc_font.height/3; | |
338 | break; | |
339 | case CUR_LOWER_HALF: | |
340 | cur_height = vc->vc_font.height >> 1; | |
341 | break; | |
342 | case CUR_TWO_THIRDS: | |
343 | cur_height = (vc->vc_font.height << 1)/3; | |
344 | break; | |
345 | case CUR_BLOCK: | |
346 | default: | |
347 | cur_height = vc->vc_font.height; | |
348 | break; | |
349 | } | |
350 | size = (vc->vc_font.height - cur_height) * w; | |
351 | while (size--) | |
352 | mask[i++] = ~msk; | |
353 | size = cur_height * w; | |
354 | while (size--) | |
355 | mask[i++] = msk; | |
356 | } | |
357 | ||
358 | switch (mode) { | |
359 | case CM_ERASE: | |
360 | ops->cursor_state.enable = 0; | |
361 | break; | |
362 | case CM_DRAW: | |
363 | case CM_MOVE: | |
364 | default: | |
365 | ops->cursor_state.enable = (use_sw) ? 0 : 1; | |
366 | break; | |
367 | } | |
368 | ||
369 | cursor.image.data = src; | |
370 | cursor.image.fg_color = ops->cursor_state.image.fg_color; | |
371 | cursor.image.bg_color = ops->cursor_state.image.bg_color; | |
372 | cursor.image.dx = ops->cursor_state.image.dx; | |
373 | cursor.image.dy = ops->cursor_state.image.dy; | |
374 | cursor.image.height = ops->cursor_state.image.height; | |
375 | cursor.image.width = ops->cursor_state.image.width; | |
376 | cursor.hot.x = ops->cursor_state.hot.x; | |
377 | cursor.hot.y = ops->cursor_state.hot.y; | |
378 | cursor.mask = ops->cursor_state.mask; | |
379 | cursor.enable = ops->cursor_state.enable; | |
380 | cursor.image.depth = 1; | |
381 | cursor.rop = ROP_XOR; | |
382 | ||
c465e05a AD |
383 | if (info->fbops->fb_cursor) |
384 | err = info->fbops->fb_cursor(info, &cursor); | |
385 | ||
386 | if (err) | |
387 | soft_cursor(info, &cursor); | |
1da177e4 LT |
388 | |
389 | ops->cursor_reset = 0; | |
390 | } | |
391 | ||
e4fc2761 AD |
392 | static int bit_update_start(struct fb_info *info) |
393 | { | |
394 | struct fbcon_ops *ops = info->fbcon_par; | |
395 | int err; | |
396 | ||
397 | err = fb_pan_display(info, &ops->var); | |
398 | ops->var.xoffset = info->var.xoffset; | |
399 | ops->var.yoffset = info->var.yoffset; | |
400 | ops->var.vmode = info->var.vmode; | |
401 | return err; | |
402 | } | |
403 | ||
1da177e4 LT |
404 | void fbcon_set_bitops(struct fbcon_ops *ops) |
405 | { | |
406 | ops->bmove = bit_bmove; | |
407 | ops->clear = bit_clear; | |
408 | ops->putcs = bit_putcs; | |
409 | ops->clear_margins = bit_clear_margins; | |
410 | ops->cursor = bit_cursor; | |
e4fc2761 AD |
411 | ops->update_start = bit_update_start; |
412 | ops->rotate_font = NULL; | |
413 | ||
414 | if (ops->rotate) | |
415 | fbcon_set_rotate(ops); | |
1da177e4 LT |
416 | } |
417 | ||
418 | EXPORT_SYMBOL(fbcon_set_bitops); | |
419 | ||
420 | MODULE_AUTHOR("Antonino Daplas <adaplas@pol.net>"); | |
421 | MODULE_DESCRIPTION("Bit Blitting Operation"); | |
422 | MODULE_LICENSE("GPL"); | |
423 |