kernel/font/font.c

   1 /*
   2  * CDDL HEADER START
   3  *
   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.
   7  *
   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.
  12  *
  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]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * Copyright 2017 Toomas Soome <tsoome@me.com>
  29  */
  30
  31 /*
  32  * Generic font related data and functions shared by early boot console
  33  * in dboot, kernel startup and full kernel.
  34  */
  35 #include <sys/types.h>
  36 #include <sys/systm.h>
  37 #include <sys/font.h>
  38 #include <sys/sysmacros.h>
  39
  40 /*
  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.
  47  */
  48
  49 /*
  50  * Must be sorted by font size in descending order
  51  */
  52 struct fontlist fonts[] = {
  53         {  &font_data_12x22,    NULL  },
  54         {  &font_data_8x16,     NULL  },
  55         {  &font_data_7x14,     NULL  },
  56         {  &font_data_6x10,     NULL  },
  57         {  NULL, NULL  }
  58 };
  59
  60 void
  61 set_font(struct font *f, short *rows, short *cols, short height, short width)
  62 {
  63         bitmap_data_t   *font_selected = NULL;
  64         struct fontlist *fl;
  65         int i;
  66
  67         /*
  68          * Find best font for these dimensions, or use default
  69          *
  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.
  76          */
  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                         break;
  82                 }
  83         }
  84         /*
  85          * The minus 2 is to make sure we have at least a 1 pixel
  86          * border around the entire screen.
  87          */
  88         if (font_selected == NULL) {
  89                 if (((*rows * DEFAULT_FONT_DATA.height) > height) ||
  90                     ((*cols * DEFAULT_FONT_DATA.width) > width)) {
  91                         *rows = (height - 2) / DEFAULT_FONT_DATA.height;
  92                         *cols = (width - 2) / DEFAULT_FONT_DATA.width;
  93                 }
  94                 font_selected = &DEFAULT_FONT_DATA;
  95         }
  96
  97         f->width = font_selected->width;
  98         f->height = font_selected->height;
  99
 100         for (i = 0; i < ENCODED_CHARS; i++)
 101                 f->char_ptr[i] = font_selected->encoding[i];
 102
 103         f->image_data = font_selected->image;
 104
 105 }
 106
 107 /*
 108  * bit_to_pix4 is for 4-bit frame buffers.  It will write one output byte
 109  * for each 2 bits of input bitmap.  It inverts the input bits before
 110  * doing the output translation, for reverse video.
 111  *
 112  * Assuming foreground is 0001 and background is 0000...
 113  * An input data byte of 0x53 will output the bit pattern
 114  * 00000001 00000001 00000000 00010001.
 115  */
 116
 117 void
 118 font_bit_to_pix4(
 119     struct font *f,
 120     uint8_t *dest,
 121     uint8_t c,
 122     uint8_t fg_color,
 123     uint8_t bg_color)
 124 {
 125         int     row;
 126         int     byte;
 127         int     i;
 128         uint8_t *cp;
 129         uint8_t data;
 130         uint8_t nibblett;
 131         int     bytes_wide;
 132
 133         cp = f->char_ptr[c];
 134         bytes_wide = (f->width + 7) / 8;
 135
 136         for (row = 0; row < f->height; row++) {
 137                 for (byte = 0; byte < bytes_wide; byte++) {
 138                         data = *cp++;
 139                         for (i = 0; i < 4; i++) {
 140                                 nibblett = (data >> ((3-i) * 2)) & 0x3;
 141                                 switch (nibblett) {
 142                                 case 0x0:
 143                                         *dest++ = bg_color << 4 | bg_color;
 144                                         break;
 145                                 case 0x1:
 146                                         *dest++ = bg_color << 4 | fg_color;
 147                                         break;
 148                                 case 0x2:
 149                                         *dest++ = fg_color << 4 | bg_color;
 150                                         break;
 151                                 case 0x3:
 152                                         *dest++ = fg_color << 4 | fg_color;
 153                                         break;
 154                                 }
 155                         }
 156                 }
 157         }
 158 }
 159
 160 /*
 161  * bit_to_pix8 is for 8-bit frame buffers.  It will write one output byte
 162  * for each bit of input bitmap.  It inverts the input bits before
 163  * doing the output translation, for reverse video.
 164  *
 165  * Assuming foreground is 00000001 and background is 00000000...
 166  * An input data byte of 0x53 will output the bit pattern
 167  * 0000000 000000001 00000000 00000001 00000000 00000000 00000001 00000001.
 168  */
 169
 170 void
 171 font_bit_to_pix8(
 172     struct font *f,
 173     uint8_t *dest,
 174     uint8_t c,
 175     uint8_t fg_color,
 176     uint8_t bg_color)
 177 {
 178         int     row;
 179         int     byte;
 180         int     i;
 181         uint8_t *cp;
 182         uint8_t data;
 183         int     bytes_wide;
 184         uint8_t mask;
 185         int     bitsleft, nbits;
 186
 187         cp = f->char_ptr[c];
 188         bytes_wide = (f->width + 7) / 8;
 189
 190         for (row = 0; row < f->height; row++) {
 191                 bitsleft = f->width;
 192                 for (byte = 0; byte < bytes_wide; byte++) {
 193                         data = *cp++;
 194                         mask = 0x80;
 195                         nbits = MIN(8, bitsleft);
 196                         bitsleft -= nbits;
 197                         for (i = 0; i < nbits; i++) {
 198                                 *dest++ = (data & mask ? fg_color: bg_color);
 199                                 mask = mask >> 1;
 200                         }
 201                 }
 202         }
 203 }
 204
 205 /*
 206  * bit_to_pix24 is for 24-bit frame buffers.  It will write four output bytes
 207  * for each bit of input bitmap.  It inverts the input bits before
 208  * doing the output translation, for reverse video.  Note that each
 209  * 24-bit RGB value is finally stored in a 32-bit unsigned int, with the
 210  * high-order byte set to zero.
 211  *
 212  * Assuming foreground is 00000000 11111111 11111111 11111111
 213  * and background is 00000000 00000000 00000000 00000000
 214  * An input data byte of 0x53 will output the bit pattern
 215  *
 216  * 00000000 00000000 00000000 00000000
 217  * 00000000 11111111 11111111 11111111
 218  * 00000000 00000000 00000000 00000000
 219  * 00000000 11111111 11111111 11111111
 220  * 00000000 00000000 00000000 00000000
 221  * 00000000 00000000 00000000 00000000
 222  * 00000000 11111111 11111111 11111111
 223  * 00000000 11111111 11111111 11111111
 224  *
 225  */
 226
 227 void
 228 font_bit_to_pix24(
 229     struct font *f,
 230     uint32_t *dest,
 231     uint8_t c,
 232     uint32_t fg_color32,
 233     uint32_t bg_color32)
 234 {
 235         int     row;
 236         int     byte;
 237         int     i;
 238         uint8_t *cp;
 239         uint32_t data;
 240         int     bytes_wide;
 241         int     bitsleft, nbits;
 242
 243         cp = f->char_ptr[c];
 244         bytes_wide = (f->width + 7) / 8;
 245
 246         for (row = 0; row < f->height; row++) {
 247                 bitsleft = f->width;
 248                 for (byte = 0; byte < bytes_wide; byte++) {
 249                         data = *cp++;
 250                         nbits = MIN(8, bitsleft);
 251                         bitsleft -= nbits;
 252                         for (i = 0; i < nbits; i++) {
 253                                 *dest++ = ((data << i) & 0x80 ?
 254                                     fg_color32 : bg_color32);
 255                         }
 256                 }
 257         }
 258 }