1 /* $NetBSD: rasops.c,v 1.128 2022/05/15 16:43:39 uwe Exp $ */
2
3 /*-
4 * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Andrew Doran.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: rasops.c,v 1.128 2022/05/15 16:43:39 uwe Exp $");
34
35 #ifdef _KERNEL_OPT
36 #include "opt_rasops.h"
37 #include "opt_wsmsgattrs.h"
38 #include "rasops_glue.h"
39 #endif
40
41 #include <sys/param.h>
42 #include <sys/bswap.h>
43 #include <sys/kmem.h>
44
45 #include <machine/endian.h>
46
47 #include <dev/wscons/wsdisplayvar.h>
48 #include <dev/wscons/wsconsio.h>
49 #include <dev/wsfont/wsfont.h>
50
51 #define _RASOPS_PRIVATE
52 #include <dev/rasops/rasops.h>
53 #include <dev/rasops/rasops_masks.h> /* XXX for MBE */
54
55 #ifndef _KERNEL
56 #include <errno.h>
57 #endif
58
59 #ifdef RASOPS_DEBUG
60 #define DPRINTF(...) aprint_error(...)
61 #else
62 #define DPRINTF(...) __nothing
63 #endif
64
65 struct rasops_matchdata {
66 struct rasops_info *ri;
67 int wantcols, wantrows;
68 int bestscore;
69 struct wsdisplay_font *pick;
70 int ident;
71 };
72
73 static const uint32_t rasops_lmask32[4 + 1] = {
74 MBE(0x00000000), MBE(0x00ffffff), MBE(0x0000ffff), MBE(0x000000ff),
75 MBE(0x00000000),
76 };
77
78 static const uint32_t rasops_rmask32[4 + 1] = {
79 MBE(0x00000000), MBE(0xff000000), MBE(0xffff0000), MBE(0xffffff00),
80 MBE(0xffffffff),
81 };
82
83 /* ANSI colormap (R,G,B). Upper 8 are high-intensity */
84 const uint8_t rasops_cmap[256 * 3] = {
85 0x00, 0x00, 0x00, /* black */
86 0x7f, 0x00, 0x00, /* red */
87 0x00, 0x7f, 0x00, /* green */
88 0x7f, 0x7f, 0x00, /* brown */
89 0x00, 0x00, 0x7f, /* blue */
90 0x7f, 0x00, 0x7f, /* magenta */
91 0x00, 0x7f, 0x7f, /* cyan */
92 0xc7, 0xc7, 0xc7, /* white - XXX too dim? */
93
94 0x7f, 0x7f, 0x7f, /* black */
95 0xff, 0x00, 0x00, /* red */
96 0x00, 0xff, 0x00, /* green */
97 0xff, 0xff, 0x00, /* brown */
98 0x00, 0x00, 0xff, /* blue */
99 0xff, 0x00, 0xff, /* magenta */
100 0x00, 0xff, 0xff, /* cyan */
101 0xff, 0xff, 0xff, /* white */
102
103 /*
104 * For the cursor, we need at least the last (255th)
105 * color to be white. Fill up white completely for
106 * simplicity.
107 */
108 #define _CMWHITE 0xff, 0xff, 0xff,
109 #define _CMWHITE16 _CMWHITE _CMWHITE _CMWHITE _CMWHITE \
110 _CMWHITE _CMWHITE _CMWHITE _CMWHITE \
111 _CMWHITE _CMWHITE _CMWHITE _CMWHITE \
112 _CMWHITE _CMWHITE _CMWHITE _CMWHITE
113 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
114 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16
115 _CMWHITE16 _CMWHITE16 _CMWHITE16 _CMWHITE16 /* but not the last one */
116 #undef _CMWHITE16
117 #undef _CMWHITE
118
119 /*
120 * For the cursor the fg/bg indices are bit inverted, so
121 * provide complimentary colors in the upper 16 entries.
122 */
123 0x7f, 0x7f, 0x7f, /* black */
124 0xff, 0x00, 0x00, /* red */
125 0x00, 0xff, 0x00, /* green */
126 0xff, 0xff, 0x00, /* brown */
127 0x00, 0x00, 0xff, /* blue */
128 0xff, 0x00, 0xff, /* magenta */
129 0x00, 0xff, 0xff, /* cyan */
130 0xff, 0xff, 0xff, /* white */
131
132 0x00, 0x00, 0x00, /* black */
133 0x7f, 0x00, 0x00, /* red */
134 0x00, 0x7f, 0x00, /* green */
135 0x7f, 0x7f, 0x00, /* brown */
136 0x00, 0x00, 0x7f, /* blue */
137 0x7f, 0x00, 0x7f, /* magenta */
138 0x00, 0x7f, 0x7f, /* cyan */
139 0xc7, 0xc7, 0xc7, /* white - XXX too dim? */
140 };
141
142 /* True if color is gray */
143 static const uint8_t rasops_isgray[16] = {
144 1, 0, 0, 0, 0, 0, 0, 1,
145 1, 0, 0, 0, 0, 0, 0, 1,
146 };
147
148 #ifdef RASOPS_APPLE_PALETTE
149 /*
150 * Approximate ANSI colormap for legacy Apple color palettes
151 */
152 static const uint8_t apple8_devcmap[16] = {
153 0xff, /* black 0x00, 0x00, 0x00 */
154 0x6b, /* red 0x99, 0x00, 0x00 */
155 0xc5, /* green 0x00, 0x99, 0x00 */
156 0x59, /* yellow 0x99, 0x99, 0x00 */
157 0xd4, /* blue 0x00, 0x00, 0x99 */
158 0x68, /* magenta 0x99, 0x00, 0x99 */
159 0xc2, /* cyan 0x00, 0x99, 0x99 */
160 0x2b, /* white 0xcc, 0xcc, 0xcc */
161
162 0x56, /* black 0x99, 0x99, 0x99 */
163 0x23, /* red 0xff, 0x00, 0x00 */
164 0xb9, /* green 0x00, 0xff, 0x00 */
165 0x05, /* yellow 0xff, 0xff, 0x00 */
166 0xd2, /* blue 0x00, 0x00, 0xff */
167 0x1e, /* magenta 0xff, 0x00, 0xff */
168 0xb4, /* cyan 0x00, 0xff, 0xff */
169 0x00, /* white 0xff, 0xff, 0xff */
170 };
171
172 static const uint8_t apple4_devcmap[16] = {
173 15, /* black */
174 3, /* red */
175 9, /* dark green */
176 1, /* yellow */
177 6, /* blue */
178 4, /* magenta */
179 7, /* cyan */
180 12, /* light grey */
181
182 13, /* medium grey */
183 3, /* red */
184 9, /* dark green */
185 1, /* yellow */
186 6, /* blue */
187 4, /* magenta */
188 7, /* cyan */
189 0, /* white */
190 };
191 #endif
192
193 /* Generic functions */
194 static void rasops_copyrows(void *, int, int, int);
195 static void rasops_copycols(void *, int, int, int, int);
196 static int rasops_mapchar(void *, int, u_int *);
197 static void rasops_cursor(void *, int, int, int);
198 static int rasops_allocattr_color(void *, int, int, int, long *);
199 static int rasops_allocattr_mono(void *, int, int, int, long *);
200 static void rasops_do_cursor(struct rasops_info *);
201 static void rasops_init_devcmap(struct rasops_info *);
202 static void rasops_make_box_chars_8(struct rasops_info *);
203 static void rasops_make_box_chars_16(struct rasops_info *);
204 static void rasops_make_box_chars_32(struct rasops_info *);
205 static void rasops_make_box_chars_alpha(struct rasops_info *);
206
207 #if NRASOPS_ROTATION > 0
208 static void rasops_rotate_font(int *, int);
209 static void rasops_copychar(void *, int, int, int, int);
210
211 /* rotate clockwise */
212 static void rasops_copycols_rotated_cw(void *, int, int, int, int);
213 static void rasops_copyrows_rotated_cw(void *, int, int, int);
214 static void rasops_erasecols_rotated_cw(void *, int, int, int, long);
215 static void rasops_eraserows_rotated_cw(void *, int, int, long);
216 static void rasops_putchar_rotated_cw(void *, int, int, u_int, long);
217
218 /* rotate counter-clockwise */
219 static void rasops_copychar_ccw(void *, int, int, int, int);
220 static void rasops_copycols_rotated_ccw(void *, int, int, int, int);
221 static void rasops_copyrows_rotated_ccw(void *, int, int, int);
222 #define rasops_erasecols_rotated_ccw rasops_erasecols_rotated_cw
223 #define rasops_eraserows_rotated_ccw rasops_eraserows_rotated_cw
224 static void rasops_putchar_rotated_ccw(void *, int, int, u_int, long);
225
226 /*
227 * List of all rotated fonts
228 */
229 SLIST_HEAD(, rotatedfont) rotatedfonts = SLIST_HEAD_INITIALIZER(rotatedfonts);
230 struct rotatedfont {
231 SLIST_ENTRY(rotatedfont) rf_next;
232 int rf_cookie;
233 int rf_rotated;
234 };
235 #endif /* NRASOPS_ROTATION > 0 */
236
237 /*
238 * Initialize a 'rasops_info' descriptor.
239 */
240 int
rasops_init(struct rasops_info * ri,int wantrows,int wantcols)241 rasops_init(struct rasops_info *ri, int wantrows, int wantcols)
242 {
243
244 memset(&ri->ri_optfont, 0, sizeof(ri->ri_optfont));
245 #ifdef _KERNEL
246 /* Select a font if the caller doesn't care */
247 if (ri->ri_font == NULL) {
248 int cookie = -1;
249 int flags;
250
251 wsfont_init();
252
253 /*
254 * first, try to find something that's as close as possible
255 * to the caller's requested terminal size
256 */
257 if (wantrows == 0)
258 wantrows = RASOPS_DEFAULT_HEIGHT;
259 if (wantcols == 0)
260 wantcols = RASOPS_DEFAULT_WIDTH;
261
262 flags = WSFONT_FIND_BESTWIDTH | WSFONT_FIND_BITMAP;
263 if ((ri->ri_flg & RI_ENABLE_ALPHA) != 0)
264 flags |= WSFONT_FIND_ALPHA;
265 if ((ri->ri_flg & RI_PREFER_ALPHA) != 0)
266 flags |= WSFONT_PREFER_ALPHA;
267 if ((ri->ri_flg & RI_PREFER_WIDEFONT) != 0)
268 flags |= WSFONT_PREFER_WIDE;
269 cookie = wsfont_find(NULL,
270 ri->ri_width / wantcols,
271 0,
272 0,
273 WSDISPLAY_FONTORDER_L2R,
274 WSDISPLAY_FONTORDER_L2R,
275 flags);
276
277 /*
278 * this means there is no supported font in the list
279 */
280 if (cookie <= 0) {
281 aprint_error("%s: font table is empty\n", __func__);
282 return -1;
283 }
284
285 #if NRASOPS_ROTATION > 0
286 /*
287 * Pick the rotated version of this font. This will create it
288 * if necessary.
289 */
290 if (ri->ri_flg & RI_ROTATE_MASK) {
291 if (ri->ri_flg & RI_ROTATE_CW)
292 rasops_rotate_font(&cookie, WSFONT_ROTATE_CW);
293 else if (ri->ri_flg & RI_ROTATE_CCW)
294 rasops_rotate_font(&cookie, WSFONT_ROTATE_CCW);
295 }
296 #endif
297
298 if (wsfont_lock(cookie, &ri->ri_font)) {
299 aprint_error("%s: couldn't lock font\n", __func__);
300 return -1;
301 }
302
303 ri->ri_wsfcookie = cookie;
304 }
305 #endif
306
307 /* This should never happen in reality... */
308 if ((uintptr_t)ri->ri_bits & 3) {
309 aprint_error("%s: bits not aligned on 32-bit boundary\n",
310 __func__);
311 return -1;
312 }
313
314 if (ri->ri_stride & 3) {
315 aprint_error("%s: stride not aligned on 32-bit boundary\n",
316 __func__);
317 return -1;
318 }
319
320 if (rasops_reconfig(ri, wantrows, wantcols))
321 return -1;
322
323 rasops_init_devcmap(ri);
324 return 0;
325 }
326
327 /*
328 * Reconfigure (because parameters have changed in some way).
329 */
330 int
rasops_reconfig(struct rasops_info * ri,int wantrows,int wantcols)331 rasops_reconfig(struct rasops_info *ri, int wantrows, int wantcols)
332 {
333 int bpp, height, s;
334 size_t len;
335
336 s = splhigh();
337
338 if (wantrows == 0)
339 wantrows = RASOPS_DEFAULT_HEIGHT;
340 if (wantcols == 0)
341 wantcols = RASOPS_DEFAULT_WIDTH;
342
343 /* throw away old line drawing character bitmaps, if we have any */
344 if (ri->ri_optfont.data != NULL) {
345 kmem_free(ri->ri_optfont.data, ri->ri_optfont.stride *
346 ri->ri_optfont.fontheight * ri->ri_optfont.numchars);
347 ri->ri_optfont.data = NULL;
348 }
349
350 /* autogenerate box drawing characters */
351 ri->ri_optfont.firstchar = WSFONT_FLAG_OPT;
352 ri->ri_optfont.numchars = 16;
353 ri->ri_optfont.fontwidth = ri->ri_font->fontwidth;
354 ri->ri_optfont.fontheight = ri->ri_font->fontheight;
355 ri->ri_optfont.stride = ri->ri_font->stride;
356 len = ri->ri_optfont.fontheight * ri->ri_optfont.stride *
357 ri->ri_optfont.numchars;
358
359 if (ri->ri_font->fontwidth > 32 || ri->ri_font->fontwidth < 4) {
360 aprint_error("%s: fontwidth assumptions botched", __func__);
361 splx(s);
362 return -1;
363 }
364
365 if ((ri->ri_flg & RI_NO_AUTO) == 0) {
366 ri->ri_optfont.data = kmem_zalloc(len, KM_SLEEP);
367 if (FONT_IS_ALPHA(&ri->ri_optfont))
368 rasops_make_box_chars_alpha(ri);
369 else {
370 switch (ri->ri_optfont.stride) {
371 case 1:
372 rasops_make_box_chars_8(ri);
373 break;
374 case 2:
375 rasops_make_box_chars_16(ri);
376 break;
377 case 4:
378 rasops_make_box_chars_32(ri);
379 break;
380 default:
381 kmem_free(ri->ri_optfont.data, len);
382 ri->ri_optfont.data = NULL;
383 aprint_verbose(
384 "%s: font stride assumptions botched",
385 __func__);
386 break;
387 }
388 }
389 } else
390 memset(&ri->ri_optfont, 0, sizeof(ri->ri_optfont));
391
392 /* Need this to frob the setup below */
393 bpp = (ri->ri_depth == 15 ? 16 : ri->ri_depth);
394
395 if ((ri->ri_flg & RI_CFGDONE) != 0) {
396 ri->ri_bits = ri->ri_origbits;
397 ri->ri_hwbits = ri->ri_hworigbits;
398 }
399
400 /* Don't care if the caller wants a hideously small console */
401 if (wantrows < 10)
402 wantrows = 10;
403
404 if (wantcols < 20)
405 wantcols = 20;
406
407 /* Now constrain what they get */
408 ri->ri_emuwidth = ri->ri_font->fontwidth * wantcols;
409 ri->ri_emuheight = ri->ri_font->fontheight * wantrows;
410
411 if (ri->ri_emuwidth > ri->ri_width)
412 ri->ri_emuwidth = ri->ri_width;
413
414 if (ri->ri_emuheight > ri->ri_height)
415 ri->ri_emuheight = ri->ri_height;
416
417 /* Reduce width until aligned on a 32-bit boundary */
418 while ((ri->ri_emuwidth * bpp & 31) != 0)
419 ri->ri_emuwidth--;
420
421 #if NRASOPS_ROTATION > 0
422 if (ri->ri_flg & (RI_ROTATE_CW|RI_ROTATE_CCW)) {
423 ri->ri_rows = ri->ri_emuwidth / ri->ri_font->fontwidth;
424 ri->ri_cols = ri->ri_emuheight / ri->ri_font->fontheight;
425 } else
426 #endif
427 {
428 ri->ri_cols = ri->ri_emuwidth / ri->ri_font->fontwidth;
429 ri->ri_rows = ri->ri_emuheight / ri->ri_font->fontheight;
430 }
431 ri->ri_emustride = ri->ri_emuwidth * bpp >> 3;
432 ri->ri_ccol = 0;
433 ri->ri_crow = 0;
434 ri->ri_pelbytes = bpp >> 3;
435
436 ri->ri_xscale = (ri->ri_font->fontwidth * bpp) >> 3;
437 ri->ri_yscale = ri->ri_font->fontheight * ri->ri_stride;
438 ri->ri_fontscale = ri->ri_font->fontheight * ri->ri_font->stride;
439
440 ri->ri_origbits = ri->ri_bits;
441 ri->ri_hworigbits = ri->ri_hwbits;
442
443 /* Clear the entire display */
444 if ((ri->ri_flg & RI_CLEAR) != 0) {
445 rasops_memset32(ri->ri_bits, 0, ri->ri_stride * ri->ri_height);
446 if (ri->ri_hwbits)
447 rasops_memset32(ri->ri_hwbits, 0,
448 ri->ri_stride * ri->ri_height);
449 }
450
451 /* Now centre our window if needs be */
452 if ((ri->ri_flg & RI_CENTER) != 0) {
453 uint32_t xoff, yoff;
454
455 xoff = ((ri->ri_width * bpp >> 3) - ri->ri_emustride) >> 1;
456 if (ri->ri_depth != 24) {
457 /*
458 * Truncate to word boundary.
459 */
460 xoff &= ~3;
461 } else {
462 /*
463 * Truncate to both word and 24-bit color boundary.
464 */
465 xoff -= xoff % 12;
466 }
467
468 yoff = ((ri->ri_height - ri->ri_emuheight) >> 1) *
469 ri->ri_stride;
470
471 ri->ri_bits += xoff;
472 ri->ri_bits += yoff;
473 if (ri->ri_hwbits != NULL) {
474 ri->ri_hwbits += xoff;
475 ri->ri_hwbits += yoff;
476 }
477
478 ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits) /
479 ri->ri_stride;
480 ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits) %
481 ri->ri_stride) * 8 / bpp);
482 } else
483 ri->ri_xorigin = ri->ri_yorigin = 0;
484
485 /* Scaling underline by font height */
486 height = ri->ri_font->fontheight;
487 ri->ri_ul.off = rounddown(height, 16) / 16; /* offset from bottom */
488 ri->ri_ul.height = roundup(height, 16) / 16; /* height */
489
490 /*
491 * Fill in defaults for operations set. XXX this nukes private
492 * routines used by accelerated fb drivers.
493 */
494 ri->ri_ops.mapchar = rasops_mapchar;
495 ri->ri_ops.copyrows = rasops_copyrows;
496 ri->ri_ops.copycols = rasops_copycols;
497 ri->ri_ops.erasecols = rasops_erasecols;
498 ri->ri_ops.eraserows = rasops_eraserows;
499 ri->ri_ops.cursor = rasops_cursor;
500 ri->ri_do_cursor = rasops_do_cursor;
501
502 ri->ri_caps &= ~(WSSCREEN_UNDERLINE | WSSCREEN_HILIT |
503 WSSCREEN_WSCOLORS | WSSCREEN_REVERSE);
504
505 if ((ri->ri_flg & RI_FORCEMONO) != 0 ||
506 #ifndef RASOPS_APPLE_PALETTE
507 ri->ri_depth < 8
508 #else
509 ri->ri_depth < 4
510 #endif
511 ) {
512 ri->ri_ops.allocattr = rasops_allocattr_mono;
513 ri->ri_caps |= WSSCREEN_UNDERLINE | WSSCREEN_REVERSE;
514 } else {
515 ri->ri_ops.allocattr = rasops_allocattr_color;
516 ri->ri_caps |= WSSCREEN_UNDERLINE | WSSCREEN_HILIT |
517 WSSCREEN_WSCOLORS | WSSCREEN_REVERSE;
518 }
519
520 switch (ri->ri_depth) {
521 #if NRASOPS1 > 0
522 case 1:
523 rasops1_init(ri);
524 break;
525 #endif
526 #if NRASOPS2 > 0
527 case 2:
528 rasops2_init(ri);
529 break;
530 #endif
531 #if NRASOPS4 > 0
532 case 4:
533 rasops4_init(ri);
534 break;
535 #endif
536 #if NRASOPS8 > 0
537 case 8:
538 rasops8_init(ri);
539 break;
540 #endif
541 #if (NRASOPS15 + NRASOPS16) > 0
542 case 15:
543 case 16:
544 rasops15_init(ri);
545 break;
546 #endif
547 #if NRASOPS24 > 0
548 case 24:
549 rasops24_init(ri);
550 break;
551 #endif
552 #if NRASOPS32 > 0
553 case 32:
554 rasops32_init(ri);
555 break;
556 #endif
557 default:
558 ri->ri_flg &= ~RI_CFGDONE;
559 aprint_error("%s: depth not supported\n", __func__);
560 splx(s);
561 return -1;
562 }
563
564 #if NRASOPS_ROTATION > 0
565 if (ri->ri_flg & RI_ROTATE_MASK) {
566 if (ri->ri_flg & RI_ROTATE_CW) {
567 ri->ri_real_ops = ri->ri_ops;
568 ri->ri_ops.copycols = rasops_copycols_rotated_cw;
569 ri->ri_ops.copyrows = rasops_copyrows_rotated_cw;
570 ri->ri_ops.erasecols = rasops_erasecols_rotated_cw;
571 ri->ri_ops.eraserows = rasops_eraserows_rotated_cw;
572 ri->ri_ops.putchar = rasops_putchar_rotated_cw;
573 } else if (ri->ri_flg & RI_ROTATE_CCW) {
574 ri->ri_real_ops = ri->ri_ops;
575 ri->ri_ops.copycols = rasops_copycols_rotated_ccw;
576 ri->ri_ops.copyrows = rasops_copyrows_rotated_ccw;
577 ri->ri_ops.erasecols = rasops_erasecols_rotated_ccw;
578 ri->ri_ops.eraserows = rasops_eraserows_rotated_ccw;
579 ri->ri_ops.putchar = rasops_putchar_rotated_ccw;
580 }
581 }
582 #endif
583
584 ri->ri_flg |= RI_CFGDONE;
585 splx(s);
586 return 0;
587 }
588
589 /*
590 * Map a character.
591 */
592 static int
rasops_mapchar(void * cookie,int c,u_int * cp)593 rasops_mapchar(void *cookie, int c, u_int *cp)
594 {
595 struct rasops_info *ri = (struct rasops_info *)cookie;
596
597 KASSERT(ri->ri_font != NULL);
598
599 int glyph = wsfont_map_unichar(ri->ri_font, c);
600 if (glyph < 0 || !CHAR_IN_FONT(glyph, PICK_FONT(ri, glyph))) {
601 *cp = ' ';
602 return 0;
603 }
604
605 *cp = glyph;
606 return 5;
607 }
608
609 /*
610 * Allocate a color attribute.
611 */
612 static int
rasops_allocattr_color(void * cookie,int fg0,int bg0,int flg,long * attr)613 rasops_allocattr_color(void *cookie, int fg0, int bg0, int flg, long *attr)
614 {
615 uint32_t fg = fg0, bg = bg0;
616
617 if (__predict_false(fg >= sizeof(rasops_isgray) ||
618 bg >= sizeof(rasops_isgray)))
619 return EINVAL;
620
621 #ifdef RASOPS_CLIPPING
622 fg &= 7;
623 bg &= 7;
624 #endif
625
626 if ((flg & WSATTR_BLINK) != 0)
627 return EINVAL;
628
629 if ((flg & WSATTR_WSCOLORS) == 0) {
630 #ifdef WS_DEFAULT_FG
631 fg = WS_DEFAULT_FG;
632 #else
633 fg = WSCOL_WHITE;
634 #endif
635 #ifdef WS_DEFAULT_BG
636 bg = WS_DEFAULT_BG;
637 #else
638 bg = WSCOL_BLACK;
639 #endif
640 }
641
642 if ((flg & WSATTR_HILIT) != 0 && fg < 8)
643 fg += 8;
644
645 if ((flg & WSATTR_REVERSE) != 0) {
646 uint32_t swap = fg;
647 fg = bg;
648 bg = swap;
649 }
650
651 flg &= WSATTR_USERMASK;
652
653 if (rasops_isgray[fg])
654 flg |= WSATTR_PRIVATE1;
655
656 if (rasops_isgray[bg])
657 flg |= WSATTR_PRIVATE2;
658
659 *attr = (bg << 16) | (fg << 24) | flg;
660 return 0;
661 }
662
663 /*
664 * Allocate a mono attribute.
665 */
666 static int
rasops_allocattr_mono(void * cookie,int fg0,int bg0,int flg,long * attr)667 rasops_allocattr_mono(void *cookie, int fg0, int bg0, int flg, long *attr)
668 {
669 uint32_t fg = fg0, bg = bg0;
670
671 if ((flg & (WSATTR_BLINK | WSATTR_HILIT | WSATTR_WSCOLORS)) != 0)
672 return EINVAL;
673
674 fg = 0xff;
675 bg = 0;
676
677 if ((flg & WSATTR_REVERSE) != 0) {
678 uint32_t swap = fg;
679 fg = bg;
680 bg = swap;
681 }
682
683 *attr = (bg << 16) | (fg << 24) | flg;
684 return 0;
685 }
686
687 /*
688 * Copy rows.
689 */
690 static void
rasops_copyrows(void * cookie,int src,int dst,int num)691 rasops_copyrows(void *cookie, int src, int dst, int num)
692 {
693 struct rasops_info *ri = (struct rasops_info *)cookie;
694 int stride;
695 uint8_t *sp, *dp, *hp;
696
697 hp = NULL; /* XXX GCC */
698
699 if (__predict_false(dst == src))
700 return;
701
702 #ifdef RASOPS_CLIPPING
703 if (src < 0) {
704 num += src;
705 src = 0;
706 }
707
708 if (src + num > ri->ri_rows)
709 num = ri->ri_rows - src;
710
711 if (dst < 0) {
712 num += dst;
713 dst = 0;
714 }
715
716 if (dst + num > ri->ri_rows)
717 num = ri->ri_rows - dst;
718
719 if (num <= 0)
720 return;
721 #endif
722
723 src *= ri->ri_yscale;
724 dst *= ri->ri_yscale;
725 num *= ri->ri_font->fontheight;
726 stride = ri->ri_stride;
727
728 if (src < dst) {
729 /* backward copy */
730 src += (num - 1) * stride;
731 dst += (num - 1) * stride;
732 stride *= -1;
733 }
734
735 sp = ri->ri_bits + src;
736 dp = ri->ri_bits + dst;
737 if (ri->ri_hwbits)
738 hp = ri->ri_hwbits + dst;
739
740 while (num--) {
741 memcpy(dp, sp, ri->ri_emustride);
742 if (ri->ri_hwbits) {
743 memcpy(hp, dp, ri->ri_emustride);
744 hp += stride;
745 }
746 sp += stride;
747 dp += stride;
748 }
749 }
750
751 /*
752 * Copy columns. This is slow, and hard to optimize due to alignment,
753 * and the fact that we have to copy both left->right and right->left.
754 * We simply cop-out here and use memmove(), since it handles all of
755 * these cases anyway.
756 */
757 static void
rasops_copycols(void * cookie,int row,int src,int dst,int num)758 rasops_copycols(void *cookie, int row, int src, int dst, int num)
759 {
760 struct rasops_info *ri = (struct rasops_info *)cookie;
761 int height;
762 uint8_t *sp, *dp, *hp;
763
764 hp = NULL; /* XXX GCC */
765
766 if (__predict_false(dst == src))
767 return;
768
769 #ifdef RASOPS_CLIPPING
770 /* Catches < 0 case too */
771 if ((unsigned)row >= (unsigned)ri->ri_rows)
772 return;
773
774 if (src < 0) {
775 num += src;
776 src = 0;
777 }
778
779 if (src + num > ri->ri_cols)
780 num = ri->ri_cols - src;
781
782 if (dst < 0) {
783 num += dst;
784 dst = 0;
785 }
786
787 if (dst + num > ri->ri_cols)
788 num = ri->ri_cols - dst;
789
790 if (num <= 0)
791 return;
792 #endif
793
794 height = ri->ri_font->fontheight;
795 row *= ri->ri_yscale;
796 num *= ri->ri_xscale;
797
798 sp = ri->ri_bits + row + src * ri->ri_xscale;
799 dp = ri->ri_bits + row + dst * ri->ri_xscale;
800 if (ri->ri_hwbits)
801 hp = ri->ri_hwbits + row + dst * ri->ri_xscale;
802
803 while (height--) {
804 memmove(dp, sp, num);
805 if (ri->ri_hwbits) {
806 memcpy(hp, dp, num);
807 hp += ri->ri_stride;
808 }
809 sp += ri->ri_stride;
810 dp += ri->ri_stride;
811 }
812 }
813
814 /*
815 * Turn cursor off/on.
816 */
817 static void
rasops_cursor(void * cookie,int on,int row,int col)818 rasops_cursor(void *cookie, int on, int row, int col)
819 {
820 struct rasops_info *ri = (struct rasops_info *)cookie;
821
822 /* Turn old cursor off */
823 if ((ri->ri_flg & RI_CURSOR) != 0)
824 #ifdef RASOPS_CLIPPING
825 if ((ri->ri_flg & RI_CURSORCLIP) == 0)
826 #endif
827 ri->ri_do_cursor(ri);
828
829 /* Select new cursor */
830 ri->ri_crow = row;
831 ri->ri_ccol = col;
832
833 #ifdef RASOPS_CLIPPING
834 ri->ri_flg &= ~RI_CURSORCLIP;
835 if (row < 0 || row >= ri->ri_rows)
836 ri->ri_flg |= RI_CURSORCLIP;
837 else if (col < 0 || col >= ri->ri_cols)
838 ri->ri_flg |= RI_CURSORCLIP;
839 #endif
840
841 if (on) {
842 ri->ri_flg |= RI_CURSOR;
843 #ifdef RASOPS_CLIPPING
844 if ((ri->ri_flg & RI_CURSORCLIP) == 0)
845 #endif
846 ri->ri_do_cursor(ri);
847 } else
848 ri->ri_flg &= ~RI_CURSOR;
849 }
850
851 /*
852 * Make the device colormap
853 */
854 static void
rasops_init_devcmap(struct rasops_info * ri)855 rasops_init_devcmap(struct rasops_info *ri)
856 {
857 int i;
858 uint32_t c;
859 const uint8_t *p;
860
861 switch (ri->ri_depth) {
862 case 1:
863 ri->ri_devcmap[0] = 0;
864 for (i = 1; i < 16; i++)
865 ri->ri_devcmap[i] = -1;
866 return;
867
868 case 2:
869 for (i = 1; i < 15; i++)
870 ri->ri_devcmap[i] = 0xaaaaaaaa;
871
872 ri->ri_devcmap[0] = 0;
873 ri->ri_devcmap[8] = 0x55555555;
874 ri->ri_devcmap[15] = -1;
875 return;
876
877 case 4:
878 for (i = 0; i < 16; i++) {
879 #ifdef RASOPS_APPLE_PALETTE
880 c = apple4_devcmap[i];
881 #else
882 c = i;
883 #endif
884 ri->ri_devcmap[i] =
885 (c << 0) | (c << 4) | (c << 8) | (c << 12) |
886 (c << 16) | (c << 20) | (c << 24) | (c << 28);
887 }
888 return;
889
890 case 8:
891 if ((ri->ri_flg & RI_8BIT_IS_RGB) == 0) {
892 for (i = 0; i < 16; i++) {
893 #ifdef RASOPS_APPLE_PALETTE
894 c = apple8_devcmap[i];
895 #else
896 c = i;
897 #endif
898 ri->ri_devcmap[i] =
899 c | (c << 8) | (c << 16) | (c << 24);
900 }
901 return;
902 }
903 }
904
905 p = rasops_cmap;
906
907 for (i = 0; i < 16; i++) {
908 if (ri->ri_rnum <= 8)
909 c = (uint32_t)(*p >> (8 - ri->ri_rnum)) << ri->ri_rpos;
910 else
911 c = (uint32_t)(*p << (ri->ri_rnum - 8)) << ri->ri_rpos;
912 p++;
913
914 if (ri->ri_gnum <= 8)
915 c |= (uint32_t)(*p >> (8 - ri->ri_gnum)) << ri->ri_gpos;
916 else
917 c |= (uint32_t)(*p << (ri->ri_gnum - 8)) << ri->ri_gpos;
918 p++;
919
920 if (ri->ri_bnum <= 8)
921 c |= (uint32_t)(*p >> (8 - ri->ri_bnum)) << ri->ri_bpos;
922 else
923 c |= (uint32_t)(*p << (ri->ri_bnum - 8)) << ri->ri_bpos;
924 p++;
925
926 /*
927 * Swap byte order if necessary. Then, fill the word for
928 * generic routines, which want this.
929 */
930 switch (ri->ri_depth) {
931 case 8:
932 c |= c << 8;
933 c |= c << 16;
934 break;
935 case 15:
936 case 16:
937 if ((ri->ri_flg & RI_BSWAP) != 0)
938 c = bswap16(c);
939 c |= c << 16;
940 break;
941 case 24:
942 #if BYTE_ORDER == LITTLE_ENDIAN
943 if ((ri->ri_flg & RI_BSWAP) == 0)
944 #else
945 if ((ri->ri_flg & RI_BSWAP) != 0)
946 #endif
947 {
948 /*
949 * Convert to ``big endian'' if not RI_BSWAP.
950 */
951 c = (c & 0x0000ff) << 16|
952 (c & 0x00ff00) |
953 (c & 0xff0000) >> 16;
954 }
955 /*
956 * No worries, we use generic routines only for
957 * gray colors, where all 3 bytes are same.
958 */
959 c |= (c & 0xff) << 24;
960 break;
961 case 32:
962 if ((ri->ri_flg & RI_BSWAP) != 0)
963 c = bswap32(c);
964 break;
965 }
966
967 ri->ri_devcmap[i] = c;
968 }
969 }
970
971 /*
972 * Unpack a rasops attribute
973 */
974 void
rasops_unpack_attr(long attr,int * fg,int * bg,int * underline)975 rasops_unpack_attr(long attr, int *fg, int *bg, int *underline)
976 {
977
978 *fg = ((uint32_t)attr >> 24) & 0xf;
979 *bg = ((uint32_t)attr >> 16) & 0xf;
980 if (underline != NULL)
981 *underline = (uint32_t)attr & WSATTR_UNDERLINE;
982 }
983
984 /*
985 * Erase rows. This isn't static, since 24-bpp uses it in special cases.
986 */
987 void
rasops_eraserows(void * cookie,int row,int num,long attr)988 rasops_eraserows(void *cookie, int row, int num, long attr)
989 {
990 struct rasops_info *ri = (struct rasops_info *)cookie;
991 int bytes;
992 uint32_t bg, *rp, *hp;
993
994 hp = NULL; /* XXX GCC */
995
996 #ifdef RASOPS_CLIPPING
997 if (row < 0) {
998 num += row;
999 row = 0;
1000 }
1001
1002 if (row + num > ri->ri_rows)
1003 num = ri->ri_rows - row;
1004
1005 if (num <= 0)
1006 return;
1007 #endif
1008
1009 /*
1010 * XXX The wsdisplay_emulops interface seems a little deficient in
1011 * that there is no way to clear the *entire* screen. We provide a
1012 * workaround here: if the entire console area is being cleared, and
1013 * the RI_FULLCLEAR flag is set, clear the entire display.
1014 */
1015 if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) {
1016 bytes = ri->ri_stride;
1017 num = ri->ri_height;
1018 rp = (uint32_t *)ri->ri_origbits;
1019 if (ri->ri_hwbits)
1020 hp = (uint32_t *)ri->ri_hworigbits;
1021 } else {
1022 bytes = ri->ri_emustride;
1023 num *= ri->ri_font->fontheight;
1024 rp = (uint32_t *)(ri->ri_bits + row * ri->ri_yscale);
1025 if (ri->ri_hwbits)
1026 hp = (uint32_t *)(ri->ri_hwbits + row * ri->ri_yscale);
1027 }
1028
1029 bg = ATTR_BG(ri, attr);
1030
1031 while (num--) {
1032 rasops_memset32(rp, bg, bytes);
1033 if (ri->ri_hwbits) {
1034 memcpy(hp, rp, bytes);
1035 DELTA(hp, ri->ri_stride, uint32_t *);
1036 }
1037 DELTA(rp, ri->ri_stride, uint32_t *);
1038 }
1039 }
1040
1041 /*
1042 * Actually turn the cursor on or off. This does the dirty work for
1043 * rasops_cursor().
1044 */
1045 static void
rasops_do_cursor(struct rasops_info * ri)1046 rasops_do_cursor(struct rasops_info *ri)
1047 {
1048 int row, col, height, slop1, slop2, full, cnt;
1049 uint32_t mask1, mask2, *dp;
1050 uint8_t tmp, *rp, *hp;
1051
1052 hp = NULL; /* XXX GCC */
1053
1054 #if NRASOPS_ROTATION > 0
1055 if (ri->ri_flg & RI_ROTATE_MASK) {
1056 if (ri->ri_flg & RI_ROTATE_CW) {
1057 /* Rotate rows/columns */
1058 row = ri->ri_ccol;
1059 col = ri->ri_rows - ri->ri_crow - 1;
1060 } else if (ri->ri_flg & RI_ROTATE_CCW) {
1061 /* Rotate rows/columns */
1062 row = ri->ri_cols - ri->ri_ccol - 1;
1063 col = ri->ri_crow;
1064 } else { /* upside-down */
1065 row = ri->ri_crow;
1066 col = ri->ri_ccol;
1067 }
1068 } else
1069 #endif
1070 {
1071 row = ri->ri_crow;
1072 col = ri->ri_ccol;
1073 }
1074
1075 height = ri->ri_font->fontheight;
1076
1077 rp = ri->ri_bits + FBOFFSET(ri, row, col);
1078 if (ri->ri_hwbits)
1079 hp = ri->ri_hwbits + FBOFFSET(ri, row, col);
1080
1081 /*
1082 * For ri_xscale = 1:
1083 *
1084 * Logic below does not work for ri_xscale = 1, e.g.,
1085 * fontwidth = 8 and bpp = 1. So we take care of it.
1086 */
1087 if (ri->ri_xscale == 1) {
1088 while (height--) {
1089 tmp = ~*rp;
1090 *rp = tmp;
1091 if (ri->ri_hwbits) {
1092 *hp = tmp;
1093 hp += ri->ri_stride;
1094 }
1095 rp += ri->ri_stride;
1096 }
1097 return;
1098 }
1099
1100 /*
1101 * For ri_xscale = 2, 3, 4, ...:
1102 *
1103 * Note that siop1 <= ri_xscale even for ri_xscale = 2,
1104 * since rp % 3 = 0 or 2 (ri_stride % 4 = 0).
1105 */
1106 slop1 = (4 - ((uintptr_t)rp & 3)) & 3;
1107 slop2 = (ri->ri_xscale - slop1) & 3;
1108 full = (ri->ri_xscale - slop1 /* - slop2 */) >> 2;
1109
1110 rp = (uint8_t *)((uintptr_t)rp & ~3);
1111 hp = (uint8_t *)((uintptr_t)hp & ~3);
1112
1113 mask1 = rasops_lmask32[4 - slop1];
1114 mask2 = rasops_rmask32[slop2];
1115
1116 while (height--) {
1117 dp = (uint32_t *)rp;
1118
1119 if (slop1) {
1120 *dp = *dp ^ mask1;
1121 dp++;
1122 }
1123
1124 for (cnt = full; cnt; cnt--) {
1125 *dp = ~*dp;
1126 dp++;
1127 }
1128
1129 if (slop2)
1130 *dp = *dp ^ mask2;
1131
1132 if (ri->ri_hwbits) {
1133 memcpy(hp, rp, ((slop1 != 0) + full +
1134 (slop2 != 0)) << 2);
1135 hp += ri->ri_stride;
1136 }
1137 rp += ri->ri_stride;
1138 }
1139 }
1140
1141 /*
1142 * Erase columns.
1143 */
1144 void
rasops_erasecols(void * cookie,int row,int col,int num,long attr)1145 rasops_erasecols(void *cookie, int row, int col, int num, long attr)
1146 {
1147 struct rasops_info *ri = (struct rasops_info *)cookie;
1148 int height;
1149 uint32_t bg, *rp, *hp;
1150
1151 hp = NULL; /* XXX GCC */
1152
1153 #ifdef RASOPS_CLIPPING
1154 if ((unsigned)row >= (unsigned)ri->ri_rows)
1155 return;
1156
1157 if (col < 0) {
1158 num += col;
1159 col = 0;
1160 }
1161
1162 if (col + num > ri->ri_cols)
1163 num = ri->ri_cols - col;
1164
1165 if (num <= 0)
1166 return;
1167 #endif
1168
1169 height = ri->ri_font->fontheight;
1170 num *= ri->ri_xscale;
1171
1172 rp = (uint32_t *)(ri->ri_bits + FBOFFSET(ri, row, col));
1173 if (ri->ri_hwbits)
1174 hp = (uint32_t *)(ri->ri_hwbits + FBOFFSET(ri, row, col));
1175
1176 bg = ATTR_BG(ri, attr);
1177
1178 while (height--) {
1179 rasops_memset32(rp, bg, num);
1180 if (ri->ri_hwbits) {
1181 memcpy(hp, rp, num);
1182 DELTA(hp, ri->ri_stride, uint32_t *);
1183 }
1184 DELTA(rp, ri->ri_stride, uint32_t *);
1185 }
1186 }
1187
1188 void
rasops_make_box_chars_16(struct rasops_info * ri)1189 rasops_make_box_chars_16(struct rasops_info *ri)
1190 {
1191 int c, i, mid;
1192 uint16_t vert_mask, hmask_left, hmask_right;
1193 uint16_t *data = (uint16_t *)ri->ri_optfont.data;
1194
1195 vert_mask = 0xc000U >> ((ri->ri_font->fontwidth >> 1) - 1);
1196 hmask_left = 0xff00U << (8 - (ri->ri_font->fontwidth >> 1));
1197 hmask_right = hmask_left >> ((ri->ri_font->fontwidth + 1) >> 1);
1198
1199 vert_mask = htobe16(vert_mask);
1200 hmask_left = htobe16(hmask_left);
1201 hmask_right = htobe16(hmask_right);
1202
1203 mid = (ri->ri_font->fontheight + 1) >> 1;
1204
1205 /* 0x00 would be empty anyway so don't bother */
1206 for (c = 1; c < 16; c++) {
1207 data += ri->ri_font->fontheight;
1208 if (c & 1) {
1209 /* upper segment */
1210 for (i = 0; i < mid; i++)
1211 data[i] = vert_mask;
1212 }
1213 if (c & 4) {
1214 /* lower segment */
1215 for (i = mid; i < ri->ri_font->fontheight; i++)
1216 data[i] = vert_mask;
1217 }
1218 if (c & 2) {
1219 /* right segment */
1220 i = ri->ri_font->fontheight >> 1;
1221 data[mid - 1] |= hmask_right;
1222 data[mid] |= hmask_right;
1223 }
1224 if (c & 8) {
1225 /* left segment */
1226 data[mid - 1] |= hmask_left;
1227 data[mid] |= hmask_left;
1228 }
1229 }
1230 }
1231
1232 void
rasops_make_box_chars_8(struct rasops_info * ri)1233 rasops_make_box_chars_8(struct rasops_info *ri)
1234 {
1235 int c, i, mid;
1236 uint8_t vert_mask, hmask_left, hmask_right;
1237 uint8_t *data = (uint8_t *)ri->ri_optfont.data;
1238
1239 vert_mask = 0xc0U >> ((ri->ri_font->fontwidth >> 1) - 1);
1240 hmask_left = 0xf0U << (4 - (ri->ri_font->fontwidth >> 1));
1241 hmask_right = hmask_left >> ((ri->ri_font->fontwidth + 1) >> 1);
1242
1243 mid = (ri->ri_font->fontheight + 1) >> 1;
1244
1245 /* 0x00 would be empty anyway so don't bother */
1246 for (c = 1; c < 16; c++) {
1247 data += ri->ri_font->fontheight;
1248 if (c & 1) {
1249 /* upper segment */
1250 for (i = 0; i < mid; i++)
1251 data[i] = vert_mask;
1252 }
1253 if (c & 4) {
1254 /* lower segment */
1255 for (i = mid; i < ri->ri_font->fontheight; i++)
1256 data[i] = vert_mask;
1257 }
1258 if (c & 2) {
1259 /* right segment */
1260 i = ri->ri_font->fontheight >> 1;
1261 data[mid - 1] |= hmask_right;
1262 data[mid] |= hmask_right;
1263 }
1264 if (c & 8) {
1265 /* left segment */
1266 data[mid - 1] |= hmask_left;
1267 data[mid] |= hmask_left;
1268 }
1269 }
1270 }
1271
1272 void
rasops_make_box_chars_32(struct rasops_info * ri)1273 rasops_make_box_chars_32(struct rasops_info *ri)
1274 {
1275 int c, i, mid;
1276 uint32_t vert_mask, hmask_left, hmask_right;
1277 uint32_t *data = (uint32_t *)ri->ri_optfont.data;
1278
1279 vert_mask = 0xc0000000U >> ((ri->ri_font->fontwidth >> 1) - 1);
1280 hmask_left = 0xffff0000U << (16 - (ri->ri_font->fontwidth >> 1));
1281 hmask_right = hmask_left >> ((ri->ri_font->fontwidth + 1) >> 1);
1282
1283 vert_mask = htobe32(vert_mask);
1284 hmask_left = htobe32(hmask_left);
1285 hmask_right = htobe32(hmask_right);
1286
1287 mid = (ri->ri_font->fontheight + 1) >> 1;
1288
1289 /* 0x00 would be empty anyway so don't bother */
1290 for (c = 1; c < 16; c++) {
1291 data += ri->ri_font->fontheight;
1292 if (c & 1) {
1293 /* upper segment */
1294 for (i = 0; i < mid; i++)
1295 data[i] = vert_mask;
1296 }
1297 if (c & 4) {
1298 /* lower segment */
1299 for (i = mid; i < ri->ri_font->fontheight; i++)
1300 data[i] = vert_mask;
1301 }
1302 if (c & 2) {
1303 /* right segment */
1304 i = ri->ri_font->fontheight >> 1;
1305 data[mid - 1] |= hmask_right;
1306 data[mid] |= hmask_right;
1307 }
1308 if (c & 8) {
1309 /* left segment */
1310 data[mid - 1] |= hmask_left;
1311 data[mid] |= hmask_left;
1312 }
1313 }
1314 }
1315
1316 void
rasops_make_box_chars_alpha(struct rasops_info * ri)1317 rasops_make_box_chars_alpha(struct rasops_info *ri)
1318 {
1319 int c, i, hmid, vmid, wi, he;
1320 uint8_t *data = (uint8_t *)ri->ri_optfont.data;
1321 uint8_t *ddata;
1322
1323 he = ri->ri_font->fontheight;
1324 wi = ri->ri_font->fontwidth;
1325
1326 vmid = (he + 1) >> 1;
1327 hmid = (wi + 1) >> 1;
1328
1329 /* 0x00 would be empty anyway so don't bother */
1330 for (c = 1; c < 16; c++) {
1331 data += ri->ri_fontscale;
1332 if (c & 1) {
1333 /* upper segment */
1334 ddata = data + hmid;
1335 for (i = 0; i <= vmid; i++) {
1336 *ddata = 0xff;
1337 ddata += wi;
1338 }
1339 }
1340 if (c & 4) {
1341 /* lower segment */
1342 ddata = data + wi * vmid + hmid;
1343 for (i = vmid; i < he; i++) {
1344 *ddata = 0xff;
1345 ddata += wi;
1346 }
1347 }
1348 if (c & 2) {
1349 /* right segment */
1350 ddata = data + wi * vmid + hmid;
1351 for (i = hmid; i < wi; i++) {
1352 *ddata = 0xff;
1353 ddata++;
1354 }
1355 }
1356 if (c & 8) {
1357 /* left segment */
1358 ddata = data + wi * vmid;
1359 for (i = 0; i <= hmid; i++) {
1360 *ddata = 0xff;
1361 ddata++;
1362 }
1363 }
1364 }
1365 }
1366
1367 /*
1368 * Return a colour map appropriate for the given struct rasops_info in the
1369 * same form used by rasops_cmap[]
1370 * For now this is either a copy of rasops_cmap[] or an R3G3B2 map, it should
1371 * probably be a linear ( or gamma corrected? ) ramp for higher depths.
1372 */
1373 int
rasops_get_cmap(struct rasops_info * ri,uint8_t * palette,size_t bytes)1374 rasops_get_cmap(struct rasops_info *ri, uint8_t *palette, size_t bytes)
1375 {
1376
1377 if ((ri->ri_depth == 8) && ((ri->ri_flg & RI_8BIT_IS_RGB) != 0)) {
1378 /* generate an R3G3B2 palette */
1379 int i, idx = 0;
1380 uint8_t tmp;
1381
1382 if (bytes < 256 * 3)
1383 return EINVAL;
1384 for (i = 0; i < 256; i++) {
1385 tmp = i & 0xe0;
1386 /*
1387 * replicate bits so 0xe0 maps to a red value of 0xff
1388 * in order to make white look actually white
1389 */
1390 tmp |= (tmp >> 3) | (tmp >> 6);
1391 palette[idx] = tmp;
1392 idx++;
1393
1394 tmp = (i & 0x1c) << 3;
1395 tmp |= (tmp >> 3) | (tmp >> 6);
1396 palette[idx] = tmp;
1397 idx++;
1398
1399 tmp = (i & 0x03) << 6;
1400 tmp |= tmp >> 2;
1401 tmp |= tmp >> 4;
1402 palette[idx] = tmp;
1403 idx++;
1404 }
1405 } else
1406 memcpy(palette, rasops_cmap, uimin(bytes, sizeof(rasops_cmap)));
1407
1408 return 0;
1409 }
1410
1411 #if NRASOPS_ROTATION > 0
1412 /*
1413 * Quarter clockwise rotation routines (originally intended for the
1414 * built-in Zaurus C3x00 display in 16bpp).
1415 */
1416
1417 static void
rasops_rotate_font(int * cookie,int rotate)1418 rasops_rotate_font(int *cookie, int rotate)
1419 {
1420 struct rotatedfont *f;
1421 int ncookie;
1422
1423 SLIST_FOREACH(f, &rotatedfonts, rf_next) {
1424 if (f->rf_cookie == *cookie) {
1425 *cookie = f->rf_rotated;
1426 return;
1427 }
1428 }
1429
1430 /*
1431 * We did not find a rotated version of this font. Ask the wsfont
1432 * code to compute one for us.
1433 */
1434
1435 f = kmem_alloc(sizeof(*f), KM_SLEEP);
1436
1437 if ((ncookie = wsfont_rotate(*cookie, rotate)) == -1)
1438 goto fail;
1439
1440 f->rf_cookie = *cookie;
1441 f->rf_rotated = ncookie;
1442 SLIST_INSERT_HEAD(&rotatedfonts, f, rf_next);
1443
1444 *cookie = ncookie;
1445 return;
1446
1447 fail: kmem_free(f, sizeof(*f));
1448 return;
1449 }
1450
1451 static void
rasops_copychar(void * cookie,int srcrow,int dstrow,int srccol,int dstcol)1452 rasops_copychar(void *cookie, int srcrow, int dstrow, int srccol, int dstcol)
1453 {
1454 struct rasops_info *ri = (struct rasops_info *)cookie;
1455 int r_srcrow, r_dstrow, r_srccol, r_dstcol, height;
1456 uint8_t *sp, *dp;
1457
1458 r_srcrow = srccol;
1459 r_dstrow = dstcol;
1460 r_srccol = ri->ri_rows - srcrow - 1;
1461 r_dstcol = ri->ri_rows - dstrow - 1;
1462
1463 r_srcrow *= ri->ri_yscale;
1464 r_dstrow *= ri->ri_yscale;
1465 height = ri->ri_font->fontheight;
1466
1467 sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale;
1468 dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale;
1469
1470 while (height--) {
1471 memmove(dp, sp, ri->ri_xscale);
1472 dp += ri->ri_stride;
1473 sp += ri->ri_stride;
1474 }
1475 }
1476
1477 static void
rasops_putchar_rotated_cw(void * cookie,int row,int col,u_int uc,long attr)1478 rasops_putchar_rotated_cw(void *cookie, int row, int col, u_int uc, long attr)
1479 {
1480 struct rasops_info *ri = (struct rasops_info *)cookie;
1481 int height;
1482 uint16_t fg, *rp;
1483
1484 if (__predict_false((unsigned int)row > ri->ri_rows ||
1485 (unsigned int)col > ri->ri_cols))
1486 return;
1487
1488 /* Avoid underflow */
1489 if (ri->ri_rows - row - 1 < 0)
1490 return;
1491
1492 /* Do rotated char sans (side)underline */
1493 ri->ri_real_ops.putchar(cookie, col, ri->ri_rows - row - 1, uc,
1494 attr & ~WSATTR_UNDERLINE);
1495
1496 /*
1497 * Do rotated underline
1498 * XXX this assumes 16-bit color depth
1499 */
1500 if ((attr & WSATTR_UNDERLINE) != 0) {
1501 height = ri->ri_font->fontheight;
1502
1503 rp = (uint16_t *)(ri->ri_bits + col * ri->ri_yscale +
1504 (ri->ri_rows - row - 1) * ri->ri_xscale);
1505
1506 fg = (uint16_t)ATTR_FG(ri, attr);
1507
1508 while (height--) {
1509 *rp = fg;
1510 DELTA(rp, ri->ri_stride, uint16_t *);
1511 }
1512 }
1513 }
1514
1515 static void
rasops_erasecols_rotated_cw(void * cookie,int row,int col,int num,long attr)1516 rasops_erasecols_rotated_cw(void *cookie, int row, int col, int num, long attr)
1517 {
1518 struct rasops_info *ri = (struct rasops_info *)cookie;
1519 int i;
1520
1521 for (i = col; i < col + num; i++)
1522 ri->ri_ops.putchar(cookie, row, i, ' ', attr);
1523 }
1524
1525 /* XXX: these could likely be optimised somewhat. */
1526 static void
rasops_copyrows_rotated_cw(void * cookie,int src,int dst,int num)1527 rasops_copyrows_rotated_cw(void *cookie, int src, int dst, int num)
1528 {
1529 struct rasops_info *ri = (struct rasops_info *)cookie;
1530 int col, roff;
1531
1532 if (src > dst)
1533 for (roff = 0; roff < num; roff++)
1534 for (col = 0; col < ri->ri_cols; col++)
1535 rasops_copychar(cookie, src + roff, dst + roff,
1536 col, col);
1537 else
1538 for (roff = num - 1; roff >= 0; roff--)
1539 for (col = 0; col < ri->ri_cols; col++)
1540 rasops_copychar(cookie, src + roff, dst + roff,
1541 col, col);
1542 }
1543
1544 static void
rasops_copycols_rotated_cw(void * cookie,int row,int src,int dst,int num)1545 rasops_copycols_rotated_cw(void *cookie, int row, int src, int dst, int num)
1546 {
1547 int coff;
1548
1549 if (src > dst)
1550 for (coff = 0; coff < num; coff++)
1551 rasops_copychar(cookie, row, row, src + coff,
1552 dst + coff);
1553 else
1554 for (coff = num - 1; coff >= 0; coff--)
1555 rasops_copychar(cookie, row, row, src + coff,
1556 dst + coff);
1557 }
1558
1559 static void
rasops_eraserows_rotated_cw(void * cookie,int row,int num,long attr)1560 rasops_eraserows_rotated_cw(void *cookie, int row, int num, long attr)
1561 {
1562 struct rasops_info *ri = (struct rasops_info *)cookie;
1563 int col, rn;
1564
1565 for (rn = row; rn < row + num; rn++)
1566 for (col = 0; col < ri->ri_cols; col++)
1567 ri->ri_ops.putchar(cookie, rn, col, ' ', attr);
1568 }
1569
1570 /*
1571 * Quarter counter-clockwise rotation routines (originally intended for the
1572 * built-in Sharp W-ZERO3 display in 16bpp).
1573 */
1574 static void
rasops_copychar_ccw(void * cookie,int srcrow,int dstrow,int srccol,int dstcol)1575 rasops_copychar_ccw(void *cookie, int srcrow, int dstrow, int srccol,
1576 int dstcol)
1577 {
1578 struct rasops_info *ri = (struct rasops_info *)cookie;
1579 int r_srcrow, r_dstrow, r_srccol, r_dstcol, height;
1580 uint8_t *sp, *dp;
1581
1582 r_srcrow = ri->ri_cols - srccol - 1;
1583 r_dstrow = ri->ri_cols - dstcol - 1;
1584 r_srccol = srcrow;
1585 r_dstcol = dstrow;
1586
1587 r_srcrow *= ri->ri_yscale;
1588 r_dstrow *= ri->ri_yscale;
1589 height = ri->ri_font->fontheight;
1590
1591 sp = ri->ri_bits + r_srcrow + r_srccol * ri->ri_xscale;
1592 dp = ri->ri_bits + r_dstrow + r_dstcol * ri->ri_xscale;
1593
1594 while (height--) {
1595 memmove(dp, sp, ri->ri_xscale);
1596 dp += ri->ri_stride;
1597 sp += ri->ri_stride;
1598 }
1599 }
1600
1601 static void
rasops_putchar_rotated_ccw(void * cookie,int row,int col,u_int uc,long attr)1602 rasops_putchar_rotated_ccw(void *cookie, int row, int col, u_int uc, long attr)
1603 {
1604 struct rasops_info *ri = (struct rasops_info *)cookie;
1605 int height;
1606 uint16_t fg, *rp;
1607
1608 if (__predict_false((unsigned int)row > ri->ri_rows ||
1609 (unsigned int)col > ri->ri_cols))
1610 return;
1611
1612 /* Avoid underflow */
1613 if (ri->ri_cols - col - 1 < 0)
1614 return;
1615
1616 /* Do rotated char sans (side)underline */
1617 ri->ri_real_ops.putchar(cookie, ri->ri_cols - col - 1, row, uc,
1618 attr & ~WSATTR_UNDERLINE);
1619
1620 /*
1621 * Do rotated underline
1622 * XXX this assumes 16-bit color depth
1623 */
1624 if ((attr & WSATTR_UNDERLINE) != 0) {
1625 height = ri->ri_font->fontheight;
1626
1627 rp = (uint16_t *)(ri->ri_bits +
1628 (ri->ri_cols - col - 1) * ri->ri_yscale +
1629 row * ri->ri_xscale +
1630 (ri->ri_font->fontwidth - 1) * ri->ri_pelbytes);
1631
1632 fg = (uint16_t)ATTR_FG(ri, attr);
1633
1634 while (height--) {
1635 *rp = fg;
1636 DELTA(rp, ri->ri_stride, uint16_t *);
1637 }
1638 }
1639 }
1640
1641 /* XXX: these could likely be optimised somewhat. */
1642 static void
rasops_copyrows_rotated_ccw(void * cookie,int src,int dst,int num)1643 rasops_copyrows_rotated_ccw(void *cookie, int src, int dst, int num)
1644 {
1645 struct rasops_info *ri = (struct rasops_info *)cookie;
1646 int col, roff;
1647
1648 if (src > dst)
1649 for (roff = 0; roff < num; roff++)
1650 for (col = 0; col < ri->ri_cols; col++)
1651 rasops_copychar_ccw(cookie,
1652 src + roff, dst + roff, col, col);
1653 else
1654 for (roff = num - 1; roff >= 0; roff--)
1655 for (col = 0; col < ri->ri_cols; col++)
1656 rasops_copychar_ccw(cookie,
1657 src + roff, dst + roff, col, col);
1658 }
1659
1660 static void
rasops_copycols_rotated_ccw(void * cookie,int row,int src,int dst,int num)1661 rasops_copycols_rotated_ccw(void *cookie, int row, int src, int dst, int num)
1662 {
1663 int coff;
1664
1665 if (src > dst)
1666 for (coff = 0; coff < num; coff++)
1667 rasops_copychar_ccw(cookie, row, row,
1668 src + coff, dst + coff);
1669 else
1670 for (coff = num - 1; coff >= 0; coff--)
1671 rasops_copychar_ccw(cookie, row, row,
1672 src + coff, dst + coff);
1673 }
1674 #endif /* NRASOPS_ROTATION */
1675