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