4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
28 * Copyright 2017 Toomas Soome <tsoome@me.com>
32 * Generic font related data and functions shared by early boot console
33 * in dboot, kernel startup and full kernel.
35 #include <sys/types.h>
36 #include <sys/systm.h>
38 #include <sys/sysmacros.h>
41 * Fonts are statically linked with this module. At some point an
42 * RFE might be desireable to allow dynamic font loading. The
43 * original intention to facilitate dynamic fonts can be seen
44 * by examining the data structures and set_font(). As much of
45 * the original code is retained but modified to be suited for
46 * traversing a list of static fonts.
50 * Must be sorted by font size in descending order
52 struct fontlist fonts
[] = {
53 { &font_data_12x22
, NULL
},
54 { &font_data_8x16
, NULL
},
55 { &font_data_7x14
, NULL
},
56 { &font_data_6x10
, NULL
},
61 set_font(struct font
*f
, short *rows
, short *cols
, short height
, short width
)
63 bitmap_data_t
*default_font
= NULL
, *font_selected
= NULL
;
68 * Find best font for these dimensions, or use default
70 * A 1 pixel border is the absolute minimum we could have
71 * as a border around the text window (BORDER_PIXELS = 2),
72 * however a slightly larger border not only looks better
73 * but for the fonts currently statically built into the
74 * emulator causes much better font selection for the
75 * normal range of screen resolutions.
77 for (fl
= fonts
; fl
->data
; fl
++) {
78 if ((((*rows
* fl
->data
->height
) + BORDER_PIXELS
) <= height
) &&
79 (((*cols
* fl
->data
->width
) + BORDER_PIXELS
) <= width
)) {
80 font_selected
= fl
->data
;
81 *rows
= (height
- BORDER_PIXELS
) /
82 font_selected
->height
;
83 *cols
= (width
- BORDER_PIXELS
) /
87 default_font
= fl
->data
;
90 * The minus 2 is to make sure we have at least a 1 pixel
91 * border around the entire screen.
93 if (font_selected
== NULL
) {
94 if (default_font
== NULL
)
95 default_font
= &DEFAULT_FONT_DATA
;
97 if (((*rows
* default_font
->height
) > height
) ||
98 ((*cols
* default_font
->width
) > width
)) {
99 *rows
= (height
- 2) / default_font
->height
;
100 *cols
= (width
- 2) / default_font
->width
;
102 font_selected
= default_font
;
105 f
->width
= font_selected
->width
;
106 f
->height
= font_selected
->height
;
108 for (i
= 0; i
< ENCODED_CHARS
; i
++)
109 f
->char_ptr
[i
] = font_selected
->encoding
[i
];
111 f
->image_data
= font_selected
->image
;
116 * bit_to_pix4 is for 4-bit frame buffers. It will write one output byte
117 * for each 2 bits of input bitmap. It inverts the input bits before
118 * doing the output translation, for reverse video.
120 * Assuming foreground is 0001 and background is 0000...
121 * An input data byte of 0x53 will output the bit pattern
122 * 00000001 00000001 00000000 00010001.
142 bytes_wide
= (f
->width
+ 7) / 8;
144 for (row
= 0; row
< f
->height
; row
++) {
145 for (byte
= 0; byte
< bytes_wide
; byte
++) {
147 for (i
= 0; i
< 4; i
++) {
148 nibblett
= (data
>> ((3-i
) * 2)) & 0x3;
151 *dest
++ = bg_color
<< 4 | bg_color
;
154 *dest
++ = bg_color
<< 4 | fg_color
;
157 *dest
++ = fg_color
<< 4 | bg_color
;
160 *dest
++ = fg_color
<< 4 | fg_color
;
169 * bit_to_pix8 is for 8-bit frame buffers. It will write one output byte
170 * for each bit of input bitmap. It inverts the input bits before
171 * doing the output translation, for reverse video.
173 * Assuming foreground is 00000001 and background is 00000000...
174 * An input data byte of 0x53 will output the bit pattern
175 * 0000000 000000001 00000000 00000001 00000000 00000000 00000001 00000001.
196 bytes_wide
= (f
->width
+ 7) / 8;
198 for (row
= 0; row
< f
->height
; row
++) {
200 for (byte
= 0; byte
< bytes_wide
; byte
++) {
203 nbits
= MIN(8, bitsleft
);
205 for (i
= 0; i
< nbits
; i
++) {
206 *dest
++ = (data
& mask
? fg_color
: bg_color
);
214 * bit_to_pix16 is for 16-bit frame buffers. It will write two output bytes
215 * for each bit of input bitmap. It inverts the input bits before
216 * doing the output translation, for reverse video.
218 * Assuming foreground is 11111111 11111111
219 * and background is 00000000 00000000
220 * An input data byte of 0x53 will output the bit pattern
250 bytes_wide
= (f
->width
+ 7) / 8;
252 for (row
= 0; row
< f
->height
; row
++) {
254 for (byte
= 0; byte
< bytes_wide
; byte
++) {
256 nbits
= MIN(8, bitsleft
);
258 for (i
= 0; i
< nbits
; i
++) {
259 d
= ((data
<< i
) & 0x80 ?
260 fg_color16
: bg_color16
);
268 * bit_to_pix24 is for 24-bit frame buffers. It will write three output bytes
269 * for each bit of input bitmap. It inverts the input bits before
270 * doing the output translation, for reverse video.
272 * Assuming foreground is 11111111 11111111 11111111
273 * and background is 00000000 00000000 00000000
274 * An input data byte of 0x53 will output the bit pattern
276 * 00000000 00000000 00000000
277 * 11111111 11111111 11111111
278 * 00000000 00000000 00000000
279 * 11111111 11111111 11111111
280 * 00000000 00000000 00000000
281 * 00000000 00000000 00000000
282 * 11111111 11111111 11111111
283 * 11111111 11111111 11111111
304 bytes_wide
= (f
->width
+ 7) / 8;
306 for (row
= 0; row
< f
->height
; row
++) {
308 for (byte
= 0; byte
< bytes_wide
; byte
++) {
310 nbits
= MIN(8, bitsleft
);
312 for (i
= 0; i
< nbits
; i
++) {
313 d
= ((data
<< i
) & 0x80 ?
314 fg_color32
: bg_color32
);
316 *dest
++ = (d
>> 8) & 0xff;
317 *dest
++ = (d
>> 16) & 0xff;
324 * bit_to_pix32 is for 32-bit frame buffers. It will write four output bytes
325 * for each bit of input bitmap. It inverts the input bits before
326 * doing the output translation, for reverse video. Note that each
327 * 24-bit RGB value is finally stored in a 32-bit unsigned int, with the
328 * high-order byte set to zero.
330 * Assuming foreground is 00000000 11111111 11111111 11111111
331 * and background is 00000000 00000000 00000000 00000000
332 * An input data byte of 0x53 will output the bit pattern
334 * 00000000 00000000 00000000 00000000
335 * 00000000 11111111 11111111 11111111
336 * 00000000 00000000 00000000 00000000
337 * 00000000 11111111 11111111 11111111
338 * 00000000 00000000 00000000 00000000
339 * 00000000 00000000 00000000 00000000
340 * 00000000 11111111 11111111 11111111
341 * 00000000 11111111 11111111 11111111
362 bytes_wide
= (f
->width
+ 7) / 8;
364 for (row
= 0; row
< f
->height
; row
++) {
366 for (byte
= 0; byte
< bytes_wide
; byte
++) {
368 nbits
= MIN(8, bitsleft
);
370 for (i
= 0; i
< nbits
; i
++) {
371 *dest
++ = ((data
<< i
) & 0x80 ?
372 fg_color32
: bg_color32
);