1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 1999 Michael Smith <msmith@freebsd.org> 5 * Copyright (c) 1999 Kazutaka YOKOTA <yokota@freebsd.org> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD$ 30 */ 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/kernel.h> 35 #include <sys/module.h> 36 #include <sys/linker.h> 37 #include <sys/fbio.h> 38 39 #include <dev/fb/fbreg.h> 40 #include <dev/fb/splashreg.h> 41 #include <dev/fb/vgareg.h> 42 43 #include <isa/isareg.h> 44 45 #define FADE_TIMEOUT 15 /* sec */ 46 #define FADE_LEVELS 10 47 48 static int splash_mode = -1; 49 static int splash_on = FALSE; 50 51 static int bmp_start(video_adapter_t *adp); 52 static int bmp_end(video_adapter_t *adp); 53 static int bmp_splash(video_adapter_t *adp, int on); 54 static int bmp_Init(char *data, int swidth, int sheight, int sdepth); 55 static int bmp_Draw(video_adapter_t *adp); 56 57 static splash_decoder_t bmp_decoder = { 58 "splash_bmp", bmp_start, bmp_end, bmp_splash, SPLASH_IMAGE, 59 }; 60 61 SPLASH_DECODER(splash_bmp, bmp_decoder); 62 63 static int 64 bmp_start(video_adapter_t *adp) 65 { 66 /* currently only 256-color modes are supported XXX */ 67 static int modes[] = { 68 M_VESA_CG640x480, 69 M_VESA_CG800x600, 70 M_VESA_CG1024x768, 71 M_CG640x480, 72 /* 73 * As 320x200 doesn't generally look great, 74 * it's least preferred here. 75 */ 76 M_VGA_CG320, 77 -1, 78 }; 79 video_info_t info; 80 int i; 81 82 if ((bmp_decoder.data == NULL) || (bmp_decoder.data_size <= 0)) { 83 printf("splash_bmp: No bitmap file found\n"); 84 return ENODEV; 85 } 86 for (i = 0; modes[i] >= 0; ++i) { 87 if ((vidd_get_info(adp, modes[i], &info) == 0) && 88 (bmp_Init((u_char *)bmp_decoder.data, info.vi_width, 89 info.vi_height, info.vi_depth) == 0)) 90 break; 91 } 92 splash_mode = modes[i]; 93 if (splash_mode < 0) 94 printf("splash_bmp: No appropriate video mode found\n"); 95 if (bootverbose) 96 printf("bmp_start(): splash_mode:%d\n", splash_mode); 97 return ((splash_mode < 0) ? ENODEV : 0); 98 } 99 100 static int 101 bmp_end(video_adapter_t *adp) 102 { 103 /* nothing to do */ 104 return 0; 105 } 106 107 static int 108 bmp_splash(video_adapter_t *adp, int on) 109 { 110 static u_char pal[256*3]; 111 static long time_stamp; 112 u_char tpal[256*3]; 113 static int fading = TRUE, brightness = FADE_LEVELS; 114 struct timeval tv; 115 int i; 116 117 if (on) { 118 if (!splash_on) { 119 /* set up the video mode and draw something */ 120 if (vidd_set_mode(adp, splash_mode)) 121 return 1; 122 if (bmp_Draw(adp)) 123 return 1; 124 vidd_save_palette(adp, pal); 125 time_stamp = 0; 126 splash_on = TRUE; 127 } 128 /* 129 * This is a kludge to fade the image away. This section of the 130 * code takes effect only after the system is completely up. 131 * FADE_TIMEOUT should be configurable. 132 */ 133 if (!cold) { 134 getmicrotime(&tv); 135 if (time_stamp == 0) 136 time_stamp = tv.tv_sec; 137 if (tv.tv_sec > time_stamp + FADE_TIMEOUT) { 138 if (fading) 139 if (brightness == 0) { 140 fading = FALSE; 141 brightness++; 142 } 143 else brightness--; 144 else 145 if (brightness == FADE_LEVELS) { 146 fading = TRUE; 147 brightness--; 148 } 149 else brightness++; 150 for (i = 0; i < sizeof(pal); ++i) { 151 tpal[i] = pal[i] * brightness / FADE_LEVELS; 152 } 153 vidd_load_palette(adp, tpal); 154 time_stamp = tv.tv_sec; 155 } 156 } 157 return 0; 158 } else { 159 /* the video mode will be restored by the caller */ 160 splash_on = FALSE; 161 return 0; 162 } 163 } 164 165 /* 166 ** Code to handle Microsoft DIB (".BMP") format images. 167 ** 168 ** Blame me (msmith@freebsd.org) if this is broken, not Soren. 169 */ 170 171 typedef struct tagBITMAPFILEHEADER { /* bmfh */ 172 u_short bfType; 173 int bfSize; 174 u_short bfReserved1; 175 u_short bfReserved2; 176 int bfOffBits; 177 } __packed BITMAPFILEHEADER; 178 179 typedef struct tagBITMAPINFOHEADER { /* bmih */ 180 int biSize; 181 int biWidth; 182 int biHeight; 183 short biPlanes; 184 short biBitCount; 185 int biCompression; 186 int biSizeImage; 187 int biXPelsPerMeter; 188 int biYPelsPerMeter; 189 int biClrUsed; 190 int biClrImportant; 191 } __packed BITMAPINFOHEADER; 192 193 typedef struct tagRGBQUAD { /* rgbq */ 194 u_char rgbBlue; 195 u_char rgbGreen; 196 u_char rgbRed; 197 u_char rgbReserved; 198 } __packed RGBQUAD; 199 200 typedef struct tagBITMAPINFO { /* bmi */ 201 BITMAPINFOHEADER bmiHeader; 202 RGBQUAD bmiColors[256]; 203 } __packed BITMAPINFO; 204 205 typedef struct tagBITMAPF 206 { 207 BITMAPFILEHEADER bmfh; 208 BITMAPINFO bmfi; 209 } __packed BITMAPF; 210 211 #define BI_RGB 0 212 #define BI_RLE8 1 213 #define BI_RLE4 2 214 215 /* 216 ** all we actually care about the image 217 */ 218 typedef struct 219 { 220 int width,height; /* image dimensions */ 221 int swidth,sheight; /* screen dimensions for the current mode */ 222 u_char depth; /* image depth (1, 4, 8, 24 bits) */ 223 u_char sdepth; /* screen depth (1, 4, 8 bpp) */ 224 int ncols; /* number of colours */ 225 u_char palette[256][3]; /* raw palette data */ 226 u_char format; /* one of the BI_* constants above */ 227 u_char *data; /* pointer to the raw data */ 228 u_char *index; /* running pointer to the data while drawing */ 229 u_char *vidmem; /* video memory allocated for drawing */ 230 video_adapter_t *adp; 231 int bank; 232 } BMP_INFO; 233 234 static BMP_INFO bmp_info; 235 236 /* 237 ** bmp_SetPix 238 ** 239 ** Given (info), set the pixel at (x),(y) to (val) 240 ** 241 */ 242 static void 243 bmp_SetPix(BMP_INFO *info, int x, int y, u_char val) 244 { 245 int sofs, bofs; 246 int newbank; 247 248 /* 249 * range check to avoid explosions 250 */ 251 if ((x < 0) || (x >= info->swidth) || (y < 0) || (y >= info->sheight)) 252 return; 253 254 /* 255 * calculate offset into video memory; 256 * because 0,0 is bottom-left for DIB, we have to convert. 257 */ 258 sofs = ((info->height - (y+1) + (info->sheight - info->height) / 2) 259 * info->adp->va_line_width); 260 x += (info->swidth - info->width) / 2; 261 262 switch(info->sdepth) { 263 case 4: 264 case 1: 265 /* EGA/VGA planar modes */ 266 sofs += (x >> 3); 267 newbank = sofs/info->adp->va_window_size; 268 if (info->bank != newbank) { 269 vidd_set_win_org(info->adp, newbank*info->adp->va_window_size); 270 info->bank = newbank; 271 } 272 sofs %= info->adp->va_window_size; 273 bofs = x & 0x7; /* offset within byte */ 274 outw(GDCIDX, (0x8000 >> bofs) | 0x08); /* bit mask */ 275 outw(GDCIDX, (val << 8) | 0x00); /* set/reset */ 276 *(info->vidmem + sofs) ^= 0xff; /* read-modify-write */ 277 break; 278 279 case 8: 280 sofs += x; 281 newbank = sofs/info->adp->va_window_size; 282 if (info->bank != newbank) { 283 vidd_set_win_org(info->adp, newbank*info->adp->va_window_size); 284 info->bank = newbank; 285 } 286 sofs %= info->adp->va_window_size; 287 *(info->vidmem+sofs) = val; 288 break; 289 } 290 } 291 292 /* 293 ** bmp_DecodeRLE4 294 ** 295 ** Given (data) pointing to a line of RLE4-format data and (line) being the starting 296 ** line onscreen, decode the line. 297 */ 298 static void 299 bmp_DecodeRLE4(BMP_INFO *info, int line) 300 { 301 int count; /* run count */ 302 u_char val; 303 int x,y; /* screen position */ 304 305 x = 0; /* starting position */ 306 y = line; 307 308 /* loop reading data */ 309 for (;;) { 310 /* 311 * encoded mode starts with a run length, and then a byte with 312 * two colour indexes to alternate between for the run 313 */ 314 if (*info->index) { 315 for (count = 0; count < *info->index; count++, x++) { 316 if (count & 1) { /* odd count, low nybble */ 317 bmp_SetPix(info, x, y, *(info->index+1) & 0x0f); 318 } else { /* even count, high nybble */ 319 bmp_SetPix(info, x, y, (*(info->index+1) >>4) & 0x0f); 320 } 321 } 322 info->index += 2; 323 /* 324 * A leading zero is an escape; it may signal the end of the 325 * bitmap, a cursor move, or some absolute data. 326 */ 327 } else { /* zero tag may be absolute mode or an escape */ 328 switch (*(info->index+1)) { 329 case 0: /* end of line */ 330 info->index += 2; 331 return; 332 case 1: /* end of bitmap */ 333 info->index = NULL; 334 return; 335 case 2: /* move */ 336 x += *(info->index + 2); /* new coords */ 337 y += *(info->index + 3); 338 info->index += 4; 339 break; 340 default: /* literal bitmap data */ 341 for (count = 0; count < *(info->index + 1); count++, x++) { 342 val = *(info->index + 2 + (count / 2)); /* byte with nybbles */ 343 if (count & 1) { 344 val &= 0xf; /* get low nybble */ 345 } else { 346 val = (val >> 4); /* get high nybble */ 347 } 348 bmp_SetPix(info, x, y, val); 349 } 350 /* warning, this depends on integer truncation, do not hand-optimise! */ 351 info->index += 2 + ((count + 3) / 4) * 2; 352 break; 353 } 354 } 355 } 356 } 357 358 /* 359 ** bmp_DecodeRLE8 360 ** Given (data) pointing to a line of RLE8-format data and (line) being the starting 361 ** line onscreen, decode the line. 362 */ 363 static void 364 bmp_DecodeRLE8(BMP_INFO *info, int line) 365 { 366 int count; /* run count */ 367 int x,y; /* screen position */ 368 369 x = 0; /* starting position */ 370 y = line; 371 372 /* loop reading data */ 373 for(;;) { 374 /* 375 * encoded mode starts with a run length, and then a byte with 376 * two colour indexes to alternate between for the run 377 */ 378 if (*info->index) { 379 for (count = 0; count < *info->index; count++, x++) 380 bmp_SetPix(info, x, y, *(info->index+1)); 381 info->index += 2; 382 /* 383 * A leading zero is an escape; it may signal the end of the 384 * bitmap, a cursor move, or some absolute data. 385 */ 386 } else { /* zero tag may be absolute mode or an escape */ 387 switch(*(info->index+1)) { 388 case 0: /* end of line */ 389 info->index += 2; 390 return; 391 case 1: /* end of bitmap */ 392 info->index = NULL; 393 return; 394 case 2: /* move */ 395 x += *(info->index + 2); /* new coords */ 396 y += *(info->index + 3); 397 info->index += 4; 398 break; 399 default: /* literal bitmap data */ 400 for (count = 0; count < *(info->index + 1); count++, x++) 401 bmp_SetPix(info, x, y, *(info->index + 2 + count)); 402 /* must be an even count */ 403 info->index += 2 + count + (count & 1); 404 break; 405 } 406 } 407 } 408 } 409 410 /* 411 ** bmp_DecodeLine 412 ** 413 ** Given (info) pointing to an image being decoded, (line) being the line currently 414 ** being displayed, decode a line of data. 415 */ 416 static void 417 bmp_DecodeLine(BMP_INFO *info, int line) 418 { 419 int x; 420 u_char val, mask, *p; 421 422 switch(info->format) { 423 case BI_RGB: 424 switch(info->depth) { 425 case 8: 426 for (x = 0; x < info->width; x++, info->index++) 427 bmp_SetPix(info, x, line, *info->index); 428 info->index += 3 - (--x % 4); 429 break; 430 case 4: 431 p = info->index; 432 for (x = 0; x < info->width; x++) { 433 if (x & 1) { 434 val = *p & 0xf; /* get low nybble */ 435 p++; 436 } else { 437 val = *p >> 4; /* get high nybble */ 438 } 439 bmp_SetPix(info, x, line, val); 440 } 441 /* warning, this depends on integer truncation, do not hand-optimise! */ 442 info->index += ((x + 7) / 8) * 4; 443 break; 444 case 1: 445 p = info->index; 446 mask = 0x80; 447 for (x = 0; x < info->width; x++) { 448 val = (*p & mask) ? 1 : 0; 449 mask >>= 1; 450 if (mask == 0) { 451 mask = 0x80; 452 p++; 453 } 454 bmp_SetPix(info, x, line, val); 455 } 456 /* warning, this depends on integer truncation, do not hand-optimise! */ 457 info->index += ((x + 31) / 32) * 4; 458 break; 459 } 460 break; 461 case BI_RLE4: 462 bmp_DecodeRLE4(info, line); 463 break; 464 case BI_RLE8: 465 bmp_DecodeRLE8(info, line); 466 break; 467 } 468 } 469 470 /* 471 ** bmp_Init 472 ** 473 ** Given a pointer (data) to the image of a BMP file, fill in bmp_info with what 474 ** can be learnt from it. Return nonzero if the file isn't usable. 475 ** 476 ** Take screen dimensions (swidth), (sheight) and (sdepth) and make sure we 477 ** can work with these. 478 */ 479 static int 480 bmp_Init(char *data, int swidth, int sheight, int sdepth) 481 { 482 BITMAPF *bmf = (BITMAPF *)data; 483 int pind; 484 485 bmp_info.data = NULL; /* assume setup failed */ 486 487 /* check file ID */ 488 if (bmf->bmfh.bfType != 0x4d42) { 489 printf("splash_bmp: not a BMP file\n"); 490 return(1); /* XXX check word ordering for big-endian ports? */ 491 } 492 493 /* do we understand this bitmap format? */ 494 if (bmf->bmfi.bmiHeader.biSize > sizeof(bmf->bmfi.bmiHeader)) { 495 printf("splash_bmp: unsupported BMP format (size=%d)\n", 496 bmf->bmfi.bmiHeader.biSize); 497 return(1); 498 } 499 500 /* save what we know about the screen */ 501 bmp_info.swidth = swidth; 502 bmp_info.sheight = sheight; 503 bmp_info.sdepth = sdepth; 504 505 /* where's the data? */ 506 bmp_info.data = (u_char *)data + bmf->bmfh.bfOffBits; 507 508 /* image parameters */ 509 bmp_info.width = bmf->bmfi.bmiHeader.biWidth; 510 bmp_info.height = bmf->bmfi.bmiHeader.biHeight; 511 bmp_info.depth = bmf->bmfi.bmiHeader.biBitCount; 512 bmp_info.format = bmf->bmfi.bmiHeader.biCompression; 513 514 switch(bmp_info.format) { /* check compression format */ 515 case BI_RGB: 516 case BI_RLE4: 517 case BI_RLE8: 518 break; 519 default: 520 printf("splash_bmp: unsupported compression format\n"); 521 return(1); /* unsupported compression format */ 522 } 523 524 /* palette details */ 525 bmp_info.ncols = (bmf->bmfi.bmiHeader.biClrUsed); 526 bzero(bmp_info.palette,sizeof(bmp_info.palette)); 527 if (bmp_info.ncols == 0) { /* uses all of them */ 528 bmp_info.ncols = 1 << bmf->bmfi.bmiHeader.biBitCount; 529 } 530 if ((bmp_info.height > bmp_info.sheight) || 531 (bmp_info.width > bmp_info.swidth) || 532 (bmp_info.ncols > (1 << sdepth))) { 533 if (bootverbose) 534 printf("splash_bmp: beyond screen capacity (%dx%d, %d colors)\n", 535 bmp_info.width, bmp_info.height, bmp_info.ncols); 536 return(1); 537 } 538 539 /* read palette */ 540 for (pind = 0; pind < bmp_info.ncols; pind++) { 541 bmp_info.palette[pind][0] = bmf->bmfi.bmiColors[pind].rgbRed; 542 bmp_info.palette[pind][1] = bmf->bmfi.bmiColors[pind].rgbGreen; 543 bmp_info.palette[pind][2] = bmf->bmfi.bmiColors[pind].rgbBlue; 544 } 545 return(0); 546 } 547 548 /* 549 ** bmp_Draw 550 ** 551 ** Render the image. Return nonzero if that's not possible. 552 ** 553 */ 554 static int 555 bmp_Draw(video_adapter_t *adp) 556 { 557 int line; 558 #if 0 559 int i; 560 #endif 561 562 if (bmp_info.data == NULL) { /* init failed, do nothing */ 563 return(1); 564 } 565 566 /* clear the screen */ 567 bmp_info.vidmem = (u_char *)adp->va_window; 568 bmp_info.adp = adp; 569 vidd_clear(adp); 570 vidd_set_win_org(adp, 0); 571 bmp_info.bank = 0; 572 573 /* initialise the info structure for drawing */ 574 bmp_info.index = bmp_info.data; 575 576 /* set the palette for our image */ 577 vidd_load_palette(adp, (u_char *)&bmp_info.palette); 578 579 #if 0 580 /* XXX: this is ugly, but necessary for EGA/VGA 1bpp/4bpp modes */ 581 if ((adp->va_type == KD_EGA) || (adp->va_type == KD_VGA)) { 582 inb(adp->va_crtc_addr + 6); /* reset flip-flop */ 583 outb(ATC, 0x14); 584 outb(ATC, 0); 585 for (i = 0; i < 16; ++i) { 586 outb(ATC, i); 587 outb(ATC, i); 588 } 589 inb(adp->va_crtc_addr + 6); /* reset flip-flop */ 590 outb(ATC, 0x20); /* enable palette */ 591 592 outw(GDCIDX, 0x0f01); /* set/reset enable */ 593 594 if (bmp_info.sdepth == 1) 595 outw(TSIDX, 0x0102); /* unmask plane #0 */ 596 } 597 #endif 598 599 for (line = 0; (line < bmp_info.height) && bmp_info.index; line++) { 600 bmp_DecodeLine(&bmp_info, line); 601 } 602 return(0); 603 } 604