![[BACK]](/icons/back.gif){kind=icon}
Return to rasops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / rasops|
Return to rasops.c CVS log | Up to [local] / sys / dev / rasops |
1.1 nbrk 1: /* $OpenBSD: rasops.c,v 1.17 2006/12/02 18:02:53 miod Exp $ */
2: /* $NetBSD: rasops.c,v 1.35 2001/02/02 06:01:01 marcus Exp $ */
3:
4: /*-
5: * Copyright (c) 1999 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Andrew Doran.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: #include <sys/param.h>
41: #include <sys/systm.h>
42: #include <sys/time.h>
43:
44: #include <machine/endian.h>
45:
46: #include <dev/wscons/wsdisplayvar.h>
47: #include <dev/wscons/wsconsio.h>
48: #include <dev/wsfont/wsfont.h>
49: #include <dev/rasops/rasops.h>
50:
51: #ifndef _KERNEL
52: #include <errno.h>
53: #endif
54:
55: /* ANSI colormap (R,G,B) */
56:
57: #define NORMAL_BLACK 0x000000
58: #define NORMAL_RED 0x7f0000
59: #define NORMAL_GREEN 0x007f00
60: #define NORMAL_BROWN 0x7f7f00
61: #define NORMAL_BLUE 0x00007f
62: #define NORMAL_MAGENTA 0x7f007f
63: #define NORMAL_CYAN 0x007f7f
64: #define NORMAL_WHITE 0xc7c7c7 /* XXX too dim? */
65:
66: #define HILITE_BLACK 0x7f7f7f
67: #define HILITE_RED 0xff0000
68: #define HILITE_GREEN 0x00ff00
69: #define HILITE_BROWN 0xffff00
70: #define HILITE_BLUE 0x0000ff
71: #define HILITE_MAGENTA 0xff00ff
72: #define HILITE_CYAN 0x00ffff
73: #define HILITE_WHITE 0xffffff
74:
75: const u_char rasops_cmap[256 * 3] = {
76: #define _C(x) ((x) & 0xff0000) >> 16, ((x) & 0x00ff00) >> 8, ((x) & 0x0000ff)
77:
78: _C(NORMAL_BLACK),
79: _C(NORMAL_RED),
80: _C(NORMAL_GREEN),
81: _C(NORMAL_BROWN),
82: _C(NORMAL_BLUE),
83: _C(NORMAL_MAGENTA),
84: _C(NORMAL_CYAN),
85: _C(NORMAL_WHITE),
86:
87: _C(HILITE_BLACK),
88: _C(HILITE_RED),
89: _C(HILITE_GREEN),
90: _C(HILITE_BROWN),
91: _C(HILITE_BLUE),
92: _C(HILITE_MAGENTA),
93: _C(HILITE_CYAN),
94: _C(HILITE_WHITE),
95:
96: /*
97: * For the cursor, we need the last 16 colors to be the
98: * opposite of the first 16. Fill the intermediate space with
99: * white completely for simplicity.
100: */
101: #define _CMWHITE16 \
102: _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), \
103: _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), \
104: _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), \
105: _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE), _C(HILITE_WHITE),
106: _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
107: _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
108: _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
109: #undef _CMWHITE16
110:
111: _C(~HILITE_WHITE),
112: _C(~HILITE_CYAN),
113: _C(~HILITE_MAGENTA),
114: _C(~HILITE_BLUE),
115: _C(~HILITE_BROWN),
116: _C(~HILITE_GREEN),
117: _C(~HILITE_RED),
118: _C(~HILITE_BLACK),
119:
120: _C(~NORMAL_WHITE),
121: _C(~NORMAL_CYAN),
122: _C(~NORMAL_MAGENTA),
123: _C(~NORMAL_BLUE),
124: _C(~NORMAL_BROWN),
125: _C(~NORMAL_GREEN),
126: _C(~NORMAL_RED),
127: _C(~NORMAL_BLACK),
128:
129: #undef _C
130: };
131:
132: /* True if color is gray */
133: const u_char rasops_isgray[16] = {
134: 1, 0, 0, 0,
135: 0, 0, 0, 1,
136: 1, 0, 0, 0,
137: 0, 0, 0, 1
138: };
139:
140: /* Generic functions */
141: void rasops_copycols(void *, int, int, int, int);
142: void rasops_copyrows(void *, int, int, int);
143: int rasops_mapchar(void *, int, u_int *);
144: void rasops_cursor(void *, int, int, int);
145: int rasops_alloc_cattr(void *, int, int, int, long *);
146: int rasops_alloc_mattr(void *, int, int, int, long *);
147: void rasops_do_cursor(struct rasops_info *);
148: void rasops_init_devcmap(struct rasops_info *);
149: void rasops_unpack_attr(void *, long, int *, int *, int *);
150: #if NRASOPS_BSWAP > 0
151: static void slow_ovbcopy(void *, void *, size_t);
152: #endif
153: #if NRASOPS_ROTATION > 0
154: void rasops_copychar(void *, int, int, int, int);
155: void rasops_copycols_rotated(void *, int, int, int, int);
156: void rasops_copyrows_rotated(void *, int, int, int);
157: void rasops_erasecols_rotated(void *, int, int, int, long);
158: void rasops_eraserows_rotated(void *, int, int, long);
159: void rasops_putchar_rotated(void *, int, int, u_int, long);
160: void rasops_rotate_font(int *);
161:
162: /*
163: * List of all rotated fonts
164: */
165: SLIST_HEAD(, rotatedfont) rotatedfonts = SLIST_HEAD_INITIALIZER(rotatedfonts);
166: struct rotatedfont {
167: SLIST_ENTRY(rotatedfont) rf_next;
168: int rf_cookie;
169: int rf_rotated;
170: };
171: #endif
172:
173: /*
174: * Initialize a 'rasops_info' descriptor.
175: */
176: int
177: rasops_init(ri, wantrows, wantcols)
178: struct rasops_info *ri;
179: int wantrows, wantcols;
180: {
181:
182: #ifdef _KERNEL
183: /* Select a font if the caller doesn't care */
184: if (ri->ri_font == NULL) {
185: int cookie;
186:
187: wsfont_init();
188:
189: if (ri->ri_width > 80*12)
190: /* High res screen, choose a big font */
191: cookie = wsfont_find(NULL, 12, 0, 0);
192: else
193: /* lower res, choose a 8 pixel wide font */
194: cookie = wsfont_find(NULL, 8, 0, 0);
195:
196: if (cookie <= 0)
197: cookie = wsfont_find(NULL, 0, 0, 0);
198:
199: if (cookie <= 0) {
200: printf("rasops_init: font table is empty\n");
201: return (-1);
202: }
203:
204: #if NRASOPS_ROTATION > 0
205: /*
206: * Pick the rotated version of this font. This will create it
207: * if necessary.
208: */
209: if (ri->ri_flg & RI_ROTATE_CW)
210: rasops_rotate_font(&cookie);
211: #endif
212:
213: if (wsfont_lock(cookie, &ri->ri_font,
214: WSDISPLAY_FONTORDER_L2R, WSDISPLAY_FONTORDER_L2R) <= 0) {
215: printf("rasops_init: couldn't lock font\n");
216: return (-1);
217: }
218:
219: ri->ri_wsfcookie = cookie;
220: }
221: #endif
222:
223: /* This should never happen in reality... */
224: #ifdef DEBUG
225: if ((long)ri->ri_bits & 3) {
226: printf("rasops_init: bits not aligned on 32-bit boundary\n");
227: return (-1);
228: }
229:
230: if ((int)ri->ri_stride & 3) {
231: printf("rasops_init: stride not aligned on 32-bit boundary\n");
232: return (-1);
233: }
234: #endif
235:
236: if (rasops_reconfig(ri, wantrows, wantcols))
237: return (-1);
238:
239: rasops_init_devcmap(ri);
240: return (0);
241: }
242:
243: /*
244: * Reconfigure (because parameters have changed in some way).
245: */
246: int
247: rasops_reconfig(ri, wantrows, wantcols)
248: struct rasops_info *ri;
249: int wantrows, wantcols;
250: {
251: int l, bpp, s;
252:
253: s = splhigh();
254:
255: if (ri->ri_font->fontwidth > 32 || ri->ri_font->fontwidth < 4)
256: panic("rasops_init: fontwidth assumptions botched!");
257:
258: /* Need this to frob the setup below */
259: bpp = (ri->ri_depth == 15 ? 16 : ri->ri_depth);
260:
261: if ((ri->ri_flg & RI_CFGDONE) != 0)
262: ri->ri_bits = ri->ri_origbits;
263:
264: /* Don't care if the caller wants a hideously small console */
265: if (wantrows < 10)
266: wantrows = 10;
267:
268: if (wantcols < 20)
269: wantcols = 20;
270:
271: /* Now constrain what they get */
272: ri->ri_emuwidth = ri->ri_font->fontwidth * wantcols;
273: ri->ri_emuheight = ri->ri_font->fontheight * wantrows;
274:
275: if (ri->ri_emuwidth > ri->ri_width)
276: ri->ri_emuwidth = ri->ri_width;
277:
278: if (ri->ri_emuheight > ri->ri_height)
279: ri->ri_emuheight = ri->ri_height;
280:
281: /* Reduce width until aligned on a 32-bit boundary */
282: while ((ri->ri_emuwidth * bpp & 31) != 0)
283: ri->ri_emuwidth--;
284:
285: #if NRASOPS_ROTATION > 0
286: if (ri->ri_flg & RI_ROTATE_CW) {
287: ri->ri_rows = ri->ri_emuwidth / ri->ri_font->fontwidth;
288: ri->ri_cols = ri->ri_emuheight / ri->ri_font->fontheight;
289: } else
290: #endif
291: {
292: ri->ri_cols = ri->ri_emuwidth / ri->ri_font->fontwidth;
293: ri->ri_rows = ri->ri_emuheight / ri->ri_font->fontheight;
294: }
295: ri->ri_emustride = ri->ri_emuwidth * bpp >> 3;
296: ri->ri_delta = ri->ri_stride - ri->ri_emustride;
297: ri->ri_ccol = 0;
298: ri->ri_crow = 0;
299: ri->ri_pelbytes = bpp >> 3;
300:
301: ri->ri_xscale = (ri->ri_font->fontwidth * bpp) >> 3;
302: ri->ri_yscale = ri->ri_font->fontheight * ri->ri_stride;
303: ri->ri_fontscale = ri->ri_font->fontheight * ri->ri_font->stride;
304:
305: #ifdef DEBUG
306: if ((ri->ri_delta & 3) != 0)
307: panic("rasops_init: ri_delta not aligned on 32-bit boundary");
308: #endif
309: /* Clear the entire display */
310: if ((ri->ri_flg & RI_CLEAR) != 0) {
311: memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height);
312: ri->ri_flg &= ~RI_CLEARMARGINS;
313: }
314:
315: /* Now centre our window if needs be */
316: ri->ri_origbits = ri->ri_bits;
317:
318: if ((ri->ri_flg & RI_CENTER) != 0) {
319: ri->ri_bits += (((ri->ri_width * bpp >> 3) -
320: ri->ri_emustride) >> 1) & ~3;
321: ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) *
322: ri->ri_stride;
323:
324: ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits)
325: / ri->ri_stride;
326: ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits)
327: % ri->ri_stride) * 8 / bpp);
328: } else
329: ri->ri_xorigin = ri->ri_yorigin = 0;
330:
331: /* Clear the margins */
332: if ((ri->ri_flg & RI_CLEARMARGINS) != 0) {
333: memset(ri->ri_origbits, 0, ri->ri_bits - ri->ri_origbits);
334: for (l = 0; l < ri->ri_emuheight; l++)
335: memset(ri->ri_bits + ri->ri_emustride +
336: l * ri->ri_stride, 0,
337: ri->ri_stride - ri->ri_emustride);
338: memset(ri->ri_bits + ri->ri_emuheight * ri->ri_stride, 0,
339: (ri->ri_origbits + ri->ri_height * ri->ri_stride) -
340: (ri->ri_bits + ri->ri_emuheight * ri->ri_stride));
341: }
342:
343: /*
344: * Fill in defaults for operations set. XXX this nukes private
345: * routines used by accelerated fb drivers.
346: */
347: ri->ri_ops.mapchar = rasops_mapchar;
348: ri->ri_ops.copyrows = rasops_copyrows;
349: ri->ri_ops.copycols = rasops_copycols;
350: ri->ri_ops.erasecols = rasops_erasecols;
351: ri->ri_ops.eraserows = rasops_eraserows;
352: ri->ri_ops.cursor = rasops_cursor;
353: ri->ri_ops.unpack_attr = rasops_unpack_attr;
354: ri->ri_do_cursor = rasops_do_cursor;
355: ri->ri_updatecursor = NULL;
356:
357: if (ri->ri_depth < 8 || (ri->ri_flg & RI_FORCEMONO) != 0) {
358: ri->ri_ops.alloc_attr = rasops_alloc_mattr;
359: ri->ri_caps = WSSCREEN_UNDERLINE | WSSCREEN_REVERSE;
360: } else {
361: ri->ri_ops.alloc_attr = rasops_alloc_cattr;
362: ri->ri_caps = WSSCREEN_UNDERLINE | WSSCREEN_HILIT |
363: WSSCREEN_WSCOLORS | WSSCREEN_REVERSE;
364: }
365:
366: switch (ri->ri_depth) {
367: #if NRASOPS1 > 0
368: case 1:
369: rasops1_init(ri);
370: break;
371: #endif
372: #if NRASOPS2 > 0
373: case 2:
374: rasops2_init(ri);
375: break;
376: #endif
377: #if NRASOPS4 > 0
378: case 4:
379: rasops4_init(ri);
380: break;
381: #endif
382: #if NRASOPS8 > 0
383: case 8:
384: rasops8_init(ri);
385: break;
386: #endif
387: #if NRASOPS15 > 0 || NRASOPS16 > 0
388: case 15:
389: case 16:
390: rasops15_init(ri);
391: break;
392: #endif
393: #if NRASOPS24 > 0
394: case 24:
395: rasops24_init(ri);
396: break;
397: #endif
398: #if NRASOPS32 > 0
399: case 32:
400: rasops32_init(ri);
401: break;
402: #endif
403: default:
404: ri->ri_flg &= ~RI_CFGDONE;
405: splx(s);
406: return (-1);
407: }
408:
409: #if NRASOPS_ROTATION > 0
410: if (ri->ri_flg & RI_ROTATE_CW) {
411: ri->ri_real_ops = ri->ri_ops;
412: ri->ri_ops.copycols = rasops_copycols_rotated;
413: ri->ri_ops.copyrows = rasops_copyrows_rotated;
414: ri->ri_ops.erasecols = rasops_erasecols_rotated;
415: ri->ri_ops.eraserows = rasops_eraserows_rotated;
416: ri->ri_ops.putchar = rasops_putchar_rotated;
417: }
418: #endif
419:
420: ri->ri_flg |= RI_CFGDONE;
421: splx(s);
422: return (0);
423: }
424:
425: /*
426: * Map a character.
427: */
428: int
429: rasops_mapchar(cookie, c, cp)
430: void *cookie;
431: int c;
432: u_int *cp;
433: {
434: struct rasops_info *ri;
435:
436: ri = (struct rasops_info *)cookie;
437:
438: #ifdef DIAGNOSTIC
439: if (ri->ri_font == NULL)
440: panic("rasops_mapchar: no font selected");
441: #endif
442: if (ri->ri_font->encoding != WSDISPLAY_FONTENC_ISO) {
443:
444: if ( (c = wsfont_map_unichar(ri->ri_font, c)) < 0) {
445:
446: *cp = ' ';
447: return (0);
448:
449: }
450: }
451:
452:
453: if (c < ri->ri_font->firstchar) {
454: *cp = ' ';
455: return (0);
456: }
457:
458: if (c - ri->ri_font->firstchar >= ri->ri_font->numchars) {
459: *cp = ' ';
460: return (0);
461: }
462:
463: *cp = c;
464: return (5);
465: }
466:
467: /*
468: * Allocate a color attribute.
469: */
470: int
471: rasops_alloc_cattr(cookie, fg, bg, flg, attr)
472: void *cookie;
473: int fg, bg, flg;
474: long *attr;
475: {
476: int swap;
477:
478: #ifdef RASOPS_CLIPPING
479: fg &= 7;
480: bg &= 7;
481: #endif
482: if ((flg & WSATTR_BLINK) != 0)
483: return (EINVAL);
484:
485: if ((flg & WSATTR_WSCOLORS) == 0) {
486: fg = WSCOL_WHITE;
487: bg = WSCOL_BLACK;
488: }
489:
490: if ((flg & WSATTR_REVERSE) != 0) {
491: swap = fg;
492: fg = bg;
493: bg = swap;
494: }
495:
496: if ((flg & WSATTR_HILIT) != 0)
497: fg += 8;
498:
499: flg = ((flg & WSATTR_UNDERLINE) ? 1 : 0);
500:
501: if (rasops_isgray[fg])
502: flg |= 2;
503:
504: if (rasops_isgray[bg])
505: flg |= 4;
506:
507: *attr = (bg << 16) | (fg << 24) | flg;
508: return (0);
509: }
510:
511: /*
512: * Allocate a mono attribute.
513: */
514: int
515: rasops_alloc_mattr(cookie, fg, bg, flg, attr)
516: void *cookie;
517: int fg, bg, flg;
518: long *attr;
519: {
520: int swap;
521:
522: if ((flg & (WSATTR_BLINK | WSATTR_HILIT | WSATTR_WSCOLORS)) != 0)
523: return (EINVAL);
524:
525: fg = 1;
526: bg = 0;
527:
528: if ((flg & WSATTR_REVERSE) != 0) {
529: swap = fg;
530: fg = bg;
531: bg = swap;
532: }
533:
534: *attr = (bg << 16) | (fg << 24) | ((flg & WSATTR_UNDERLINE) ? 7 : 6);
535: return (0);
536: }
537:
538: /*
539: * Copy rows.
540: */
541: void
542: rasops_copyrows(cookie, src, dst, num)
543: void *cookie;
544: int src, dst, num;
545: {
546: int32_t *sp, *dp, *srp, *drp;
547: struct rasops_info *ri;
548: int n8, n1, cnt, delta;
549:
550: ri = (struct rasops_info *)cookie;
551:
552: #ifdef RASOPS_CLIPPING
553: if (dst == src)
554: return;
555:
556: if (src < 0) {
557: num += src;
558: src = 0;
559: }
560:
561: if ((src + num) > ri->ri_rows)
562: num = ri->ri_rows - src;
563:
564: if (dst < 0) {
565: num += dst;
566: dst = 0;
567: }
568:
569: if ((dst + num) > ri->ri_rows)
570: num = ri->ri_rows - dst;
571:
572: if (num <= 0)
573: return;
574: #endif
575:
576: num *= ri->ri_font->fontheight;
577: n8 = ri->ri_emustride >> 5;
578: n1 = (ri->ri_emustride >> 2) & 7;
579:
580: if (dst < src) {
581: srp = (int32_t *)(ri->ri_bits + src * ri->ri_yscale);
582: drp = (int32_t *)(ri->ri_bits + dst * ri->ri_yscale);
583: delta = ri->ri_stride;
584: } else {
585: src = ri->ri_font->fontheight * src + num - 1;
586: dst = ri->ri_font->fontheight * dst + num - 1;
587: srp = (int32_t *)(ri->ri_bits + src * ri->ri_stride);
588: drp = (int32_t *)(ri->ri_bits + dst * ri->ri_stride);
589: delta = -ri->ri_stride;
590: }
591:
592: while (num--) {
593: dp = drp;
594: sp = srp;
595: DELTA(drp, delta, int32_t *);
596: DELTA(srp, delta, int32_t *);
597:
598: for (cnt = n8; cnt; cnt--) {
599: dp[0] = sp[0];
600: dp[1] = sp[1];
601: dp[2] = sp[2];
602: dp[3] = sp[3];
603: dp[4] = sp[4];
604: dp[5] = sp[5];
605: dp[6] = sp[6];
606: dp[7] = sp[7];
607: dp += 8;
608: sp += 8;
609: }
610:
611: for (cnt = n1; cnt; cnt--)
612: *dp++ = *sp++;
613: }
614: }
615:
616: /*
617: * Copy columns. This is slow, and hard to optimize due to alignment,
618: * and the fact that we have to copy both left->right and right->left.
619: * We simply cop-out here and use ovbcopy(), since it handles all of
620: * these cases anyway.
621: */
622: void
623: rasops_copycols(cookie, row, src, dst, num)
624: void *cookie;
625: int row, src, dst, num;
626: {
627: struct rasops_info *ri;
628: u_char *sp, *dp;
629: int height;
630:
631: ri = (struct rasops_info *)cookie;
632:
633: #ifdef RASOPS_CLIPPING
634: if (dst == src)
635: return;
636:
637: /* Catches < 0 case too */
638: if ((unsigned)row >= (unsigned)ri->ri_rows)
639: return;
640:
641: if (src < 0) {
642: num += src;
643: src = 0;
644: }
645:
646: if ((src + num) > ri->ri_cols)
647: num = ri->ri_cols - src;
648:
649: if (dst < 0) {
650: num += dst;
651: dst = 0;
652: }
653:
654: if ((dst + num) > ri->ri_cols)
655: num = ri->ri_cols - dst;
656:
657: if (num <= 0)
658: return;
659: #endif
660:
661: num *= ri->ri_xscale;
662: row *= ri->ri_yscale;
663: height = ri->ri_font->fontheight;
664:
665: sp = ri->ri_bits + row + src * ri->ri_xscale;
666: dp = ri->ri_bits + row + dst * ri->ri_xscale;
667:
668: #if NRASOPS_BSWAP > 0
669: if (ri->ri_flg & RI_BSWAP) {
670: while (height--) {
671: slow_ovbcopy(sp, dp, num);
672: dp += ri->ri_stride;
673: sp += ri->ri_stride;
674: }
675: } else
676: #endif
677: {
678: while (height--) {
679: ovbcopy(sp, dp, num);
680: dp += ri->ri_stride;
681: sp += ri->ri_stride;
682: }
683: }
684: }
685:
686: /*
687: * Turn cursor off/on.
688: */
689: void
690: rasops_cursor(cookie, on, row, col)
691: void *cookie;
692: int on, row, col;
693: {
694: struct rasops_info *ri;
695:
696: ri = (struct rasops_info *)cookie;
697:
698: /* Turn old cursor off */
699: if ((ri->ri_flg & RI_CURSOR) != 0)
700: #ifdef RASOPS_CLIPPING
701: if ((ri->ri_flg & RI_CURSORCLIP) == 0)
702: #endif
703: ri->ri_do_cursor(ri);
704:
705: /* Select new cursor */
706: #ifdef RASOPS_CLIPPING
707: ri->ri_flg &= ~RI_CURSORCLIP;
708:
709: if (row < 0 || row >= ri->ri_rows)
710: ri->ri_flg |= RI_CURSORCLIP;
711: else if (col < 0 || col >= ri->ri_cols)
712: ri->ri_flg |= RI_CURSORCLIP;
713: #endif
714: ri->ri_crow = row;
715: ri->ri_ccol = col;
716:
717: if (ri->ri_updatecursor != NULL)
718: ri->ri_updatecursor(ri);
719:
720: if (on) {
721: ri->ri_flg |= RI_CURSOR;
722: #ifdef RASOPS_CLIPPING
723: if ((ri->ri_flg & RI_CURSORCLIP) == 0)
724: #endif
725: ri->ri_do_cursor(ri);
726: } else
727: ri->ri_flg &= ~RI_CURSOR;
728: }
729:
730: /*
731: * Make the device colormap
732: */
733: void
734: rasops_init_devcmap(ri)
735: struct rasops_info *ri;
736: {
737: int i;
738: #if NRASOPS15 > 0 || NRASOPS16 > 0 || NRASOPS24 > 0 || NRASOPS32 > 0
739: const u_char *p;
740: #endif
741: #if NRASOPS4 > 0 || NRASOPS15 > 0 || NRASOPS16 > 0 || NRASOPS24 > 0 || NRASOPS32 > 0
742: int c;
743: #endif
744:
745: switch (ri->ri_depth) {
746: #if NRASOPS1 > 0
747: case 1:
748: ri->ri_devcmap[0] = 0;
749: for (i = 1; i < 16; i++)
750: ri->ri_devcmap[i] = 0xffffffff;
751: return;
752: #endif
753: #if NRASOPS2 > 0
754: case 2:
755: for (i = 1; i < 15; i++)
756: ri->ri_devcmap[i] = 0xaaaaaaaa;
757:
758: ri->ri_devcmap[0] = 0;
759: ri->ri_devcmap[8] = 0x55555555;
760: ri->ri_devcmap[15] = 0xffffffff;
761: return;
762: #endif
763: #if NRASOPS4 > 0
764: case 4:
765: for (i = 0; i < 16; i++) {
766: c = i | (i << 4);
767: ri->ri_devcmap[i] = c | (c<<8) | (c<<16) | (c<<24);
768: }
769: return;
770: #endif
771: #if NRASOPS8 > 0
772: case 8:
773: for (i = 0; i < 16; i++)
774: ri->ri_devcmap[i] = i | (i<<8) | (i<<16) | (i<<24);
775: return;
776: #endif
777: default:
778: break;
779: }
780:
781: #if NRASOPS15 > 0 || NRASOPS16 > 0 || NRASOPS24 > 0 || NRASOPS32 > 0
782: p = rasops_cmap;
783:
784: for (i = 0; i < 16; i++) {
785: if (ri->ri_rnum <= 8)
786: c = (*p >> (8 - ri->ri_rnum)) << ri->ri_rpos;
787: else
788: c = (*p << (ri->ri_rnum - 8)) << ri->ri_rpos;
789: p++;
790:
791: if (ri->ri_gnum <= 8)
792: c |= (*p >> (8 - ri->ri_gnum)) << ri->ri_gpos;
793: else
794: c |= (*p << (ri->ri_gnum - 8)) << ri->ri_gpos;
795: p++;
796:
797: if (ri->ri_bnum <= 8)
798: c |= (*p >> (8 - ri->ri_bnum)) << ri->ri_bpos;
799: else
800: c |= (*p << (ri->ri_bnum - 8)) << ri->ri_bpos;
801: p++;
802:
803: /* Fill the word for generic routines, which want this */
804: if (ri->ri_depth == 24)
805: c = c | ((c & 0xff) << 24);
806: else if (ri->ri_depth <= 16)
807: c = c | (c << 16);
808:
809: /* 24bpp does bswap on the fly. {32,16,15}bpp do it here. */
810: #if NRASOPS_BSWAP > 0
811: if ((ri->ri_flg & RI_BSWAP) == 0)
812: ri->ri_devcmap[i] = c;
813: else if (ri->ri_depth == 32)
814: ri->ri_devcmap[i] = swap32(c);
815: else if (ri->ri_depth == 16 || ri->ri_depth == 15)
816: ri->ri_devcmap[i] = swap16(c);
817: else
818: ri->ri_devcmap[i] = c;
819: #else
820: ri->ri_devcmap[i] = c;
821: #endif
822: }
823: #endif
824: }
825:
826: /*
827: * Unpack a rasops attribute
828: */
829: void
830: rasops_unpack_attr(cookie, attr, fg, bg, underline)
831: void *cookie;
832: long attr;
833: int *fg, *bg, *underline;
834: {
835: *fg = ((u_int)attr >> 24) & 0xf;
836: *bg = ((u_int)attr >> 16) & 0xf;
837: if (underline != NULL)
838: *underline = (u_int)attr & 1;
839: }
840:
841: /*
842: * Erase rows
843: */
844: void
845: rasops_eraserows(cookie, row, num, attr)
846: void *cookie;
847: int row, num;
848: long attr;
849: {
850: struct rasops_info *ri;
851: int np, nw, cnt, delta;
852: int32_t *dp, clr;
853:
854: ri = (struct rasops_info *)cookie;
855:
856: #ifdef RASOPS_CLIPPING
857: if (row < 0) {
858: num += row;
859: row = 0;
860: }
861:
862: if ((row + num) > ri->ri_rows)
863: num = ri->ri_rows - row;
864:
865: if (num <= 0)
866: return;
867: #endif
868:
869: clr = ri->ri_devcmap[(attr >> 16) & 0xf];
870:
871: /*
872: * XXX The wsdisplay_emulops interface seems a little deficient in
873: * that there is no way to clear the *entire* screen. We provide a
874: * workaround here: if the entire console area is being cleared, and
875: * the RI_FULLCLEAR flag is set, clear the entire display.
876: */
877: if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) {
878: np = ri->ri_stride >> 5;
879: nw = (ri->ri_stride >> 2) & 7;
880: num = ri->ri_height;
881: dp = (int32_t *)ri->ri_origbits;
882: delta = 0;
883: } else {
884: np = ri->ri_emustride >> 5;
885: nw = (ri->ri_emustride >> 2) & 7;
886: num *= ri->ri_font->fontheight;
887: dp = (int32_t *)(ri->ri_bits + row * ri->ri_yscale);
888: delta = ri->ri_delta;
889: }
890:
891: while (num--) {
892: for (cnt = np; cnt; cnt--) {
893: dp[0] = clr;
894: dp[1] = clr;
895: dp[2] = clr;
896: dp[3] = clr;
897: dp[4] = clr;
898: dp[5] = clr;
899: dp[6] = clr;
900: dp[7] = clr;
901: dp += 8;
902: }
903:
904: for (cnt = nw; cnt; cnt--) {
905: *(int32_t *)dp = clr;
906: DELTA(dp, 4, int32_t *);
907: }
908:
909: DELTA(dp, delta, int32_t *);
910: }
911: }
912:
913: /*
914: * Actually turn the cursor on or off. This does the dirty work for
915: * rasops_cursor().
916: */
917: void
918: rasops_do_cursor(ri)
919: struct rasops_info *ri;
920: {
921: int full1, height, cnt, slop1, slop2, row, col;
922: u_char *dp, *rp;
923:
924: #if NRASOPS_ROTATION > 0
925: if (ri->ri_flg & RI_ROTATE_CW) {
926: /* Rotate rows/columns */
927: row = ri->ri_ccol;
928: col = ri->ri_rows - ri->ri_crow - 1;
929: } else
930: #endif
931: {
932: row = ri->ri_crow;
933: col = ri->ri_ccol;
934: }
935:
936: rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
937: height = ri->ri_font->fontheight;
938: slop1 = (4 - ((long)rp & 3)) & 3;
939:
940: if (slop1 > ri->ri_xscale)
941: slop1 = ri->ri_xscale;
942:
943: slop2 = (ri->ri_xscale - slop1) & 3;
944: full1 = (ri->ri_xscale - slop1 - slop2) >> 2;
945:
946: if ((slop1 | slop2) == 0) {
947: /* A common case */
948: while (height--) {
949: dp = rp;
950: rp += ri->ri_stride;
951:
952: for (cnt = full1; cnt; cnt--) {
953: *(int32_t *)dp ^= ~0;
954: dp += 4;
955: }
956: }
957: } else {
958: /* XXX this is stupid.. use masks instead */
959: while (height--) {
960: dp = rp;
961: rp += ri->ri_stride;
962:
963: if (slop1 & 1)
964: *dp++ ^= ~0;
965:
966: if (slop1 & 2) {
967: *(int16_t *)dp ^= ~0;
968: dp += 2;
969: }
970:
971: for (cnt = full1; cnt; cnt--) {
972: *(int32_t *)dp ^= ~0;
973: dp += 4;
974: }
975:
976: if (slop2 & 1)
977: *dp++ ^= ~0;
978:
979: if (slop2 & 2)
980: *(int16_t *)dp ^= ~0;
981: }
982: }
983: }
984:
985: /*
986: * Erase columns.
987: */
988: void
989: rasops_erasecols(cookie, row, col, num, attr)
990: void *cookie;
991: int row, col, num;
992: long attr;
993: {
994: int n8, height, cnt, slop1, slop2, clr;
995: struct rasops_info *ri;
996: int32_t *rp, *dp;
997:
998: ri = (struct rasops_info *)cookie;
999:
1000: #ifdef RASOPS_CLIPPING
1001: if ((unsigned)row >= (unsigned)ri->ri_rows)
1002: return;
1003:
1004: if (col < 0) {
1005: num += col;
1006: col = 0;
1007: }
1008:
1009: if ((col + num) > ri->ri_cols)
1010: num = ri->ri_cols - col;
1011:
1012: if (num <= 0)
1013: return;
1014: #endif
1015:
1016: num = num * ri->ri_xscale;
1017: rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
1018: height = ri->ri_font->fontheight;
1019: clr = ri->ri_devcmap[(attr >> 16) & 0xf];
1020:
1021: /* Don't bother using the full loop for <= 32 pels */
1022: if (num <= 32) {
1023: if (((num | ri->ri_xscale) & 3) == 0) {
1024: /* Word aligned blt */
1025: num >>= 2;
1026:
1027: while (height--) {
1028: dp = rp;
1029: DELTA(rp, ri->ri_stride, int32_t *);
1030:
1031: for (cnt = num; cnt; cnt--)
1032: *dp++ = clr;
1033: }
1034: } else if (((num | ri->ri_xscale) & 1) == 0) {
1035: /*
1036: * Halfword aligned blt. This is needed so the
1037: * 15/16 bit ops can use this function.
1038: */
1039: num >>= 1;
1040:
1041: while (height--) {
1042: dp = rp;
1043: DELTA(rp, ri->ri_stride, int32_t *);
1044:
1045: for (cnt = num; cnt; cnt--) {
1046: *(int16_t *)dp = clr;
1047: DELTA(dp, 2, int32_t *);
1048: }
1049: }
1050: } else {
1051: while (height--) {
1052: dp = rp;
1053: DELTA(rp, ri->ri_stride, int32_t *);
1054:
1055: for (cnt = num; cnt; cnt--) {
1056: *(u_char *)dp = clr;
1057: DELTA(dp, 1, int32_t *);
1058: }
1059: }
1060: }
1061:
1062: return;
1063: }
1064:
1065: slop1 = (4 - ((long)rp & 3)) & 3;
1066: slop2 = (num - slop1) & 3;
1067: num -= slop1 + slop2;
1068: n8 = num >> 5;
1069: num = (num >> 2) & 7;
1070:
1071: while (height--) {
1072: dp = rp;
1073: DELTA(rp, ri->ri_stride, int32_t *);
1074:
1075: /* Align span to 4 bytes */
1076: if (slop1 & 1) {
1077: *(u_char *)dp = clr;
1078: DELTA(dp, 1, int32_t *);
1079: }
1080:
1081: if (slop1 & 2) {
1082: *(int16_t *)dp = clr;
1083: DELTA(dp, 2, int32_t *);
1084: }
1085:
1086: /* Write 32 bytes per loop */
1087: for (cnt = n8; cnt; cnt--) {
1088: dp[0] = clr;
1089: dp[1] = clr;
1090: dp[2] = clr;
1091: dp[3] = clr;
1092: dp[4] = clr;
1093: dp[5] = clr;
1094: dp[6] = clr;
1095: dp[7] = clr;
1096: dp += 8;
1097: }
1098:
1099: /* Write 4 bytes per loop */
1100: for (cnt = num; cnt; cnt--)
1101: *dp++ = clr;
1102:
1103: /* Write unaligned trailing slop */
1104: if (slop2 & 1) {
1105: *(u_char *)dp = clr;
1106: DELTA(dp, 1, int32_t *);
1107: }
1108:
1109: if (slop2 & 2)
1110: *(int16_t *)dp = clr;
1111: }
1112: }
1113:
1114: #if NRASOPS_ROTATION > 0
1115: /*
1116: * Quarter clockwise rotation routines (originally intended for the
1117: * built-in Zaurus C3x00 display in 16bpp).
1118: */
1119:
1120: #include <sys/malloc.h>
1121:
1122: void
1123: rasops_rotate_font(int *cookie)
1124: {
1125: struct rotatedfont *f;
1126: int ncookie;
1127:
1128: SLIST_FOREACH(f, &rotatedfonts, rf_next) {
1129: if (f->rf_cookie == *cookie) {
1130: *cookie = f->rf_rotated;
1131: return;
1132: }
1133: }
1134:
1135: /*
1136: * We did not find a rotated version of this font. Ask the wsfont
1137: * code to compute one for us.
1138: */
1139:
1140: f = malloc(sizeof(struct rotatedfont), M_DEVBUF, M_WAITOK);
1141: if (f == NULL)
1142: return;
1143:
1144: if ((ncookie = wsfont_rotate(*cookie)) == -1)
1145: return;
1146:
1147: f->rf_cookie = *cookie;
1148: f->rf_rotated = ncookie;
1149: SLIST_INSERT_HEAD(&rotatedfonts, f, rf_next);
1150:
1151: *cookie = ncookie;
1152: }
1153:
1154: void
1155: rasops_copychar(cookie, srcrow, dstrow, srccol, dstcol)
1156: void *cookie;
1157: int srcrow, dstrow, srccol, dstcol;
1158: {
1159: struct rasops_info *ri;
1160: u_char *sp, *dp;
1161: int height;
1162: int r_srcrow, r_dstrow, r_srccol, r_dstcol;
1163:
1164: ri = (struct rasops_info *)cookie;
1165:
1166: r_srcrow = srccol;
1167: r_dstrow = dstcol;
1168: r_srccol = ri->ri_rows - srcrow - 1;
1169: r_dstcol = ri->ri_rows - dstrow - 1;
1170:
1171: r_srcrow *= ri->ri_yscale;
1172: r_dstrow *= ri->ri_yscale;
1173: height = ri->ri_font->fontheight;
1174:
1175: sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale;
1176: dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale;
1177:
1178: #if NRASOPS_BSWAP > 0
1179: if (ri->ri_flg & RI_BSWAP) {
1180: while (height--) {
1181: slow_ovbcopy(sp, dp, ri->ri_xscale);
1182: dp += ri->ri_stride;
1183: sp += ri->ri_stride;
1184: }
1185: } else
1186: #endif
1187: {
1188: while (height--) {
1189: ovbcopy(sp, dp, ri->ri_xscale);
1190: dp += ri->ri_stride;
1191: sp += ri->ri_stride;
1192: }
1193: }
1194: }
1195:
1196: void
1197: rasops_putchar_rotated(cookie, row, col, uc, attr)
1198: void *cookie;
1199: int row, col;
1200: u_int uc;
1201: long attr;
1202: {
1203: struct rasops_info *ri;
1204: u_char *rp;
1205: int height;
1206:
1207: ri = (struct rasops_info *)cookie;
1208:
1209: /* Do rotated char sans (side)underline */
1210: ri->ri_real_ops.putchar(cookie, col, ri->ri_rows - row - 1, uc,
1211: attr & ~1);
1212:
1213: /* Do rotated underline */
1214: rp = ri->ri_bits + col * ri->ri_yscale + (ri->ri_rows - row - 1) *
1215: ri->ri_xscale;
1216: height = ri->ri_font->fontheight;
1217:
1218: /* XXX this assumes 16-bit color depth */
1219: if ((attr & 1) != 0) {
1220: int16_t c = (int16_t)ri->ri_devcmap[((u_int)attr >> 24) & 0xf];
1221:
1222: while (height--) {
1223: *(int16_t *)rp = c;
1224: rp += ri->ri_stride;
1225: }
1226: }
1227: }
1228:
1229: void
1230: rasops_erasecols_rotated(cookie, row, col, num, attr)
1231: void *cookie;
1232: int row, col, num;
1233: long attr;
1234: {
1235: struct rasops_info *ri;
1236: int i;
1237:
1238: ri = (struct rasops_info *)cookie;
1239:
1240: for (i = col; i < col + num; i++)
1241: ri->ri_ops.putchar(cookie, row, i, ' ', attr);
1242: }
1243:
1244: /* XXX: these could likely be optimised somewhat. */
1245: void
1246: rasops_copyrows_rotated(cookie, src, dst, num)
1247: void *cookie;
1248: int src, dst, num;
1249: {
1250: struct rasops_info *ri = (struct rasops_info *)cookie;
1251: int col, roff;
1252:
1253: if (src > dst)
1254: for (roff = 0; roff < num; roff++)
1255: for (col = 0; col < ri->ri_cols; col++)
1256: rasops_copychar(cookie, src + roff, dst + roff,
1257: col, col);
1258: else
1259: for (roff = num - 1; roff >= 0; roff--)
1260: for (col = 0; col < ri->ri_cols; col++)
1261: rasops_copychar(cookie, src + roff, dst + roff,
1262: col, col);
1263: }
1264:
1265: void
1266: rasops_copycols_rotated(cookie, row, src, dst, num)
1267: void *cookie;
1268: int row, src, dst, num;
1269: {
1270: int coff;
1271:
1272: if (src > dst)
1273: for (coff = 0; coff < num; coff++)
1274: rasops_copychar(cookie, row, row, src + coff, dst + coff);
1275: else
1276: for (coff = num - 1; coff >= 0; coff--)
1277: rasops_copychar(cookie, row, row, src + coff, dst + coff);
1278: }
1279:
1280: void
1281: rasops_eraserows_rotated(cookie, row, num, attr)
1282: void *cookie;
1283: int row, num;
1284: long attr;
1285: {
1286: struct rasops_info *ri;
1287: int col, rn;
1288:
1289: ri = (struct rasops_info *)cookie;
1290:
1291: for (rn = row; rn < row + num; rn++)
1292: for (col = 0; col < ri->ri_cols; col++)
1293: ri->ri_ops.putchar(cookie, rn, col, ' ', attr);
1294: }
1295: #endif /* NRASOPS_ROTATION */
1296:
1297: #if NRASOPS_BSWAP > 0
1298: /*
1299: * Strictly byte-only ovbcopy() version, to be used with RI_BSWAP, as the
1300: * regular ovbcopy() may want to optimize things by doing larger-than-byte
1301: * reads or write. This may confuse things if src and dst have different
1302: * alignments.
1303: */
1304: void
1305: slow_ovbcopy(void *s, void *d, size_t len)
1306: {
1307: u_int8_t *src = s;
1308: u_int8_t *dst = d;
1309:
1310: if ((vaddr_t)dst <= (vaddr_t)src) {
1311: while (len-- != 0)
1312: *dst++ = *src++;
1313: } else {
1314: src += len;
1315: dst += len;
1316: if (len != 0)
1317: while (--len != 0)
1318: *--dst = *--src;
1319: }
1320: }
1321: #endif /* NRASOPS_BSWAP */