File: /usr/src/linux/drivers/video/fbcon-iplan2p4.c
1 /*
2 * linux/drivers/video/fbcon-iplan2p4.c -- Low level frame buffer operations
3 * for interleaved bitplanes à la Atari (4
4 * planes, 2 bytes interleave)
5 *
6 * Created 5 Apr 1997 by Geert Uytterhoeven
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
13 #include <linux/module.h>
14 #include <linux/tty.h>
15 #include <linux/console.h>
16 #include <linux/string.h>
17 #include <linux/fb.h>
18
19 #include <asm/byteorder.h>
20
21 #ifdef __mc68000__
22 #include <asm/setup.h>
23 #endif
24
25 #include <video/fbcon.h>
26 #include <video/fbcon-iplan2p4.h>
27
28
29 /*
30 * Interleaved bitplanes à la Atari (4 planes, 2 bytes interleave)
31 */
32
33 /* Increment/decrement 4 plane addresses */
34
35 #define INC_4P(p) do { if (!((long)(++(p)) & 1)) (p) += 6; } while(0)
36 #define DEC_4P(p) do { if ((long)(--(p)) & 1) (p) -= 6; } while(0)
37
38 /* Perform the m68k movepl operation. */
39 static inline void movepl(u8 *d, u32 val)
40 {
41 #if defined __mc68000__ && !defined CPU_M68060_ONLY
42 asm volatile ("movepl %1,%0@(0)" : : "a" (d), "d" (val));
43 #else
44 d[0] = (val >> 24) & 0xff;
45 d[2] = (val >> 16) & 0xff;
46 d[4] = (val >> 8) & 0xff;
47 d[6] = val & 0xff;
48 #endif
49 }
50
51 /* Sets the bytes in the visible column at d, height h, to the value
52 * val for a 4 plane screen. The bits of the color in 'color' are
53 * moved (8 times) to the respective bytes. This means:
54 *
55 * for(h times; d += bpr)
56 * *d = (color & 1) ? 0xff : 0;
57 * *(d+2) = (color & 2) ? 0xff : 0;
58 * *(d+4) = (color & 4) ? 0xff : 0;
59 * *(d+6) = (color & 8) ? 0xff : 0;
60 */
61
62 static __inline__ void memclear_4p_col(void *d, size_t h, u32 val, int bpr)
63 {
64 u8 *dd = d;
65 do {
66 movepl(dd, val);
67 dd += bpr;
68 } while (--h);
69 }
70
71 /* Sets a 4 plane region from 'd', length 'count' bytes, to the color
72 * in val1/val2. 'd' has to be an even address and count must be divisible
73 * by 8, because only whole words and all planes are accessed. I.e.:
74 *
75 * for(count/8 times)
76 * *d = *(d+1) = (color & 1) ? 0xff : 0;
77 * *(d+2) = *(d+3) = (color & 2) ? 0xff : 0;
78 * *(d+4) = *(d+5) = (color & 4) ? 0xff : 0;
79 * *(d+6) = *(d+7) = (color & 8) ? 0xff : 0;
80 */
81
82 static __inline__ void memset_even_4p(void *d, size_t count, u32 val1,
83 u32 val2)
84 {
85 u32 *dd = d;
86
87 count /= 8;
88 while (count--) {
89 *dd++ = val1;
90 *dd++ = val2;
91 }
92 }
93
94 /* Copies a 4 plane column from 's', height 'h', to 'd'. */
95
96 static __inline__ void memmove_4p_col (void *d, void *s, int h, int bpr)
97 {
98 u8 *dd = d, *ss = s;
99
100 while (h--) {
101 dd[0] = ss[0];
102 dd[2] = ss[2];
103 dd[4] = ss[4];
104 dd[6] = ss[6];
105 dd += bpr;
106 ss += bpr;
107 }
108 }
109
110
111 /* This expands a 4 bit color into a long for movepl (4 plane) operations. */
112
113 static const u32 four2byte[] = {
114 0x00000000, 0xff000000, 0x00ff0000, 0xffff0000,
115 0x0000ff00, 0xff00ff00, 0x00ffff00, 0xffffff00,
116 0x000000ff, 0xff0000ff, 0x00ff00ff, 0xffff00ff,
117 0x0000ffff, 0xff00ffff, 0x00ffffff, 0xffffffff
118 };
119
120 static __inline__ u32 expand4l(u8 c)
121 {
122 return four2byte[c];
123 }
124
125
126 /* This expands a 4 bit color into two longs for two movel operations
127 * (4 planes).
128 */
129
130 static const u32 two2word[] = {
131 #ifndef __LITTLE_ENDIAN
132 0x00000000, 0xffff0000, 0x0000ffff, 0xffffffff,
133 #else
134 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff,
135 #endif
136 };
137
138 static __inline__ void expand4dl(u8 c, u32 *ret1, u32 *ret2)
139 {
140 *ret1 = two2word[c & 3];
141 *ret2 = two2word[c >> 2];
142 }
143
144
145 /* This duplicates a byte 4 times into a long. */
146
147 static __inline__ u32 dup4l(u8 c)
148 {
149 u32 rv;
150
151 rv = c;
152 rv |= rv << 8;
153 rv |= rv << 16;
154 return rv;
155 }
156
157
158 void fbcon_iplan2p4_setup(struct display *p)
159 {
160 p->next_line = p->var.xres_virtual>>1;
161 p->next_plane = 2;
162 }
163
164 void fbcon_iplan2p4_bmove(struct display *p, int sy, int sx, int dy, int dx,
165 int height, int width)
166 {
167 /* bmove() has to distinguish two major cases: If both, source and
168 * destination, start at even addresses or both are at odd
169 * addresses, just the first odd and last even column (if present)
170 * require special treatment (memmove_col()). The rest between
171 * then can be copied by normal operations, because all adjacent
172 * bytes are affected and are to be stored in the same order.
173 * The pathological case is when the move should go from an odd
174 * address to an even or vice versa. Since the bytes in the plane
175 * words must be assembled in new order, it seems wisest to make
176 * all movements by memmove_col().
177 */
178
179 if (sx == 0 && dx == 0 && width * 4 == p->next_line) {
180 /* Special (but often used) case: Moving whole lines can be
181 *done with memmove()
182 */
183 fb_memmove(p->screen_base + dy * p->next_line * fontheight(p),
184 p->screen_base + sy * p->next_line * fontheight(p),
185 p->next_line * height * fontheight(p));
186 } else {
187 int rows, cols;
188 u8 *src;
189 u8 *dst;
190 int bytes = p->next_line;
191 int linesize;
192 u_int colsize;
193 u_int upwards = (dy < sy) || (dy == sy && dx < sx);
194
195 if (fontheightlog(p)) {
196 linesize = bytes << fontheightlog(p);
197 colsize = height << fontheightlog(p);
198 } else {
199 linesize = bytes * fontheight(p);
200 colsize = height * fontheight(p);
201 }
202 if ((sx & 1) == (dx & 1)) {
203 /* odd->odd or even->even */
204
205 if (upwards) {
206 src = p->screen_base + sy * linesize + (sx>>1)*8 + (sx & 1);
207 dst = p->screen_base + dy * linesize + (dx>>1)*8 + (dx & 1);
208 if (sx & 1) {
209 memmove_4p_col(dst, src, colsize, bytes);
210 src += 7;
211 dst += 7;
212 --width;
213 }
214 if (width > 1) {
215 for(rows = colsize; rows > 0; --rows) {
216 fb_memmove(dst, src, (width>>1)*8);
217 src += bytes;
218 dst += bytes;
219 }
220 }
221 if (width & 1) {
222 src -= colsize * bytes;
223 dst -= colsize * bytes;
224 memmove_4p_col(dst + (width>>1)*8, src + (width>>1)*8,
225 colsize, bytes);
226 }
227 } else {
228 if (!((sx+width-1) & 1)) {
229 src = p->screen_base + sy * linesize + ((sx+width-1)>>1)*8;
230 dst = p->screen_base + dy * linesize + ((dx+width-1)>>1)*8;
231 memmove_4p_col(dst, src, colsize, bytes);
232 --width;
233 }
234 src = p->screen_base + sy * linesize + (sx>>1)*8 + (sx & 1);
235 dst = p->screen_base + dy * linesize + (dx>>1)*8 + (dx & 1);
236 if (width > 1) {
237 src += colsize * bytes + (sx & 1)*7;
238 dst += colsize * bytes + (sx & 1)*7;
239 for(rows = colsize; rows > 0; --rows) {
240 src -= bytes;
241 dst -= bytes;
242 fb_memmove(dst, src, (width>>1)*8);
243 }
244 }
245 if (width & 1) {
246 memmove_4p_col(dst-7, src-7, colsize, bytes);
247 }
248 }
249 } else {
250 /* odd->even or even->odd */
251
252 if (upwards) {
253 src = p->screen_base + sy * linesize + (sx>>1)*8 + (sx & 1);
254 dst = p->screen_base + dy * linesize + (dx>>1)*8 + (dx & 1);
255 for(cols = width; cols > 0; --cols) {
256 memmove_4p_col(dst, src, colsize, bytes);
257 INC_4P(src);
258 INC_4P(dst);
259 }
260 } else {
261 sx += width-1;
262 dx += width-1;
263 src = p->screen_base + sy * linesize + (sx>>1)*8 + (sx & 1);
264 dst = p->screen_base + dy * linesize + (dx>>1)*8 + (dx & 1);
265 for(cols = width; cols > 0; --cols) {
266 memmove_4p_col(dst, src, colsize, bytes);
267 DEC_4P(src);
268 DEC_4P(dst);
269 }
270 }
271 }
272 }
273 }
274
275 void fbcon_iplan2p4_clear(struct vc_data *conp, struct display *p, int sy,
276 int sx, int height, int width)
277 {
278 u32 offset;
279 u8 *start;
280 int rows;
281 int bytes = p->next_line;
282 int lines;
283 u32 size;
284 u32 cval1, cval2, pcval;
285
286 expand4dl(attr_bgcol_ec(p,conp), &cval1, &cval2);
287
288 if (fontheightlog(p))
289 lines = height << fontheightlog(p);
290 else
291 lines = height * fontheight(p);
292
293 if (sx == 0 && width * 4 == bytes) {
294 if (fontheightlog(p))
295 offset = (sy * bytes) << fontheightlog(p);
296 else
297 offset = sy * bytes * fontheight(p);
298 size = lines * bytes;
299 memset_even_4p(p->screen_base+offset, size, cval1, cval2);
300 } else {
301 if (fontheightlog(p))
302 offset = ((sy * bytes) << fontheightlog(p)) + (sx>>1)*8 + (sx & 1);
303 else
304 offset = sy * bytes * fontheight(p) + (sx>>1)*8 + (sx & 1);
305 start = p->screen_base + offset;
306 pcval = expand4l(attr_bgcol_ec(p,conp));
307
308 /* Clears are split if the region starts at an odd column or
309 * end at an even column. These extra columns are spread
310 * across the interleaved planes. All in between can be
311 * cleared by normal fb_memclear_small(), because both bytes of
312 * the single plane words are affected.
313 */
314
315 if (sx & 1) {
316 memclear_4p_col(start, lines, pcval, bytes);
317 start += 7;
318 width--;
319 }
320 if (width & 1) {
321 memclear_4p_col(start + (width>>1)*8, lines, pcval, bytes);
322 width--;
323 }
324 if (width) {
325 for(rows = lines; rows-- ; start += bytes)
326 memset_even_4p(start, width*4, cval1, cval2);
327 }
328 }
329 }
330
331 void fbcon_iplan2p4_putc(struct vc_data *conp, struct display *p, int c,
332 int yy, int xx)
333 {
334 u8 *dest;
335 u8 *cdat;
336 int rows;
337 int bytes = p->next_line;
338 u32 eorx, fgx, bgx, fdx;
339
340 if (fontheightlog(p)) {
341 dest = (p->screen_base + ((yy * bytes) << fontheightlog(p)) +
342 (xx>>1)*8 + (xx & 1));
343 cdat = p->fontdata + ((c & p->charmask) << fontheightlog(p));
344 } else {
345 dest = (p->screen_base + yy * bytes * fontheight(p) +
346 (xx>>1)*8 + (xx & 1));
347 cdat = p->fontdata + (c & p->charmask) * fontheight(p);
348 }
349
350 fgx = expand4l(attr_fgcol(p,c));
351 bgx = expand4l(attr_bgcol(p,c));
352 eorx = fgx ^ bgx;
353
354 for(rows = fontheight(p) ; rows-- ; dest += bytes) {
355 fdx = dup4l(*cdat++);
356 movepl(dest, (fdx & eorx) ^ bgx);
357 }
358 }
359
360 void fbcon_iplan2p4_putcs(struct vc_data *conp, struct display *p,
361 const unsigned short *s, int count, int yy, int xx)
362 {
363 u8 *dest, *dest0;
364 u8 *cdat;
365 u16 c;
366 int rows;
367 int bytes;
368 u32 eorx, fgx, bgx, fdx;
369
370 bytes = p->next_line;
371 if (fontheightlog(p))
372 dest0 = (p->screen_base + ((yy * bytes) << fontheightlog(p)) +
373 (xx>>1)*8 + (xx & 1));
374 else
375 dest0 = (p->screen_base + yy * bytes * fontheight(p) +
376 (xx>>1)*8 + (xx & 1));
377 fgx = expand4l(attr_fgcol(p,scr_readw(s)));
378 bgx = expand4l(attr_bgcol(p,scr_readw(s)));
379 eorx = fgx ^ bgx;
380
381 while (count--) {
382 /* I think, unrolling the loops like in the 1 plane case isn't
383 * practicable here, because the body is much longer for 4
384 * planes (mostly the dup4l()). I guess, unrolling this would
385 * need more than 256 bytes and so exceed the instruction
386 * cache :-(
387 */
388
389 c = scr_readw(s++) & p->charmask;
390 if (fontheightlog(p))
391 cdat = p->fontdata + (c << fontheightlog(p));
392 else
393 cdat = p->fontdata + c * fontheight(p);
394
395 for(rows = fontheight(p), dest = dest0; rows-- ; dest += bytes) {
396 fdx = dup4l(*cdat++);
397 movepl(dest, (fdx & eorx) ^ bgx);
398 }
399 INC_4P(dest0);
400 }
401 }
402
403 void fbcon_iplan2p4_revc(struct display *p, int xx, int yy)
404 {
405 u8 *dest;
406 int j;
407 int bytes;
408
409 if (fontheightlog(p))
410 dest = (p->screen_base + ((yy * p->next_line) << fontheightlog(p)) +
411 (xx>>1)*8 + (xx & 1));
412 else
413 dest = (p->screen_base + yy * p->next_line * fontheight(p) +
414 (xx>>1)*8 + (xx & 1));
415 j = fontheight(p);
416 bytes = p->next_line;
417
418 while (j--) {
419 /* This should really obey the individual character's
420 * background and foreground colors instead of simply
421 * inverting.
422 */
423 dest[0] = ~dest[0];
424 dest[2] = ~dest[2];
425 dest[4] = ~dest[4];
426 dest[6] = ~dest[6];
427 dest += bytes;
428 }
429 }
430
431 void fbcon_iplan2p4_clear_margins(struct vc_data *conp, struct display *p,
432 int bottom_only)
433 {
434 u32 offset;
435 int bytes;
436 int lines;
437 u32 cval1, cval2;
438
439 /* No need to handle right margin, cannot occur with fontwidth == 8 */
440
441 bytes = p->next_line;
442 if (fontheightlog(p)) {
443 lines = p->var.yres - (conp->vc_rows << fontheightlog(p));
444 offset = ((p->yscroll + conp->vc_rows) * bytes) << fontheightlog(p);
445 } else {
446 lines = p->var.yres - conp->vc_rows * fontheight(p);
447 offset = (p->yscroll + conp->vc_rows) * bytes * fontheight(p);
448 }
449 if (lines) {
450 expand4dl(attr_bgcol_ec(p,conp), &cval1, &cval2);
451 memset_even_4p(p->screen_base+offset, lines * bytes, cval1, cval2);
452 }
453 }
454
455
456 /*
457 * `switch' for the low level operations
458 */
459
460 struct display_switch fbcon_iplan2p4 = {
461 setup: fbcon_iplan2p4_setup,
462 bmove: fbcon_iplan2p4_bmove,
463 clear: fbcon_iplan2p4_clear,
464 putc: fbcon_iplan2p4_putc,
465 putcs: fbcon_iplan2p4_putcs,
466 revc: fbcon_iplan2p4_revc,
467 clear_margins: fbcon_iplan2p4_clear_margins,
468 fontwidthmask: FONTWIDTH(8)
469 };
470
471
472 #ifdef MODULE
473 MODULE_LICENSE("GPL");
474
475 int init_module(void)
476 {
477 return 0;
478 }
479
480 void cleanup_module(void)
481 {}
482 #endif /* MODULE */
483
484
485 /*
486 * Visible symbols for modules
487 */
488
489 EXPORT_SYMBOL(fbcon_iplan2p4);
490 EXPORT_SYMBOL(fbcon_iplan2p4_setup);
491 EXPORT_SYMBOL(fbcon_iplan2p4_bmove);
492 EXPORT_SYMBOL(fbcon_iplan2p4_clear);
493 EXPORT_SYMBOL(fbcon_iplan2p4_putc);
494 EXPORT_SYMBOL(fbcon_iplan2p4_putcs);
495 EXPORT_SYMBOL(fbcon_iplan2p4_revc);
496 EXPORT_SYMBOL(fbcon_iplan2p4_clear_margins);
497