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 | 164 | if (attribute) { |
72caa5fb | 165 | buf = kmalloc(cellsize, GFP_ATOMIC); |
829e79b6 AD |
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 | { | |
1da177e4 LT |
208 | unsigned int cw = vc->vc_font.width; |
209 | unsigned int ch = vc->vc_font.height; | |
210 | unsigned int rw = info->var.xres - (vc->vc_cols*cw); | |
211 | unsigned int bh = info->var.yres - (vc->vc_rows*ch); | |
212 | unsigned int rs = info->var.xres - rw; | |
213 | unsigned int bs = info->var.yres - bh; | |
214 | struct fb_fillrect region; | |
215 | ||
f74a289b | 216 | region.color = 0; |
1da177e4 LT |
217 | region.rop = ROP_COPY; |
218 | ||
219 | if (rw && !bottom_only) { | |
220 | region.dx = info->var.xoffset + rs; | |
221 | region.dy = 0; | |
222 | region.width = rw; | |
223 | region.height = info->var.yres_virtual; | |
224 | info->fbops->fb_fillrect(info, ®ion); | |
225 | } | |
226 | ||
227 | if (bh) { | |
228 | region.dx = info->var.xoffset; | |
229 | region.dy = info->var.yoffset + bs; | |
230 | region.width = rs; | |
231 | region.height = bh; | |
232 | info->fbops->fb_fillrect(info, ®ion); | |
233 | } | |
234 | } | |
235 | ||
b73deed3 AD |
236 | static void bit_cursor(struct vc_data *vc, struct fb_info *info, int mode, |
237 | int softback_lines, int fg, int bg) | |
1da177e4 LT |
238 | { |
239 | struct fb_cursor cursor; | |
b73deed3 | 240 | struct fbcon_ops *ops = info->fbcon_par; |
1da177e4 | 241 | unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff; |
9a4a83d2 | 242 | int w = DIV_ROUND_UP(vc->vc_font.width, 8), c; |
b73deed3 | 243 | int y = real_y(ops->p, vc->vc_y); |
1da177e4 | 244 | int attribute, use_sw = (vc->vc_cursor_type & 0x10); |
c465e05a | 245 | int err = 1; |
1da177e4 LT |
246 | char *src; |
247 | ||
248 | cursor.set = 0; | |
249 | ||
250 | if (softback_lines) { | |
251 | if (y + softback_lines >= vc->vc_rows) { | |
252 | mode = CM_ERASE; | |
253 | ops->cursor_flash = 0; | |
254 | return; | |
255 | } else | |
256 | y += softback_lines; | |
257 | } | |
258 | ||
259 | c = scr_readw((u16 *) vc->vc_pos); | |
260 | attribute = get_attribute(info, c); | |
261 | src = vc->vc_font.data + ((c & charmask) * (w * vc->vc_font.height)); | |
262 | ||
263 | if (ops->cursor_state.image.data != src || | |
264 | ops->cursor_reset) { | |
265 | ops->cursor_state.image.data = src; | |
266 | cursor.set |= FB_CUR_SETIMAGE; | |
267 | } | |
268 | ||
269 | if (attribute) { | |
270 | u8 *dst; | |
271 | ||
272 | dst = kmalloc(w * vc->vc_font.height, GFP_ATOMIC); | |
273 | if (!dst) | |
274 | return; | |
275 | kfree(ops->cursor_data); | |
276 | ops->cursor_data = dst; | |
277 | update_attr(dst, src, attribute, vc); | |
278 | src = dst; | |
279 | } | |
280 | ||
281 | if (ops->cursor_state.image.fg_color != fg || | |
282 | ops->cursor_state.image.bg_color != bg || | |
283 | ops->cursor_reset) { | |
284 | ops->cursor_state.image.fg_color = fg; | |
285 | ops->cursor_state.image.bg_color = bg; | |
286 | cursor.set |= FB_CUR_SETCMAP; | |
287 | } | |
288 | ||
289 | if ((ops->cursor_state.image.dx != (vc->vc_font.width * vc->vc_x)) || | |
290 | (ops->cursor_state.image.dy != (vc->vc_font.height * y)) || | |
291 | ops->cursor_reset) { | |
292 | ops->cursor_state.image.dx = vc->vc_font.width * vc->vc_x; | |
293 | ops->cursor_state.image.dy = vc->vc_font.height * y; | |
294 | cursor.set |= FB_CUR_SETPOS; | |
295 | } | |
296 | ||
297 | if (ops->cursor_state.image.height != vc->vc_font.height || | |
298 | ops->cursor_state.image.width != vc->vc_font.width || | |
299 | ops->cursor_reset) { | |
300 | ops->cursor_state.image.height = vc->vc_font.height; | |
301 | ops->cursor_state.image.width = vc->vc_font.width; | |
302 | cursor.set |= FB_CUR_SETSIZE; | |
303 | } | |
304 | ||
305 | if (ops->cursor_state.hot.x || ops->cursor_state.hot.y || | |
306 | ops->cursor_reset) { | |
307 | ops->cursor_state.hot.x = cursor.hot.y = 0; | |
308 | cursor.set |= FB_CUR_SETHOT; | |
309 | } | |
310 | ||
311 | if (cursor.set & FB_CUR_SETSIZE || | |
b73deed3 | 312 | vc->vc_cursor_type != ops->p->cursor_shape || |
1da177e4 LT |
313 | ops->cursor_state.mask == NULL || |
314 | ops->cursor_reset) { | |
315 | char *mask = kmalloc(w*vc->vc_font.height, GFP_ATOMIC); | |
316 | int cur_height, size, i = 0; | |
317 | u8 msk = 0xff; | |
318 | ||
319 | if (!mask) | |
320 | return; | |
321 | ||
322 | kfree(ops->cursor_state.mask); | |
323 | ops->cursor_state.mask = mask; | |
324 | ||
b73deed3 | 325 | ops->p->cursor_shape = vc->vc_cursor_type; |
1da177e4 LT |
326 | cursor.set |= FB_CUR_SETSHAPE; |
327 | ||
b73deed3 | 328 | switch (ops->p->cursor_shape & CUR_HWMASK) { |
1da177e4 LT |
329 | case CUR_NONE: |
330 | cur_height = 0; | |
331 | break; | |
332 | case CUR_UNDERLINE: | |
333 | cur_height = (vc->vc_font.height < 10) ? 1 : 2; | |
334 | break; | |
335 | case CUR_LOWER_THIRD: | |
336 | cur_height = vc->vc_font.height/3; | |
337 | break; | |
338 | case CUR_LOWER_HALF: | |
339 | cur_height = vc->vc_font.height >> 1; | |
340 | break; | |
341 | case CUR_TWO_THIRDS: | |
342 | cur_height = (vc->vc_font.height << 1)/3; | |
343 | break; | |
344 | case CUR_BLOCK: | |
345 | default: | |
346 | cur_height = vc->vc_font.height; | |
347 | break; | |
348 | } | |
349 | size = (vc->vc_font.height - cur_height) * w; | |
350 | while (size--) | |
351 | mask[i++] = ~msk; | |
352 | size = cur_height * w; | |
353 | while (size--) | |
354 | mask[i++] = msk; | |
355 | } | |
356 | ||
357 | switch (mode) { | |
358 | case CM_ERASE: | |
359 | ops->cursor_state.enable = 0; | |
360 | break; | |
361 | case CM_DRAW: | |
362 | case CM_MOVE: | |
363 | default: | |
364 | ops->cursor_state.enable = (use_sw) ? 0 : 1; | |
365 | break; | |
366 | } | |
367 | ||
368 | cursor.image.data = src; | |
369 | cursor.image.fg_color = ops->cursor_state.image.fg_color; | |
370 | cursor.image.bg_color = ops->cursor_state.image.bg_color; | |
371 | cursor.image.dx = ops->cursor_state.image.dx; | |
372 | cursor.image.dy = ops->cursor_state.image.dy; | |
373 | cursor.image.height = ops->cursor_state.image.height; | |
374 | cursor.image.width = ops->cursor_state.image.width; | |
375 | cursor.hot.x = ops->cursor_state.hot.x; | |
376 | cursor.hot.y = ops->cursor_state.hot.y; | |
377 | cursor.mask = ops->cursor_state.mask; | |
378 | cursor.enable = ops->cursor_state.enable; | |
379 | cursor.image.depth = 1; | |
380 | cursor.rop = ROP_XOR; | |
381 | ||
c465e05a AD |
382 | if (info->fbops->fb_cursor) |
383 | err = info->fbops->fb_cursor(info, &cursor); | |
384 | ||
385 | if (err) | |
386 | soft_cursor(info, &cursor); | |
1da177e4 LT |
387 | |
388 | ops->cursor_reset = 0; | |
389 | } | |
390 | ||
e4fc2761 AD |
391 | static int bit_update_start(struct fb_info *info) |
392 | { | |
393 | struct fbcon_ops *ops = info->fbcon_par; | |
394 | int err; | |
395 | ||
396 | err = fb_pan_display(info, &ops->var); | |
397 | ops->var.xoffset = info->var.xoffset; | |
398 | ops->var.yoffset = info->var.yoffset; | |
399 | ops->var.vmode = info->var.vmode; | |
400 | return err; | |
401 | } | |
402 | ||
1da177e4 LT |
403 | void fbcon_set_bitops(struct fbcon_ops *ops) |
404 | { | |
405 | ops->bmove = bit_bmove; | |
406 | ops->clear = bit_clear; | |
407 | ops->putcs = bit_putcs; | |
408 | ops->clear_margins = bit_clear_margins; | |
409 | ops->cursor = bit_cursor; | |
e4fc2761 AD |
410 | ops->update_start = bit_update_start; |
411 | ops->rotate_font = NULL; | |
412 | ||
413 | if (ops->rotate) | |
414 | fbcon_set_rotate(ops); | |
1da177e4 LT |
415 | } |
416 | ||
417 | EXPORT_SYMBOL(fbcon_set_bitops); | |
418 | ||
419 | MODULE_AUTHOR("Antonino Daplas <adaplas@pol.net>"); | |
420 | MODULE_DESCRIPTION("Bit Blitting Operation"); | |
421 | MODULE_LICENSE("GPL"); | |
422 |