core/graphics.c

   1 /*
   2  * -----------------------------------------------------------------------
   3  *
   4  *   Copyright 1994-2008 H. Peter Anvin - All Rights Reserved
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
   9  *   Boston MA 02111-1307, USA; either version 2 of the License, or
  10  *   (at your option) any later version; incorporated herein by reference.
  11  *
  12  * -----------------------------------------------------------------------
  13  *
  14  * -----------------------------------------------------------------------
  15  *  VGA splash screen code
  16  * -----------------------------------------------------------------------
  17  */
  18
  19 #include <stddef.h>
  20 #include "core.h"
  21 #include <sys/io.h>
  22 #include <hw/vga.h>
  23 #include "fs.h"
  24 #include "bios.h"
  25
  26 uint8_t UsingVGA = 0;
  27 uint16_t VGAPos;                /* Pointer into VGA memory */
  28 uint16_t *VGAFilePtr;           /* Pointer into VGAFileBuf */
  29
  30 char VGAFileBuf[VGA_FILE_BUF_SIZE]; /* Unmangled VGA image name */
  31 char VGAFileMBuf[FILENAME_MAX]; /* Mangled VGA image name */
  32
  33 static uint8_t VGARowBuffer[640 + 80];  /* Decompression buffer */
  34 static uint8_t VGAPlaneBuffer[(640/8) * 4]; /* Plane buffers */
  35
  36 extern uint16_t GXPixCols;
  37 extern uint16_t GXPixRows;
  38
  39 /* Maps colors to consecutive DAC registers */
  40 static uint8_t linear_color[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8,
  41                                   9, 10, 11, 12, 13, 14, 15, 0 };
  42
  43 static FILE *fd;
  44
  45 typedef struct {
  46         uint32_t LSSMagic;      /* Magic number */
  47         uint16_t GraphXSize;    /* Width of splash screen file */
  48         uint16_t GraphYSize;    /* Height of splash screen file */
  49         uint8_t GraphColorMap[3*16];
  50 } lssheader_t;
  51
  52 static lssheader_t LSSHeader;
  53
  54 #define LSSMagic        LSSHeader.LSSMagic
  55 #define GraphXSize      LSSHeader.GraphXSize
  56 #define GraphYSize      LSSHeader.GraphYSize
  57
  58 /*
  59  * Enable VGA graphics, if possible. Return 0 on success.
  60  */
  61 static int vgasetmode(void)
  62 {
  63         com32sys_t ireg, oreg;
  64
  65         if (UsingVGA)
  66                 return 0;               /* Nothing to do... */
  67
  68         memset(&ireg, 0, sizeof(ireg));
  69         memset(&oreg, 0, sizeof(oreg));
  70
  71         if (UsingVGA & 0x4) {
  72                 /*
  73                  * We're in VESA mode, which means VGA; use VESA call
  74                  * to revert the mode, and then call the conventional
  75                  * mode-setting for good measure...
  76                  */
  77                 ireg.eax.w[0] = 0x4F02;
  78                 ireg.ebx.w[0] = 0x0012;
  79                 __intcall(0x10, &ireg, &oreg);
  80         } else {
  81                 /* Get video card and monitor */
  82                 ireg.eax.w[0] = 0x1A00;
  83                 __intcall(0x10, &ireg, &oreg);
  84                 oreg.ebx.b[0] -= 7; /* BL=07h and BL=08h OK */
  85
  86                 if (oreg.ebx.b[0] > 1)
  87                         return -1;
  88         }
  89
  90         /*
  91          * Set mode.
  92          */
  93         ireg.eax.w[0] = 0x0012; /* Set mode = 640x480 VGA 16 colors */
  94         __intcall(0x10, &ireg, &oreg);
  95
  96         ireg.edx.w[0] = (uint32_t)linear_color;
  97         ireg.eax.w[0] = 0x1002; /* Write color registers */
  98         __intcall(0x10, &ireg, &oreg);
  99
 100         UsingVGA = 1;
 101
 102         /* Set GXPixCols and GXPixRows */
 103         GXPixCols = 640;
 104         GXPixRows = 480;
 105
 106         use_font();
 107         ScrollAttribute = 0;
 108
 109         return 0;
 110 }
 111
 112 static inline char getnybble(void)
 113 {
 114         char data = getc(fd);
 115
 116         if (data & 0x10) {
 117                 data &= 0x0F;
 118                 return data;
 119         }
 120
 121         data = getc(fd);
 122         return (data & 0x0F);
 123 }
 124
 125 /*
 126  * rledecode:
 127  *      Decode a pixel row in RLE16 format.
 128  *
 129  * 'in': input (RLE16 encoded) buffer
 130  * 'out': output (decoded) buffer
 131  * 'count': pixel count
 132  */
 133 static void rledecode(uint8_t *out, size_t count)
 134 {
 135         uint8_t prev_pixel = 0;
 136         size_t size = count;
 137         uint8_t data;
 138         int i;
 139
 140 again:
 141         for (i = 0; i < size; i++) {
 142
 143                 data = getnybble();
 144                 if (data == prev_pixel)
 145                         break;
 146
 147                 *out++ = data;
 148                 prev_pixel = data;
 149         }
 150
 151         size -= i;
 152         if (!size)
 153                 return;
 154
 155         /* Start of run sequence */
 156         data = getnybble();
 157         if (data == 0) {
 158                 /* long run */
 159                 uint8_t hi;
 160
 161                 data = getnybble();
 162                 hi = getnybble();
 163                 hi <<= 4;
 164                 data |= hi;
 165                 data += 16;
 166         }
 167
 168         /* dorun */
 169         for (i = 0; i < data; i++)
 170                 *out++ = prev_pixel;
 171
 172         size -= i;
 173         if (size)
 174                 goto again;
 175 }
 176
 177 /*
 178  * packedpixel2vga:
 179  *      Convert packed-pixel to VGA bitplanes
 180  *
 181  * 'in': packed pixel string (640 pixels)
 182  * 'out': output (four planes @ 640/8 = 80 bytes)
 183  * 'count': pixel count (multiple of 8)
 184  */
 185 static void packedpixel2vga(const uint8_t *in, uint8_t *out)
 186 {
 187         int i, j, k;
 188
 189         for (i = 0; i < 4; i++) {
 190                 const uint8_t *ip = in;
 191
 192                 for (j = 0; j < 640/8; j++) {
 193                         uint8_t ob = 0;
 194
 195                         for (k = 0; k < 8; k++) {
 196                                 uint8_t px = *ip++;
 197                                 ob = (ob << 1) | ((px >> i) & 1);
 198                         }
 199
 200                         *out++ = ob;
 201                 }
 202         }
 203 }
 204
 205 /*
 206  * outputvga:
 207  *      Output four subsequent lines of VGA data
 208  *
 209  * 'in': four planes @ 640/8=80 bytes
 210  * 'out': pointer into VGA memory
 211  */
 212 static void outputvga(const void *in, void *out)
 213 {
 214         int i;
 215
 216         /* Select the sequencer mask */
 217         outb(VGA_SEQ_IX_MAP_MASK, VGA_SEQ_ADDR);
 218
 219         for (i = 1; i <= 8; i <<= 1) {
 220                 /* Select the bit plane to write */
 221                 outb(i, VGA_SEQ_DATA);
 222                 memcpy(out, in, 640/8);
 223                 in = (const char *)in + 640/8;
 224         }
 225 }
 226
 227 /*
 228  * Display a graphical splash screen.
 229  */
 230 void vgadisplayfile(FILE *_fd)
 231 {
 232         char *p;
 233         int size;
 234
 235         fd = _fd;
 236
 237         /*
 238          * This is a cheap and easy way to make sure the screen is
 239          * cleared in case we were in graphics mode aready.
 240          */
 241         vgaclearmode();
 242         vgasetmode();
 243
 244         size = 4+2*2+16*3;
 245         p = (char *)&LSSHeader;
 246
 247         /* Load the header */
 248         while (size--)
 249                 *p = getc(fd);
 250
 251         if (*p != EOF) {
 252                 com32sys_t ireg, oreg;
 253                 uint16_t rows;
 254                 int i;
 255
 256                 /* The header WILL be in the first chunk. */
 257                 if (LSSMagic != 0x1413f33d)
 258                         return;
 259
 260                 memset(&ireg, 0, sizeof(ireg));
 261
 262                 /* Color map offset */
 263                 ireg.edx.w[0] = offsetof(lssheader_t, GraphColorMap);
 264
 265                 ireg.eax.w[0] = 0x1012;        /* Set RGB registers */
 266                 ireg.ebx.w[0] = 0;             /* First register number */
 267                 ireg.ecx.w[0] = 16;            /* 16 registers */
 268                 __intcall(0x10, &ireg, &oreg);
 269
 270                 /* Number of pixel rows */
 271                 rows = (GraphYSize + VGAFontSize) - 1;
 272                 rows = rows / VGAFontSize;
 273                 if (rows >= VidRows)
 274                         rows = VidRows - 1;
 275
 276                 memset(&ireg, 0, sizeof(ireg));
 277
 278                 ireg.edx.b[1] = rows;
 279                 ireg.eax.b[1] = 2;
 280                 ireg.ebx.w[0] = 0;
 281
 282                 /* Set cursor below image */
 283                 __intcall(0x10, &ireg, &oreg);
 284
 285                 rows = GraphYSize; /* Number of graphics rows */
 286                 VGAPos = 0;
 287
 288                 for (i = 0; i < rows; i++) {
 289                         /* Pre-clear the row buffer */
 290                         memset(VGARowBuffer, 0, 640);
 291
 292                         /* Decode one row */
 293                         rledecode(VGARowBuffer, GraphXSize);
 294
 295                         packedpixel2vga(VGARowBuffer, VGAPlaneBuffer);
 296                         outputvga(VGAPlaneBuffer, MK_PTR(0xA000, VGAPos));
 297                         VGAPos += 640/8;
 298                 }
 299         }
 300 }
 301
 302 /*
 303  * Disable VGA graphics.
 304  */
 305 void vgaclearmode(void)
 306 {
 307         com32sys_t ireg, oreg;
 308
 309         /* Already in text mode? */
 310         if (!UsingVGA)
 311                 return;
 312
 313         if (UsingVGA & 0x4) {
 314                 /* VESA return to normal video mode */
 315                 memset(&ireg, 0, sizeof(ireg));
 316
 317                 ireg.eax.w[0] = 0x4F02; /* Set SuperVGA video mode */
 318                 ireg.ebx.w[0] = 0x0003;
 319                 __intcall(0x10, &ireg, &oreg);
 320         }
 321
 322         /* Return to normal video mode */
 323         memset(&ireg, 0, sizeof(ireg));
 324         ireg.eax.w[0] = 0x0003;
 325         __intcall(0x10, &ireg, &oreg);
 326
 327         UsingVGA = 0;
 328
 329         ScrollAttribute = 0x7;
 330         /* Restore text font/data */
 331         use_font();
 332 }
 333
 334 static void vgacursorcommon(char data)
 335 {
 336         if (UsingVGA) {
 337                 com32sys_t ireg;
 338
 339                 ireg.eax.b[0] = data;
 340                 ireg.eax.b[1] = 0x09;
 341                 ireg.ebx.w[0] = 0x0007;
 342                 ireg.ecx.w[0] = 1;
 343                 __intcall(0x10, &ireg, NULL);
 344         }
 345 }
 346
 347 void vgahidecursor(void)
 348 {
 349         vgacursorcommon(' ');
 350 }
 351
 352 void vgashowcursor(void)
 353 {
 354         vgacursorcommon('_');
 355 }
 356
 357 void using_vga(uint8_t vga, uint16_t pix_cols, uint16_t pix_rows)
 358 {
 359     UsingVGA = vga;
 360     GXPixCols = pix_cols;
 361     GXPixRows = pix_rows;
 362
 363     if (!(UsingVGA & 0x08))
 364         adjust_screen();
 365 }
 366
 367 void pm_using_vga(com32sys_t *regs)
 368 {
 369     using_vga(regs->eax.b[0], regs->ecx.w[0], regs->edx.w[0]);
 370 }