15 Jun
2007
15 Jun
'07
10:58 a.m.
Author: fireball
Date: Fri Jun 15 14:58:37 2007
New Revision: 27186
URL: http://svn.reactos.org/svn/reactos?rev=27186&view=rev
Log:
- Resurrect "old" bootvid. The plan is to
* make it working in trunk
* add framebuffer support for olpc and xbox kind of devices.
Added:
branches/olpc/drivers/base/bootvid/bar.bmp
- copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/bar.bmp
branches/olpc/drivers/base/bootvid/bootimage.bmp
- copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/bootimage.bmp
branches/olpc/drivers/base/bootvid/bootvid.h
- copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/bootvid.h
branches/olpc/drivers/base/bootvid/resource.h
- copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/resource.h
branches/olpc/drivers/base/bootvid/vid.c
- copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/vid.c
branches/olpc/drivers/base/bootvid/vid_vga.c
- copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/vid_vga.c
branches/olpc/drivers/base/bootvid/vid_vgatext.c
- copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/vid_vgatext.c
branches/olpc/drivers/base/bootvid/vid_xbox.c
- copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/vid_xbox.c
Removed:
branches/olpc/drivers/base/bootvid/bootdata.c
branches/olpc/drivers/base/bootvid/precomp.h
branches/olpc/drivers/base/bootvid/vga.c
Modified:
branches/olpc/drivers/base/bootvid/bootvid.c (contents, props changed)
branches/olpc/drivers/base/bootvid/bootvid.def (contents, props changed)
branches/olpc/drivers/base/bootvid/bootvid.rbuild (contents, props changed)
branches/olpc/drivers/base/bootvid/bootvid.rc (contents, props changed)
Removed: branches/olpc/drivers/base/bootvid/bootdata.c
URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootd…
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootdata.c (original)
+++ branches/olpc/drivers/base/bootvid/bootdata.c (removed)
@@ -1,309 +1,0 @@
-#include "precomp.h"
-
-USHORT AT_Initialization[] =
-{
- 0x10 | CMD_STREAM_READ, // Major Command = 0x10. Minor Command = 0x08.
- 0x3DA, // Index Status 1 Register Port Address
-
- //
- // This Stream performs a USHORT Array Indexed Write at port 0x3C0
- //
- 0x20 | 0x01, // Major Command = 0x20. Minor Command = 0x01.
- 0x3C0, // Attribute Controller Data Register
- 0x10, // Loop Count = 16 (Number of Pallette Entries)
- 0x0, // Index to select (Index = 0, palettes)
- 0x00, // Palette 0
- 0x01, // Palette 1
- 0x02, // Palette 2
- 0x03, // Palette 3
- 0x04, // Palette 4
- 0x05, // Palette 5
- 0x06, // Palette 6
- 0x07, // Palette 7
- 0x08, // Palette 8
- 0x09, // Palette 9
- 0x0A, // Palette 10
- 0x0B, // Palette 11
- 0x0C, // Palette 12
- 0x0D, // Palette 13
- 0x0E, // Palette 14
- 0x0F, // Palette 15
-
- //
- // This Stream performs a UCHAR READ of port 0x3DA
- //
- 0x10 | CMD_STREAM_READ, // Major Command = 0x10. Minor Command = 0x08.
- 0x3DA, // Index Status 1 Register Port Address
-
- //
- // This Stream performs a UCHAR WRITE of value 0x20 at port 0x3C0
- //
- 0x10 | CMD_STREAM_WRITE, // Major Command = 0x10. Minor Command = 0x00.
- 0x3C0, // Attribute Controller Data Register
- 0x20, // Set Palette Address Source
-
- //
- // End of Stream Marker
- //
- 0x0 // End of command stream
-};
-
-UCHAR FontData[256 * 13] =
-{
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 0
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 13
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 26
- 0x18, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 39
- 0x14, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 52
- 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 65
- 0x24, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 78
- 0x10, 0x28, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 91
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, // 104
- 0x14, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 117
- 0x28, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 130
- 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 143
- 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 156
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, // 169
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 182
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 195
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 208
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 221
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 234
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 247
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 260
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 273
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 286
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 299
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 312
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 325
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 338
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 351
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 364
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 377
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 390
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 403
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 416
- 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // 429
- 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 442
- 0x00, 0x14, 0x14, 0x14, 0x7F, 0x28, 0xFE, 0x50, 0x50, 0x50, 0x00, 0x00, 0x00, // 455
- 0x10, 0x3C, 0x50, 0x50, 0x70, 0x38, 0x1C, 0x14, 0x14, 0x78, 0x10, 0x00, 0x00, // 468
- 0x00, 0x61, 0x92, 0x94, 0x68, 0x18, 0x16, 0x29, 0x49, 0x86, 0x00, 0x00, 0x00, // 481
- 0x00, 0x18, 0x24, 0x24, 0x38, 0x71, 0x89, 0x8E, 0xC6, 0x7E, 0x00, 0x00, 0x00, // 494
- 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 507
- 0x06, 0x08, 0x10, 0x30, 0x20, 0x20, 0x20, 0x20, 0x30, 0x10, 0x08, 0x06, 0x00, // 520
- 0x60, 0x10, 0x08, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x10, 0x60, 0x00, // 533
- 0x00, 0x10, 0x52, 0x24, 0x3C, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 546
- 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, // 559
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x10, 0x20, 0x00, // 572
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 585
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, // 598
- 0x01, 0x02, 0x02, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x40, 0x40, 0x80, 0x00, // 611
- 0x00, 0x18, 0x24, 0x42, 0x42, 0x42, 0x42, 0x42, 0x24, 0x3C, 0x00, 0x00, 0x00, // 624
- 0x00, 0x30, 0xD0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFE, 0x00, 0x00, 0x00, // 637
- 0x00, 0x78, 0x04, 0x04, 0x04, 0x08, 0x10, 0x20, 0x40, 0x7C, 0x00, 0x00, 0x00, // 650
- 0x00, 0x78, 0x04, 0x04, 0x08, 0x30, 0x0C, 0x04, 0x04, 0x78, 0x00, 0x00, 0x00, // 663
- 0x00, 0x08, 0x18, 0x28, 0x28, 0x48, 0x88, 0xFC, 0x08, 0x08, 0x00, 0x00, 0x00, // 676
- 0x00, 0x3C, 0x20, 0x20, 0x38, 0x04, 0x04, 0x04, 0x04, 0x38, 0x00, 0x00, 0x00, // 689
- 0x00, 0x1C, 0x20, 0x40, 0x5C, 0x62, 0x42, 0x42, 0x22, 0x1C, 0x00, 0x00, 0x00, // 702
- 0x00, 0x7E, 0x02, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0x00, 0x00, 0x00, // 715
- 0x00, 0x3C, 0x42, 0x42, 0x24, 0x3C, 0x46, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 728
- 0x00, 0x38, 0x44, 0x42, 0x42, 0x46, 0x3A, 0x02, 0x04, 0x38, 0x00, 0x00, 0x00, // 741
- 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, // 754
- 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, 0x30, 0x30, 0x10, 0x20, 0x00, // 767
- 0x00, 0x00, 0x00, 0x02, 0x0C, 0x10, 0x60, 0x10, 0x0C, 0x02, 0x00, 0x00, 0x00, // 780
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, // 793
- 0x00, 0x00, 0x00, 0x40, 0x30, 0x08, 0x06, 0x08, 0x30, 0x40, 0x00, 0x00, 0x00, // 806
- 0x00, 0x7C, 0x42, 0x02, 0x04, 0x08, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // 819
- 0x00, 0x3C, 0x62, 0xDE, 0xB2, 0xA2, 0xA6, 0x9B, 0x44, 0x3C, 0x00, 0x00, 0x00, // 832
- 0x00, 0x00, 0x18, 0x18, 0x24, 0x24, 0x24, 0x7E, 0x42, 0x81, 0x00, 0x00, 0x00, // 845
- 0x00, 0x00, 0x7C, 0x42, 0x42, 0x7C, 0x42, 0x42, 0x42, 0x7C, 0x00, 0x00, 0x00, // 858
- 0x00, 0x00, 0x3E, 0x40, 0x80, 0x80, 0x80, 0x80, 0x40, 0x3E, 0x00, 0x00, 0x00, // 871
- 0x00, 0x00, 0x78, 0x44, 0x42, 0x42, 0x42, 0x42, 0x44, 0x78, 0x00, 0x00, 0x00, // 884
- 0x00, 0x00, 0x7E, 0x40, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x7E, 0x00, 0x00, 0x00, // 897
- 0x00, 0x00, 0x7E, 0x40, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, // 910
- 0x00, 0x00, 0x3E, 0x40, 0x80, 0x80, 0x8E, 0x82, 0x42, 0x3E, 0x00, 0x00, 0x00, // 923
- 0x00, 0x00, 0x42, 0x42, 0x42, 0x7E, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, // 936
- 0x00, 0x00, 0x7C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7C, 0x00, 0x00, 0x00, // 949
- 0x00, 0x00, 0x3C, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x78, 0x00, 0x00, 0x00, // 962
- 0x00, 0x00, 0x42, 0x44, 0x48, 0x70, 0x50, 0x48, 0x44, 0x42, 0x00, 0x00, 0x00, // 975
- 0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7E, 0x00, 0x00, 0x00, // 988
- 0x00, 0x00, 0xC6, 0xC6, 0xAA, 0xAA, 0xAA, 0x92, 0x82, 0x82, 0x00, 0x00, 0x00, //
1001
- 0x00, 0x00, 0x42, 0x62, 0x52, 0x52, 0x4A, 0x4A, 0x46, 0x42, 0x00, 0x00, 0x00, //
1014
- 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x44, 0x38, 0x00, 0x00, 0x00, //
1027
- 0x00, 0x00, 0x7C, 0x42, 0x42, 0x42, 0x7C, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, //
1040
- 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x44, 0x38, 0x06, 0x03, 0x00, //
1053
- 0x00, 0x00, 0x78, 0x44, 0x44, 0x44, 0x78, 0x48, 0x44, 0x42, 0x00, 0x00, 0x00, //
1066
- 0x00, 0x00, 0x3E, 0x40, 0x40, 0x38, 0x04, 0x02, 0x02, 0x7C, 0x00, 0x00, 0x00, //
1079
- 0x00, 0x00, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, //
1092
- 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, //
1105
- 0x00, 0x00, 0x81, 0x42, 0x42, 0x44, 0x24, 0x28, 0x38, 0x10, 0x00, 0x00, 0x00, //
1118
- 0x00, 0x00, 0x81, 0x81, 0x92, 0x5A, 0x5A, 0x6A, 0x66, 0x24, 0x00, 0x00, 0x00, //
1131
- 0x00, 0x00, 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81, 0x00, 0x00, 0x00, //
1144
- 0x00, 0x00, 0x82, 0x44, 0x28, 0x28, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, //
1157
- 0x00, 0x00, 0xFE, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0xFE, 0x00, 0x00, 0x00, //
1170
- 0x1E, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1E, 0x00, //
1183
- 0x80, 0x40, 0x40, 0x20, 0x10, 0x10, 0x08, 0x08, 0x04, 0x02, 0x02, 0x01, 0x00, //
1196
- 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x78, 0x00, //
1209
- 0x00, 0x08, 0x08, 0x18, 0x14, 0x24, 0x24, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, //
1222
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, //
1235
- 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
1248
- 0x00, 0x00, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, //
1261
- 0x40, 0x40, 0x40, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x62, 0x5C, 0x00, 0x00, 0x00, //
1274
- 0x00, 0x00, 0x00, 0x1E, 0x20, 0x40, 0x40, 0x40, 0x20, 0x1E, 0x00, 0x00, 0x00, //
1287
- 0x02, 0x02, 0x02, 0x3A, 0x46, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, //
1300
- 0x00, 0x00, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, //
1313
- 0x1E, 0x20, 0x20, 0xFE, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, //
1326
- 0x00, 0x00, 0x00, 0x3A, 0x46, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x02, 0x02, 0x3C, //
1339
- 0x40, 0x40, 0x40, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, //
1352
- 0x18, 0x18, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, //
1365
- 0x18, 0x18, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x70, //
1378
- 0x40, 0x40, 0x40, 0x44, 0x48, 0x50, 0x60, 0x50, 0x48, 0x44, 0x00, 0x00, 0x00, //
1391
- 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, //
1404
- 0x00, 0x00, 0x00, 0xB6, 0xDA, 0x92, 0x92, 0x92, 0x92, 0x92, 0x00, 0x00, 0x00, //
1417
- 0x00, 0x00, 0x00, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, //
1430
- 0x00, 0x00, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, //
1443
- 0x00, 0x00, 0x00, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x62, 0x5C, 0x40, 0x40, 0x40, //
1456
- 0x00, 0x00, 0x00, 0x3A, 0x46, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x02, 0x02, 0x02, //
1469
- 0x00, 0x00, 0x00, 0x5C, 0x64, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, //
1482
- 0x00, 0x00, 0x00, 0x3C, 0x40, 0x60, 0x18, 0x04, 0x04, 0x78, 0x00, 0x00, 0x00, //
1495
- 0x00, 0x00, 0x20, 0xFC, 0x20, 0x20, 0x20, 0x20, 0x20, 0x1C, 0x00, 0x00, 0x00, //
1508
- 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, //
1521
- 0x00, 0x00, 0x00, 0x82, 0x44, 0x44, 0x44, 0x28, 0x28, 0x10, 0x00, 0x00, 0x00, //
1534
- 0x00, 0x00, 0x00, 0x81, 0x91, 0x5A, 0x5A, 0x6A, 0x24, 0x24, 0x00, 0x00, 0x00, //
1547
- 0x00, 0x00, 0x00, 0x42, 0x24, 0x18, 0x18, 0x18, 0x24, 0x42, 0x00, 0x00, 0x00, //
1560
- 0x00, 0x00, 0x00, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18, 0x10, 0x30, 0xE0, //
1573
- 0x00, 0x00, 0x00, 0x7E, 0x02, 0x04, 0x08, 0x10, 0x20, 0x7E, 0x00, 0x00, 0x00, //
1586
- 0x1C, 0x10, 0x10, 0x10, 0x10, 0x60, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0C, 0x00, //
1599
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, //
1612
- 0x30, 0x08, 0x08, 0x08, 0x08, 0x06, 0x08, 0x08, 0x08, 0x08, 0x08, 0x30, 0x00, //
1625
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x8E, 0x00, 0x00, 0x00, 0x00, 0x00, //
1638
- 0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, //
1651
- 0x00, 0x00, 0x3E, 0x40, 0x80, 0x80, 0x80, 0x80, 0x40, 0x3E, 0x04, 0x02, 0x06, //
1664
- 0x00, 0x24, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, //
1677
- 0x08, 0x10, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, //
1690
- 0x18, 0x24, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, //
1703
- 0x00, 0x24, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, //
1716
- 0x10, 0x08, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, //
1729
- 0x10, 0x28, 0x10, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, //
1742
- 0x00, 0x00, 0x00, 0x1E, 0x20, 0x40, 0x40, 0x40, 0x20, 0x1E, 0x08, 0x04, 0x0C, //
1755
- 0x18, 0x24, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, //
1768
- 0x00, 0x12, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, //
1781
- 0x10, 0x08, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, //
1794
- 0x00, 0x24, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, //
1807
- 0x18, 0x24, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, //
1820
- 0x10, 0x08, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, //
1833
- 0x24, 0x00, 0x18, 0x18, 0x24, 0x24, 0x24, 0x7E, 0x42, 0x81, 0x00, 0x00, 0x00, //
1846
- 0x10, 0x28, 0x10, 0x28, 0x28, 0x24, 0x44, 0x7E, 0x42, 0x81, 0x00, 0x00, 0x00, //
1859
- 0x08, 0x10, 0x7E, 0x40, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x7E, 0x00, 0x00, 0x00, //
1872
- 0x00, 0x00, 0x00, 0xFC, 0x12, 0x12, 0x7E, 0x90, 0x90, 0x6E, 0x00, 0x00, 0x00, //
1885
- 0x00, 0x00, 0x0F, 0x18, 0x18, 0x28, 0x2E, 0x78, 0x48, 0x8F, 0x00, 0x00, 0x00, //
1898
- 0x18, 0x24, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, //
1911
- 0x00, 0x24, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, //
1924
- 0x20, 0x10, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, //
1937
- 0x18, 0x24, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, //
1950
- 0x20, 0x10, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, //
1963
- 0x00, 0x24, 0x00, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18, 0x10, 0x30, 0xE0, //
1976
- 0x24, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x44, 0x38, 0x00, 0x00, 0x00, //
1989
- 0x24, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, //
2002
- 0x00, 0x08, 0x1C, 0x28, 0x48, 0x48, 0x48, 0x68, 0x1C, 0x08, 0x00, 0x00, 0x00, //
2015
- 0x00, 0x0E, 0x10, 0x10, 0x10, 0x38, 0x10, 0x10, 0x20, 0x3E, 0x00, 0x00, 0x00, //
2028
- 0x00, 0x81, 0x42, 0x24, 0x18, 0x7C, 0x10, 0x7C, 0x10, 0x10, 0x00, 0x00, 0x00, //
2041
- 0x00, 0xE0, 0x90, 0x90, 0xE0, 0x96, 0xBC, 0x94, 0x92, 0x9E, 0x00, 0x00, 0x00, //
2054
- 0x0E, 0x10, 0x10, 0x3C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xE0, //
2067
- 0x08, 0x10, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, //
2080
- 0x08, 0x10, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, //
2093
- 0x08, 0x10, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, //
2106
- 0x08, 0x10, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, //
2119
- 0x14, 0x28, 0x00, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, //
2132
- 0x14, 0x28, 0x42, 0x62, 0x52, 0x52, 0x4A, 0x4A, 0x46, 0x42, 0x00, 0x00, 0x00, //
2145
- 0x00, 0x78, 0x08, 0x38, 0x48, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2158
- 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2171
- 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x10, 0x20, 0x40, 0x42, 0x3E, 0x00, //
2184
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, //
2197
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, //
2210
- 0x00, 0xC4, 0x48, 0x48, 0x50, 0x37, 0x21, 0x43, 0x44, 0x87, 0x00, 0x00, 0x00, //
2223
- 0x00, 0xC4, 0x48, 0x48, 0x50, 0x22, 0x26, 0x4A, 0x4F, 0x82, 0x00, 0x00, 0x00, //
2236
- 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, //
2249
- 0x00, 0x00, 0x00, 0x00, 0x12, 0x24, 0x48, 0x24, 0x12, 0x00, 0x00, 0x00, 0x00, //
2262
- 0x00, 0x00, 0x00, 0x00, 0x48, 0x24, 0x12, 0x24, 0x48, 0x00, 0x00, 0x00, 0x00, //
2275
- 0x94, 0x00, 0x00, 0x94, 0x00, 0x94, 0x00, 0x00, 0x94, 0x00, 0x94, 0x00, 0x00, //
2288
- 0x49, 0x94, 0x00, 0x49, 0x94, 0x49, 0x00, 0x94, 0x49, 0x94, 0x49, 0x00, 0x94, //
2301
- 0xFF, 0x94, 0x94, 0xFF, 0x94, 0xFF, 0x94, 0x94, 0xFF, 0x94, 0xFF, 0x94, 0x94, //
2314
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, //
2327
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, //
2340
- 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, //
2353
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xF4, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, //
2366
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, //
2379
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, //
2392
- 0x14, 0x14, 0x14, 0x14, 0x14, 0xF4, 0x04, 0xF4, 0x14, 0x14, 0x14, 0x14, 0x14, //
2405
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, //
2418
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x04, 0xF4, 0x14, 0x14, 0x14, 0x14, 0x14, //
2431
- 0x14, 0x14, 0x14, 0x14, 0x14, 0xF4, 0x04, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, //
2444
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2457
- 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, //
2470
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, //
2483
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2496
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2509
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, //
2522
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, //
2535
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2548
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, //
2561
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x10, //
2574
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x17, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, //
2587
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x17, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, //
2600
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x17, 0x14, 0x14, 0x14, 0x14, 0x14, //
2613
- 0x14, 0x14, 0x14, 0x14, 0x14, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, //
2626
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xF7, 0x14, 0x14, 0x14, 0x14, 0x14, //
2639
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x17, 0x10, 0x17, 0x14, 0x14, 0x14, 0x14, 0x14, //
2652
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, //
2665
- 0x14, 0x14, 0x14, 0x14, 0x14, 0xF7, 0x00, 0xF7, 0x14, 0x14, 0x14, 0x14, 0x14, //
2678
- 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, //
2691
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2704
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, //
2717
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, //
2730
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2743
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, //
2756
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x10, //
2769
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, //
2782
- 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xFF, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, //
2795
- 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, //
2808
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2821
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, //
2834
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //
2847
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //
2860
- 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, //
2873
- 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, //
2886
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
2899
- 0x00, 0x00, 0x00, 0x31, 0x49, 0x86, 0x84, 0x84, 0x8A, 0x71, 0x00, 0x00, 0x00, //
2912
- 0x38, 0x48, 0x48, 0x50, 0x50, 0x58, 0x44, 0x42, 0x42, 0x5C, 0x00, 0x00, 0x00, //
2925
- 0x00, 0x00, 0x3F, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, //
2938
- 0x00, 0x00, 0x00, 0x7F, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, //
2951
- 0x00, 0x00, 0xFF, 0x40, 0x20, 0x10, 0x10, 0x20, 0x40, 0xFF, 0x00, 0x00, 0x00, //
2964
- 0x00, 0x00, 0x00, 0x7F, 0x84, 0x84, 0x84, 0x84, 0x84, 0x78, 0x00, 0x00, 0x00, //
2977
- 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x66, 0x5A, 0x40, 0x40, 0x40, //
2990
- 0x00, 0x00, 0x00, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, //
3003
- 0x00, 0x00, 0x10, 0x7C, 0x92, 0x92, 0x92, 0x92, 0x7C, 0x10, 0x00, 0x00, 0x00, //
3016
- 0x00, 0x00, 0x38, 0x44, 0x82, 0xBA, 0x82, 0x82, 0x44, 0x38, 0x00, 0x00, 0x00, //
3029
- 0x00, 0x00, 0x7C, 0xC6, 0x82, 0x82, 0x82, 0x84, 0x44, 0xEE, 0x00, 0x00, 0x00, //
3042
- 0x38, 0x40, 0x60, 0x18, 0x24, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, //
3055
- 0x00, 0x00, 0x00, 0x00, 0x66, 0x99, 0x99, 0x99, 0x66, 0x00, 0x00, 0x00, 0x00, //
3068
- 0x10, 0x10, 0x10, 0x7C, 0x92, 0x91, 0x91, 0x91, 0x92, 0x7C, 0x10, 0x10, 0x10, //
3081
- 0x00, 0x00, 0x00, 0x1E, 0x20, 0x40, 0x7C, 0x40, 0x60, 0x1E, 0x00, 0x00, 0x00, //
3094
- 0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x82, 0x00, 0x00, 0x00, //
3107
- 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, //
3120
- 0x00, 0x00, 0x00, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x00, 0xFE, 0x00, 0x00, 0x00, //
3133
- 0x00, 0x00, 0x40, 0x30, 0x08, 0x06, 0x08, 0x30, 0x40, 0x00, 0x7E, 0x00, 0x00, //
3146
- 0x00, 0x00, 0x02, 0x0C, 0x10, 0x60, 0x10, 0x0C, 0x02, 0x00, 0x7E, 0x00, 0x00, //
3159
- 0x0C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, //
3172
- 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x60, //
3185
- 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, //
3198
- 0x00, 0x00, 0x00, 0x00, 0x72, 0x4E, 0x00, 0x72, 0x4E, 0x00, 0x00, 0x00, 0x00, //
3211
- 0x00, 0x10, 0x28, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
3224
- 0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, //
3237
- 0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, //
3250
- 0x01, 0x01, 0x02, 0x02, 0x02, 0x04, 0x04, 0xC4, 0x28, 0x28, 0x18, 0x10, 0x00, //
3263
- 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
3276
- 0x00, 0x3C, 0x04, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //
3289
- 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, //
3302
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 //
3315
-};
Modified: branches/olpc/drivers/base/bootvid/bootvid.c
URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootv…
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootvid.c (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.c Fri Jun 15 14:58:37 2007
@@ -1,475 +1,290 @@
-#include "precomp.h"
-
-/* PRIVATE FUNCTIONS *********************************************************/
-
-BOOLEAN
-NTAPI
-VgaInterpretCmdStream(IN PUSHORT CmdStream)
-{
- PUCHAR Base = (PUCHAR)VgaRegisterBase;
- USHORT Cmd;
- UCHAR Major, Minor;
- USHORT Count;
- UCHAR Index;
- PUSHORT Buffer;
- PUSHORT ShortPort;
- PUCHAR Port;
- UCHAR Value;
- USHORT ShortValue;
-
- /* First make sure that we have a Command Stream */
- if (!CmdStream) return TRUE;
-
- /* Loop as long as we have commands */
- while (*CmdStream)
- {
- /* Get the Major and Minor Function */
- Cmd = *CmdStream;
- Major = Cmd & 0xF0;
- Minor = Cmd & 0x0F;
-
- /* Move to the next command */
- CmdStream++;
-
- /* Check which major function this was */
- if (Major == 0x10)
- {
- /* Now let's see the minor function */
- if (Minor & CMD_STREAM_READ)
- {
- /* Now check the sub-type */
- if (Minor & CMD_STREAM_USHORT)
- {
- /* The port is what is in the stream right now */
- ShortPort = UlongToPtr((ULONG)*CmdStream);
-
- /* Move to the next command */
- CmdStream++;
-
- /* Read USHORT from the port */
- READ_PORT_USHORT(PtrToUlong(Base) + ShortPort);
- }
- else
- {
- /* The port is what is in the stream right now */
- Port = UlongToPtr((ULONG)*CmdStream);
-
- /* Move to the next command */
- CmdStream++;
-
- /* Read UCHAR from the port */
- READ_PORT_UCHAR(PtrToUlong(Base) + Port);
- }
- }
- else if (Minor & CMD_STREAM_WRITE_ARRAY)
- {
- /* Now check the sub-type */
- if (Minor & CMD_STREAM_USHORT)
- {
- /* The port is what is in the stream right now */
- ShortPort = UlongToPtr(Cmd);
-
- /* Move to the next command and get the count */
- Count = *(CmdStream++);
-
- /* The buffer is what's next in the command stream */
- Buffer = CmdStream++;
-
- /* Write USHORT to the port */
- WRITE_PORT_BUFFER_USHORT(PtrToUshort(Base) + ShortPort, Buffer,
Count);
-
- /* Move past the buffer in the command stream */
- CmdStream += Count;
- }
- else
- {
- /* The port is what is in the stream right now */
- Port = UlongToPtr(Cmd);
-
- /* Move to the next command and get the count */
- Count = *(CmdStream++);
-
- /* Add the base to the port */
- Port = PtrToUlong(Port) + Base;
-
- /* Move to next command */
- CmdStream++;
-
- /* Loop the cmd array */
- for (; Count; Count--, CmdStream++)
- {
- /* Get the byte we're writing */
- Value = (UCHAR)*CmdStream;
-
- /* Write UCHAR to the port */
- WRITE_PORT_UCHAR(Port, Value);
- }
- }
- }
- else if (Minor & CMD_STREAM_USHORT)
- {
- /* Get the ushort we're writing and advance in the stream */
- ShortValue = *CmdStream;
- CmdStream++;
-
- /* Write USHORT to the port (which is in cmd) */
- WRITE_PORT_USHORT((PUSHORT)Base + Cmd, ShortValue);
- }
- else
- {
- /* The port is what is in the stream right now */
- Port = UlongToPtr((ULONG)*CmdStream);
-
- /* Get the uchar we're writing */
- Value = (UCHAR)*++CmdStream;
-
- /* Move to the next command */
- CmdStream++;
-
- /* Write UCHAR to the port (which is in cmd) */
- WRITE_PORT_UCHAR(PtrToUlong(Base) + Port, Value);
- }
- }
- else if (Major == 0x20)
- {
- /* Check the minor function. Note these are not flags anymore. */
- switch (Minor)
- {
- case 0:
- /* The port is what is in the stream right now */
- ShortPort = UlongToPtr(*CmdStream);
-
- /* Move to the next command and get the count */
- Count = *(CmdStream++);
-
- /* Move to the next command and get the value to write */
- ShortValue = *(CmdStream++);
-
- /* Add the base to the port */
- ShortPort = PtrToUlong(ShortPort) + (PUSHORT)Base;
-
- /* Move to next command */
- CmdStream++;
-
- /* Make sure we have data */
- if (!ShortValue) continue;
-
- /* Loop the cmd array */
- for (; Count; Count--, CmdStream++, Value++)
- {
- /* Get the byte we're writing */
- ShortValue += (*CmdStream) << 8;
-
- /* Write USHORT to the port */
- WRITE_PORT_USHORT(ShortPort, ShortValue);
- }
- break;
- case 1:
- /* The port is what is in the stream right now. Add the base too */
- Port = *CmdStream + Base;
-
- /* Move to the next command and get the count */
- Count = *++CmdStream;
-
- /* Move to the next command and get the index to write */
- Index = (UCHAR)*++CmdStream;
-
- /* Move to next command */
- CmdStream++;
-
- /* Loop the cmd array */
- for (; Count; Count--, Index++)
- {
- /* Write the index */
- WRITE_PORT_UCHAR(Port, Index);
-
- /* Get the byte we're writing */
- Value = (UCHAR)*CmdStream;
-
- /* Move to next command */
- CmdStream++;
-
- /* Write UCHAR value to the port */
- WRITE_PORT_UCHAR(Port, Value);
- }
- break;
- case 2:
- /* The port is what is in the stream right now. Add the base too */
- Port = *CmdStream + Base;
-
- /* Read the current value and add the stream data */
- Value = READ_PORT_UCHAR(Port);
- Value &= *CmdStream++;
- Value ^= *CmdStream++;
-
- /* Write the value */
- WRITE_PORT_UCHAR(Port, Value);
- break;
- default:
- /* Unknown command, fail */
- return FALSE;
- }
- }
- else if (Major != 0xF0)
- {
- /* Unknown major function, fail */
- return FALSE;
- }
-
- /* Get the next command */
- Cmd = *CmdStream;
- }
-
- /* If we got here, return success */
- return TRUE;
-}
-
-BOOLEAN
-NTAPI
-VgaIsPresent(VOID)
-{
- UCHAR VgaReg, VgaReg2, VgaReg3;
- UCHAR SeqReg, SeqReg2;
- UCHAR i;
-
- /* Read the VGA Address Register */
- VgaReg = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE);
-
- /* Select Read Map Select Register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
-
- /* Read it back...it should be 4 */
- if (((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE)) & 0xF) != 4) return
FALSE;
-
- /* Read the VGA Data Register */
- VgaReg2 = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF);
-
- /* Enable all planes */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 3);
-
- /* Read it back...it should be 3 */
- if (READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) != 0x3)
- {
- /* Reset the registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
- return FALSE;
- }
-
- /* Select Bit Mask Register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
-
- /* Read it back...it should be 8 */
- if (((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE)) & 0xF) != 8)
- {
- /* Reset the registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
- return FALSE;
- }
-
- /* Read the VGA Data Register */
- VgaReg3 = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF);
-
- /* Loop bitmasks */
- for (i = 0xBB; i; i >>= 1)
- {
- /* Set bitmask */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, i);
-
- /* Read it back...it should be the same */
- if (READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) != i)
- {
- /* Reset the registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0xFF);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
- return FALSE;
- }
- }
-
- /* Select Read Map Select Register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
-
- /* Read it back...it should be 3 */
- if (READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) != 3)
- {
- /* Reset the registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0xFF);
- return FALSE;
- }
-
- /* Write the registers we read earlier */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, VgaReg);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, VgaReg2);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, VgaReg3);
-
- /* Read sequencer address */
- SeqReg = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4);
-
- /* Select memory mode register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4, 4);
-
- /* Read it back...it should still be 4 */
- if (((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4)) & 7) != 4)
- {
- /* Fail */
- return FALSE;
- }
-
- /* Read sequencer Data */
- SeqReg2 = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5);
-
- /* Write null plane */
- WRITE_PORT_USHORT((PUSHORT)VgaRegisterBase + 0x3C4, 0x100);
-
- /* Write sequencer flag */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5, SeqReg2 ^ 8);
-
- /* Read it back */
- if ((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5)) != (SeqReg2 ^ 8))
- {
- /* Not the same value...restore registers and fail */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5, 2);
- WRITE_PORT_USHORT((PUSHORT)VgaRegisterBase + 0x3C4, 0x300);
- return FALSE;
- }
-
- /* Now write the registers we read */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5, SeqReg2);
- WRITE_PORT_USHORT((PUSHORT)VgaRegisterBase + 0x3C4, 0x300);
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4, SeqReg);
-
- /* VGA is present! */
- return TRUE;
-}
-
-/* PUBLIC FUNCTIONS **********************************************************/
-
/*
- * @implemented
+ * ReactOS Boot video driver
+ *
+ * Copyright (C) 2003 Casper S. Hornstroup
+ * Copyright (C) 2004, 2005 Filip Navara
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * $Id$
*/
-BOOLEAN
-NTAPI
-VidInitialize(IN BOOLEAN SetMode)
-{
- ULONG Context = 0;
- PHYSICAL_ADDRESS TranslatedAddress;
- PHYSICAL_ADDRESS NullAddress = {{0}};
- ULONG AddressSpace = 1;
- BOOLEAN Result;
- ULONG_PTR Base;
-
- /* Make sure that we have a bus translation function */
- if (!HalFindBusAddressTranslation) return FALSE;
-
- /* Get the VGA Register address */
- Result = HalFindBusAddressTranslation(NullAddress,
- &AddressSpace,
- &TranslatedAddress,
- &Context,
- TRUE);
- if (!Result) return FALSE;
-
- /* See if this is I/O Space, which we need to map */
-TryAgain:
- if (!AddressSpace)
- {
- /* Map it */
- Base = (ULONG_PTR)MmMapIoSpace(TranslatedAddress, 0x400, MmNonCached);
- }
- else
- {
- /* The base is the translated address, no need to map I/O space */
- Base = TranslatedAddress.LowPart;
- }
-
- /* Set the VGA Register base and now check if we have a VGA device */
- VgaRegisterBase = Base;
- if (VgaIsPresent())
- {
- /* Translate the VGA Memory Address */
- NullAddress.LowPart = 0xA0000;
- AddressSpace = 0;
- Result = HalFindBusAddressTranslation(NullAddress,
- &AddressSpace,
- &TranslatedAddress,
- &Context,
- FALSE);
- if (Result)
- {
- /* Success! See if this is I/O Space, which we need to map */
- if (!AddressSpace)
- {
- /* Map it */
- Base = (ULONG_PTR)MmMapIoSpace(TranslatedAddress,
- 0x20000,
- MmNonCached);
- }
- else
- {
- /* The base is the translated address, no need to map I/O space */
- Base = TranslatedAddress.LowPart;
- }
-
- /* Set the VGA Memory Base */
- VgaBase = Base;
-
- /* Now check if we have to set the mode */
- if (SetMode)
- {
- //
- // Reset the display
- //
- //HalResetDisplay();
- curr_x = 0;
- curr_y = 0;
-
- /* Initialize it */
- VgaInterpretCmdStream(AT_Initialization);
- return TRUE;
- }
- }
- }
- else
- {
- /* It's not, so unmap the I/O space if we mapped it */
- if (!AddressSpace) MmUnmapIoSpace((PVOID)VgaRegisterBase, 0x400);
- }
-
- /* If we got here, then we failed...let's try again */
- Result = HalFindBusAddressTranslation(NullAddress,
- &AddressSpace,
- &TranslatedAddress,
- &Context,
- TRUE);
- if (Result) goto TryAgain;
-
- /* If we got here, then we failed even past our re-try... */
- return FALSE;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidResetDisplay(IN BOOLEAN HalReset)
-{
- /* Clear the current position */
- curr_x = 0;
- curr_y = 0;
-
- /* Clear the screen with HAL if we were asked to */
- //if (HalReset) HalResetDisplay();
-
- /* Re-initialize the VGA Display */
- VgaInterpretCmdStream(AT_Initialization);
-
- /* Re-initialize the palette and fill the screen black */
- InitializePalette();
- VidSolidColorFill(0, 0, 639, 479, 0);
-}
-
+
+/* INCLUDES ******************************************************************/
+
+#include "bootvid.h"
+#include "resource.h"
+
+#define NDEBUG
+#include <debug.h>
+
+//#define USE_PROGRESS_BAR
+
+/* GLOBALS *******************************************************************/
+
+static volatile LONG ShutdownNotify;
+static KEVENT ShutdownCompleteEvent;
+
+/* DATA **********************************************************************/
+
+static RGBQUAD _MainPalette[16];
+static UCHAR _Square1[9 * 4];
+static UCHAR _Square2[9 * 4];
+static UCHAR _Square3[9 * 4];
+
+/* FUNCTIONS *****************************************************************/
+
+static VOID NTAPI
+BootVidAnimationThread(PVOID Ignored)
+{
+ UCHAR PaletteBitmapBuffer[sizeof(BITMAPINFOHEADER) + sizeof(_MainPalette)];
+ PBITMAPINFOHEADER PaletteBitmap = (PBITMAPINFOHEADER)PaletteBitmapBuffer;
+ LPRGBQUAD Palette = (LPRGBQUAD)(PaletteBitmapBuffer + sizeof(BITMAPINFOHEADER));
+ ULONG Iteration, Index, ClrUsed;
+ UINT AnimBarPos;
+ LARGE_INTEGER Interval;
+
+ /*
+ * Build a bitmap containing the fade in palette. The palette entries
+ * are then processed in a loop and set using VidBitBlt function.
+ */
+
+ ClrUsed = sizeof(_MainPalette) / sizeof(_MainPalette[0]);
+ RtlZeroMemory(PaletteBitmap, sizeof(BITMAPINFOHEADER));
+ PaletteBitmap->biSize = sizeof(BITMAPINFOHEADER);
+ PaletteBitmap->biBitCount = 4;
+ PaletteBitmap->biClrUsed = ClrUsed;
+
+ /*
+ * Main animation loop.
+ */
+
+ for (Iteration = 0, AnimBarPos = 0; !ShutdownNotify; Iteration++)
+ {
+ if (Iteration <= PALETTE_FADE_STEPS)
+ {
+ for (Index = 0; Index < ClrUsed; Index++)
+ {
+ Palette[Index].rgbRed =
+ _MainPalette[Index].rgbRed * Iteration / PALETTE_FADE_STEPS;
+ Palette[Index].rgbGreen =
+ _MainPalette[Index].rgbGreen * Iteration / PALETTE_FADE_STEPS;
+ Palette[Index].rgbBlue =
+ _MainPalette[Index].rgbBlue * Iteration / PALETTE_FADE_STEPS;
+ }
+
+ VidBitBlt(PaletteBitmapBuffer, 0, 0);
+ }
+#ifdef USE_PROGRESS_BAR
+ else
+ {
+ break;
+ }
+
+ Interval.QuadPart = -PALETTE_FADE_TIME;
+#else
+
+#if 0
+ if (AnimBarPos == 0)
+ {
+ VidSolidColorFill(0x173, 354, 0x178, 354 + 9, 0);
+ }
+ else if (AnimBarPos > 3)
+ {
+ VidSolidColorFill(0xe3 + AnimBarPos * 8, 354,
+ 0xe8 + AnimBarPos * 8, 354 + 9,
+ 0);
+ }
+
+ if (AnimBarPos >= 3)
+ {
+ VidBufferToScreenBlt(_Square1, 0xeb + AnimBarPos * 8, 354, 6, 9, 4);
+ }
+ if (AnimBarPos >= 2 && AnimBarPos <= 16)
+ {
+ VidBufferToScreenBlt(_Square2, 0xf3 + AnimBarPos * 8, 354, 6, 9, 4);
+ }
+ if (AnimBarPos >= 1 && AnimBarPos <= 15)
+ {
+ VidBufferToScreenBlt(_Square3, 0xfb + AnimBarPos * 8, 354, 6, 9, 4);
+ }
+#endif
+
+ if (Iteration <= PALETTE_FADE_STEPS)
+ {
+ Interval.QuadPart = -PALETTE_FADE_TIME;
+ if ((Iteration % 5) == 0)
+ AnimBarPos++;
+ }
+ else
+ {
+ Interval.QuadPart = -PALETTE_FADE_TIME * 5;
+ AnimBarPos++;
+ }
+ AnimBarPos = Iteration % 18;
+#endif
+
+ /* Wait for a bit. */
+ KeDelayExecutionThread(KernelMode, FALSE, &Interval);
+ }
+
+ DPRINT("Finishing bootvid thread.\n");
+ KeSetEvent(&ShutdownCompleteEvent, 0, FALSE);
+
+ PsTerminateSystemThread(0);
+}
+
+
+NTSTATUS NTAPI
+BootVidDisplayBootLogo(PVOID ImageBase)
+{
+ PBITMAPINFOHEADER BitmapInfoHeader;
+ LPRGBQUAD Palette;
+ static const ULONG BitmapIds[2] = {IDB_BOOTIMAGE, IDB_BAR};
+ PUCHAR BitmapData[2];
+ ULONG Index;
+ HANDLE BitmapThreadHandle;
+ CLIENT_ID BitmapThreadId;
+ NTSTATUS Status;
+
+ KeInitializeEvent(&ShutdownCompleteEvent, NotificationEvent, FALSE);
+
+ /*
+ * Get the bitmaps from the executable.
+ */
+
+ for (Index = 0; Index < sizeof(BitmapIds) / sizeof(BitmapIds[0]); Index++)
+ {
+ PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
+ LDR_RESOURCE_INFO ResourceInfo;
+ ULONG Size;
+
+ ResourceInfo.Type = /* RT_BITMAP */ 2;
+ ResourceInfo.Name = BitmapIds[Index];
+ ResourceInfo.Language = 0x09;
+
+ Status = LdrFindResource_U(
+ ImageBase,
+ &ResourceInfo,
+ RESOURCE_DATA_LEVEL,
+ &ResourceDataEntry);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("LdrFindResource_U() failed with status 0x%.08x\n", Status);
+ return Status;
+ }
+
+ Status = LdrAccessResource(
+ ImageBase,
+ ResourceDataEntry,
+ (PVOID*)&BitmapData[Index],
+ &Size);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("LdrAccessResource() failed with status 0x%.08x\n", Status);
+ return Status;
+ }
+ }
+
+
+ /*
+ * Initialize the graphics output.
+ */
+
+ if (!VidInitialize(TRUE))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ /*
+ * Load the bar bitmap and get the square data from it.
+ */
+
+ VidBitBlt(BitmapData[1], 0, 0);
+ VidScreenToBufferBlt(_Square1, 0, 0, 6, 9, 4);
+ VidScreenToBufferBlt(_Square2, 8, 0, 6, 9, 4);
+ VidScreenToBufferBlt(_Square3, 16, 0, 6, 9, 4);
+
+ /*
+ * Save the main image palette and replace it with black palette, so
+ * we can do fade in effect later.
+ */
+
+ BitmapInfoHeader = (PBITMAPINFOHEADER)BitmapData[0];
+ Palette = (LPRGBQUAD)(BitmapData[0] + BitmapInfoHeader->biSize);
+ RtlCopyMemory(_MainPalette, Palette, sizeof(_MainPalette));
+ RtlZeroMemory(Palette, sizeof(_MainPalette));
+
+ /*
+ * Display the main image.
+ */
+
+ VidBitBlt(BitmapData[0], 0, 0);
+
+ /*
+ * Start a thread that handles the fade in and bar animation effects.
+ */
+
+ Status = PsCreateSystemThread(
+ &BitmapThreadHandle,
+ THREAD_ALL_ACCESS,
+ NULL,
+ NULL,
+ &BitmapThreadId,
+ BootVidAnimationThread,
+ NULL);
+
+ if (!NT_SUCCESS(Status))
+ {
+ VidCleanUp();
+ return Status;
+ }
+
+ ZwClose(BitmapThreadHandle);
+
+ return STATUS_SUCCESS;
+}
+
+
+VOID NTAPI
+BootVidUpdateProgress(ULONG Progress)
+{
+#ifdef USE_PROGRESS_BAR
+ if (ShutdownNotify == 0)
+ {
+ VidSolidColorFill(0x103, 354, 0x103 + (Progress * 120 / 100), 354 + 9, 1);
+ }
+#endif
+}
+
+
+VOID NTAPI
+BootVidFinalizeBootLogo(VOID)
+{
+ InterlockedIncrement(&ShutdownNotify);
+ DPRINT1("Waiting for bootvid thread to finish.\n");
+ KeWaitForSingleObject(&ShutdownCompleteEvent, Executive, KernelMode,
+ FALSE, NULL);
+ DPRINT1("Bootvid thread to finish.\n");
+ //VidResetDisplay();
+}
+
+
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
+{
+ return STATUS_SUCCESS;
+}
Propchange: branches/olpc/drivers/base/bootvid/bootvid.c
------------------------------------------------------------------------------
--- svn:needs-lock (original)
+++ svn:needs-lock (removed)
@@ -1,1 +1,0 @@
-*
Modified: branches/olpc/drivers/base/bootvid/bootvid.def
URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootv…
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootvid.def (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.def Fri Jun 15 14:58:37 2007
@@ -1,15 +1,14 @@
-LIBRARY BOOTVID.DLL
+LIBRARY bootvid.sys
EXPORTS
-VidBitBlt@12
-VidBufferToScreenBlt@24
-VidCleanUp@0
-VidDisplayString@4
-VidDisplayStringXY
-VidInitialize@4
-VidResetDisplay@4
-VidScreenToBufferBlt@24
-VidSetScrollRegion@16
-VidSetTextColor@4
-VidSolidColorFill@20
-
+VidInitialize
+VidCleanUp
+VidResetDisplay
+VidBufferToScreenBlt
+VidScreenToBufferBlt
+VidBitBlt
+VidSolidColorFill
+VidDisplayString
+BootVidDisplayBootLogo
+BootVidUpdateProgress
+BootVidFinalizeBootLogo
Propchange: branches/olpc/drivers/base/bootvid/bootvid.def
------------------------------------------------------------------------------
--- svn:needs-lock (original)
+++ svn:needs-lock (removed)
@@ -1,1 +1,0 @@
-*
Modified: branches/olpc/drivers/base/bootvid/bootvid.rbuild
URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootv…
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootvid.rbuild (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.rbuild Fri Jun 15 14:58:37 2007
@@ -2,11 +2,13 @@
<importlibrary definition="bootvid.def"></importlibrary>
<bootstrap base="$(CDOUTPUT)" nameoncd="bootvid.dll" />
<include base="bootvid">.</include>
- <define name="__USE_W32API" />
+ <define name="__USE_W32API" />
<library>ntoskrnl</library>
<library>hal</library>
<file>bootvid.c</file>
- <file>bootdata.c</file>
- <file>vga.c</file>
+ <file>vid.c</file>
+ <file>vid_vga.c</file>
+ <file>vid_vgatext.c</file>
+ <file>vid_xbox.c</file>
<file>bootvid.rc</file>
-</module>
+</module>
Propchange: branches/olpc/drivers/base/bootvid/bootvid.rbuild
------------------------------------------------------------------------------
--- svn:needs-lock (original)
+++ svn:needs-lock (removed)
@@ -1,1 +1,0 @@
-*
Modified: branches/olpc/drivers/base/bootvid/bootvid.rc
URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootv…
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootvid.rc (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.rc Fri Jun 15 14:58:37 2007
@@ -3,8 +3,12 @@
#include "resource.h"
#define REACTOS_VERSION_DLL
-#define REACTOS_STR_FILE_DESCRIPTION "VGA Boot Driver\0"
-#define REACTOS_STR_INTERNAL_NAME "bootvid.dll\0"
-#define REACTOS_STR_ORIGINAL_FILENAME "bootvid.dll\0"
+#define REACTOS_STR_FILE_DESCRIPTION "ReactOS Boot Video\0"
+#define REACTOS_STR_INTERNAL_NAME "bootvid\0"
+#define REACTOS_STR_ORIGINAL_FILENAME "bootvid.sys\0"
+#include <reactos/version.rc>
-#include <reactos/version.rc>
+IDB_BOOTIMAGE BITMAP DISCARDABLE "bootimage.bmp"
+IDB_BAR BITMAP DISCARDABLE "bar.bmp"
+
+
Propchange: branches/olpc/drivers/base/bootvid/bootvid.rc
------------------------------------------------------------------------------
--- svn:needs-lock (original)
+++ svn:needs-lock (removed)
@@ -1,1 +1,0 @@
-*
Removed: branches/olpc/drivers/base/bootvid/precomp.h
URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/preco…
==============================================================================
--- branches/olpc/drivers/base/bootvid/precomp.h (original)
+++ branches/olpc/drivers/base/bootvid/precomp.h (removed)
@@ -1,46 +1,0 @@
-#include "ntddk.h"
-#include "arc/arc.h"
-#include "halfuncs.h"
-#include "drivers/bootvid/bootvid.h"
-
-//
-// Command Stream Definitions
-//
-#define CMD_STREAM_WRITE 0x0
-#define CMD_STREAM_WRITE_ARRAY 0x2
-#define CMD_STREAM_USHORT 0x4
-#define CMD_STREAM_READ 0x8
-
-//
-// Bitmap Header
-//
-typedef struct tagBITMAPINFOHEADER
-{
- ULONG biSize;
- LONG biWidth;
- LONG biHeight;
- USHORT biPlanes;
- USHORT biBitCount;
- ULONG biCompression;
- ULONG biSizeImage;
- LONG biXPelsPerMeter;
- LONG biYPelsPerMeter;
- ULONG biClrUsed;
- ULONG biClrImportant;
-} BITMAPINFOHEADER, *PBITMAPINFOHEADER;
-
-VOID
-NTAPI
-InitializePalette(
- VOID
-);
-
-//
-// Globals
-//
-extern USHORT AT_Initialization[];
-extern ULONG curr_x;
-extern ULONG curr_y;
-extern ULONG_PTR VgaRegisterBase;
-extern ULONG_PTR VgaBase;
-extern UCHAR FontData[256 * 13];
Removed: branches/olpc/drivers/base/bootvid/vga.c
URL:
http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/vga.c…
==============================================================================
--- branches/olpc/drivers/base/bootvid/vga.c (original)
+++ branches/olpc/drivers/base/bootvid/vga.c (removed)
@@ -1,1274 +1,0 @@
-#include "precomp.h"
-
-/* GLOBALS *******************************************************************/
-
-ULONG ScrollRegion[4] =
-{
- 0,
- 0,
- 640 - 1,
- 480 - 1
-};
-UCHAR lMaskTable[8] =
-{
- (1 << 8) - (1 << 0),
- (1 << 7) - (1 << 0),
- (1 << 6) - (1 << 0),
- (1 << 5) - (1 << 0),
- (1 << 4) - (1 << 0),
- (1 << 3) - (1 << 0),
- (1 << 2) - (1 << 0),
- (1 << 1) - (1 << 0)
-};
-UCHAR rMaskTable[8] =
-{
- (1 << 7),
- (1 << 7)+ (1 << 6),
- (1 << 7)+ (1 << 6) + (1 << 5),
- (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4),
- (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3),
- (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3) +
(1 << 2),
- (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3) +
(1 << 2) + (1 << 1),
- (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3) +
(1 << 2) + (1 << 1) +
- (1 << 0),
-};
-UCHAR PixelMask[8] =
-{
- (1 << 7),
- (1 << 6),
- (1 << 5),
- (1 << 4),
- (1 << 3),
- (1 << 2),
- (1 << 1),
- (1 << 0),
-};
-ULONG lookup[16] =
-{
- 0x0000,
- 0x0100,
- 0x1000,
- 0x1100,
- 0x0001,
- 0x0101,
- 0x1001,
- 0x1101,
- 0x0010,
- 0x0110,
- 0x1010,
- 0x1110,
- 0x0011,
- 0x0111,
- 0x1011,
- 0x1111,
-};
-
-ULONG TextColor = 0xF;
-ULONG curr_x = 0;
-ULONG curr_y = 0;
-BOOLEAN NextLine = FALSE;
-ULONG_PTR VgaRegisterBase = 0;
-ULONG_PTR VgaBase = 0;
-
-/* PRIVATE FUNCTIONS *********************************************************/
-
-VOID
-NTAPI
-ReadWriteMode(UCHAR Mode)
-{
- UCHAR Value;
-
- /* Switch to graphics mode register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 5);
-
- /* Get the current register value, minus the current mode */
- Value = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) & 0xF4;
-
- /* Set the new mode */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, Mode | Value);
-}
-
-VOID
-NTAPI
-__outpb(IN ULONG Port,
- IN ULONG Value)
-{
- /* Write to the VGA Register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + Port, (UCHAR)Value);
-}
-
-VOID
-NTAPI
-__outpw(IN ULONG Port,
- IN ULONG Value)
-{
- /* Write to the VGA Register */
- WRITE_PORT_USHORT((PUSHORT)(VgaRegisterBase + Port), (USHORT)Value);
-}
-
-VOID
-NTAPI
-SetPixel(IN ULONG Left,
- IN ULONG Top,
- IN UCHAR Color)
-{
- PUCHAR PixelPosition;
-
- /* Calculate the pixel position. */
- PixelPosition = (PUCHAR)VgaBase + (Left >> 3) + (Top * 80);
-
- /* Switch to mode 10 */
- ReadWriteMode(10);
-
- /* Clear the 4 planes (we're already in unchained mode here) */
- __outpw(0x3C4, 0xF02);
-
- /* Select the color don't care register */
- __outpw(0x3CE, 7);
-
- /* Select the bitmask register and write the mask */
- __outpw(0x3CE, (PixelMask[Left & 7] << 8) | 8);
-
- /* Read the current pixel value and add our color */
- WRITE_REGISTER_UCHAR(PixelPosition,
- READ_REGISTER_UCHAR(PixelPosition) & Color);
-}
-
-VOID
-NTAPI
-DisplayCharacter(CHAR Character,
- ULONG Left,
- ULONG Top,
- ULONG TextColor,
- ULONG BackTextColor)
-{
- PUCHAR FontChar;
- ULONG i, j, XOffset;
-
- /* Get the font line for this character */
- FontChar = &FontData[Character * 13 - Top];
-
- /* Loop each pixel height */
- i = 13;
- do
- {
- /* Loop each pixel width */
- j = 128;
- XOffset = Left;
- do
- {
- /* Check if we should draw this pixel */
- if (FontChar[Top] & (UCHAR)j)
- {
- /* We do, use the given Text Color */
- SetPixel(XOffset, Top, (UCHAR)TextColor);
- }
- else if (BackTextColor < 16)
- {
- /* This is a background pixel. We're drawing it unless it's */
- /* transparent. */
- SetPixel(XOffset, Top, (UCHAR)BackTextColor);
- }
-
- /* Increase X Offset */
- XOffset++;
- } while (j >>= 1);
-
- /* Move to the next Y ordinate */
- Top++;
- } while (--i);
-}
-
-VOID
-NTAPI
-DisplayStringXY(PUCHAR String,
- ULONG Left,
- ULONG Top,
- ULONG TextColor,
- ULONG BackColor)
-{
- /* Loop every character */
- while (*String)
- {
- /* Display a character */
- DisplayCharacter(*String, Left, Top, TextColor, BackColor);
-
- /* Move to next character and next position */
- String++;
- Left += 8;
- }
-}
-
-VOID
-NTAPI
-SetPaletteEntryRGB(IN ULONG Id,
- IN ULONG Rgb)
-{
- PCHAR Colors = (PCHAR)&Rgb;
-
- /* Set the palette index */
- __outpb(0x3C8, (UCHAR)Id);
-
- /* Set RGB colors */
- __outpb(0x3C9, Colors[2] >> 2);
- __outpb(0x3C9, Colors[1] >> 2);
- __outpb(0x3C9, Colors[0] >> 2);
-}
-
-VOID
-NTAPI
-InitPaletteWithTable(IN PULONG Table,
- IN ULONG Count)
-{
- ULONG i;
- PULONG Entry = Table;
-
- /* Loop every entry */
- for (i = 0; i < Count; i++, Entry++)
- {
- /* Set the entry */
- SetPaletteEntryRGB(i, *Entry);
- }
-}
-
-VOID
-NTAPI
-SetPaletteEntry(IN ULONG Id,
- IN ULONG PaletteEntry)
-{
- /* Set the palette index */
- __outpb(0x3C8, (UCHAR)Id);
-
- /* Set RGB colors */
- __outpb(0x3C9, PaletteEntry & 0xFF);
- __outpb(0x3C9, (PaletteEntry >>= 8) & 0xFF);
- __outpb(0x3C9, (PaletteEntry >> 8) & 0xFF);
-}
-
-VOID
-NTAPI
-InitializePalette(VOID)
-{
- ULONG PaletteEntry[16] = {0,
- 0x20,
- 0x2000,
- 0x2020,
- 0x200000,
- 0x200020,
- 0x202000,
- 0x202020,
- 0x303030,
- 0x3F,
- 0x3F00,
- 0x3F3F,
- 0x3F0000,
- 0x3F003F,
- 0x3F3F00,
- 0x3F3F3F};
- ULONG i;
-
- /* Loop all the entries and set their palettes */
- for (i = 0; i < 16; i++) SetPaletteEntry(i, PaletteEntry[i]);
-}
-
-VOID
-NTAPI
-VgaScroll(ULONG Scroll)
-{
- ULONG Top;
- ULONG SourceOffset, DestOffset;
- ULONG Offset;
- ULONG i, j;
-
- /* Set memory positions of the scroll */
- SourceOffset = VgaBase + (ScrollRegion[1] * 80) + (ScrollRegion[0] >> 3);
- DestOffset = SourceOffset + (Scroll * 80);
-
- /* Clear the 4 planes */
- __outpw(0x3C4, 0xF02);
-
- /* Set the bitmask to 0xFF for all 4 planes */
- __outpw(0x3CE, 0xFF08);
-
- /* Set Mode 1 */
- ReadWriteMode(1);
-
- /* Save top and check if it's above the bottom */
- Top = ScrollRegion[1];
- if (Top > ScrollRegion[3]) return;
-
- /* Start loop */
- do
- {
- /* Set number of bytes to loop and start offset */
- Offset = ScrollRegion[0] >> 3;
- j = SourceOffset;
-
- /* Check if this is part of the scroll region */
- if (Offset <= (ScrollRegion[2] >> 3))
- {
- /* Update position */
- i = DestOffset - SourceOffset;
-
- /* Loop the X axis */
- do
- {
- /* Write value in the new position so that we can do the scroll */
- WRITE_REGISTER_UCHAR((PUCHAR)j,
- READ_REGISTER_UCHAR((PUCHAR)j + i));
-
- /* Move to the next memory location to write to */
- j++;
-
- /* Move to the next byte in the region */
- Offset++;
-
- /* Make sure we don't go past the scroll region */
- } while (Offset <= (ScrollRegion[2] >> 3));
- }
-
- /* Move to the next line */
- SourceOffset += 80;
- DestOffset += 80;
-
- /* Increase top */
- Top++;
-
- /* Make sure we don't go past the scroll region */
- } while (Top <= ScrollRegion[3]);
-}
-
-VOID
-NTAPI
-PreserveRow(IN ULONG CurrentTop,
- IN ULONG TopDelta,
- IN BOOLEAN Direction)
-{
- PUCHAR Position1, Position2;
- ULONG Count;
-
- /* Clear the 4 planes */
- __outpw(0x3C4, 0xF02);
-
- /* Set the bitmask to 0xFF for all 4 planes */
- __outpw(0x3CE, 0xFF08);
-
- /* Set Mode 1 */
- ReadWriteMode(1);
-
- /* Check which way we're preserving */
- if (Direction)
- {
- /* Calculate the position in memory for the row */
- Position1 = (PUCHAR)VgaBase + CurrentTop * 80;
- Position2 = (PUCHAR)VgaBase + 0x9600;
- }
- else
- {
- /* Calculate the position in memory for the row */
- Position1 = (PUCHAR)VgaBase + 0x9600;
- Position2 = (PUCHAR)VgaBase + CurrentTop * 80;
- }
-
- /* Set the count and make sure it's above 0 */
- Count = TopDelta * 80;
- if (Count)
- {
- /* Loop every pixel */
- do
- {
- /* Write the data back on the other position */
- WRITE_REGISTER_UCHAR(Position1, READ_REGISTER_UCHAR(Position2));
-
- /* Increase both positions */
- Position2++;
- Position1++;
- } while (--Count);
- }
-}
-
-VOID
-NTAPI
-BitBlt(IN ULONG Left,
- IN ULONG Top,
- IN ULONG Width,
- IN ULONG Height,
- IN PUCHAR Buffer,
- IN ULONG BitsPerPixel,
- IN ULONG Delta)
-{
- ULONG LeftAnd, LeftShifted, LeftPlusOne, LeftPos;
- ULONG lMask, rMask;
- UCHAR NotlMask;
- ULONG Distance;
- ULONG DistanceMinusLeftBpp;
- ULONG SomeYesNoFlag, SomeYesNoFlag2;
- PUCHAR PixelPosition, m;
- PUCHAR i, k;
- ULONG j;
- ULONG x;
- ULONG Plane;
- UCHAR LeftArray[84];
- PUCHAR CurrentLeft;
- PUCHAR l;
- ULONG LoopCount;
- UCHAR pMask, PlaneShift;
- BOOLEAN Odd;
- UCHAR Value;
-
- /* Check if the buffer isn't 4bpp */
- if (BitsPerPixel != 4)
- {
- /* FIXME: TODO */
- DbgPrint("Unhandled BitBlt\n"
- "%lxx%lx @ (%lx,%lx)\n"
- "Bits Per Pixel %lx\n"
- "Buffer: %p. Delta: %lx\n",
- Width,
- Height,
- Left,
- Top,
- BitsPerPixel,
- Buffer,
- Delta);
- return;
- }
-
- /* Get the masks and other values */
- LeftAnd = Left & 0x7;
- lMask = lMaskTable[LeftAnd];
- Distance = Width + Left;
- rMask = rMaskTable[(Distance - 1) & 0x7];
- Left >>= 3;
-
- /* Set some values */
- SomeYesNoFlag = FALSE;
- SomeYesNoFlag2 = FALSE;
- Distance = (Distance - 1) >> 3;
- DistanceMinusLeftBpp = Distance - Left;
-
- /* Check if the distance is equal to the left position and add the masks */
- if (Left == Distance) lMask += rMask;
-
- /* Check if there's no distance offset */
- if (DistanceMinusLeftBpp)
- {
- /* Set the first flag on */
- SomeYesNoFlag = TRUE;
-
- /* Decrease offset and check if we still have one */
- if (--DistanceMinusLeftBpp)
- {
- /* Still have a distance offset */
- SomeYesNoFlag2 = TRUE;
- }
- }
-
- /* Calculate initial pixel position */
- PixelPosition = (PUCHAR)VgaBase + (Top * 80) + Left;
-
- /* Set loop buffer variable */
- i = Buffer;
-
- /* Switch to mode 0 */
- ReadWriteMode(0);
-
- /* Leave now if the height is 0 */
- if (Height <= 0) return;
-
- /* Set more weird values */
- CurrentLeft = &LeftArray[Left];
- NotlMask = ~(UCHAR)lMask;
- LeftPlusOne = Left + 1;
- LeftShifted = (lMask << 8) | 8;
- j = Height;
-
- /* Start the height loop */
- do
- {
- /* Start the plane loop */
- Plane = 0;
- do
- {
- /* Clear the current value */
- *CurrentLeft = 0;
- LoopCount = 0;
-
- /* Set the buffer loop variable for this loop */
- k = i;
-
- /* Calculate plane shift and pixel mask */
- PlaneShift = 1 << Plane;
- pMask = PixelMask[LeftAnd];
-
- /* Check if we have a width */
- if (Width > 0)
- {
- /* Loop it */
- l = CurrentLeft;
- x = Width;
- do
- {
- /* Check if we're odd and increase the loop count */
- Odd = LoopCount & 1 ? TRUE : FALSE;
- LoopCount++;
- if (Odd)
- {
- /* Check for the plane shift */
- if (*k & PlaneShift)
- {
- /* Write the pixel mask */
- *l |= pMask;
- }
-
- /* Increase buffer position */
- k++;
- }
- else
- {
- /* Check for plane shift */
- if ((*k >> 4) & PlaneShift)
- {
- /* Write the pixel mask */
- *l |= pMask;
- }
- }
-
- /* Shift the pixel mask */
- pMask >>= 1;
- if (!pMask)
- {
- /* Move to the next current left position and clear it */
- l++;
- *l = 0;
-
- /* Set the pixel mask to 0x80 */
- pMask = 0x80;
- }
- } while (--x);
- }
-
- /* Set the plane value */
- __outpw(0x3C4, (1 << (Plane + 8) | 2));
-
- /* Select the bitmask register and write the mask */
- __outpw(0x3CE, (USHORT)LeftShifted);
-
- /* Read the current Pixel value */
- Value = READ_REGISTER_UCHAR(PixelPosition);
-
- /* Add our mask */
- Value = (Value & NotlMask) | *CurrentLeft;
-
- /* Set current left for the loop, and write new pixel value */
- LeftPos = LeftPlusOne;
- WRITE_REGISTER_UCHAR(PixelPosition, Value);
-
- /* Set loop pixel position and check if we should loop */
- m = PixelPosition + 1;
- if (SomeYesNoFlag2)
- {
- /* Set the bitmask to 0xFF for all 4 planes */
- __outpw(0x3CE, 0xFF08);
-
- /* Check if we have any distance left */
- if (DistanceMinusLeftBpp > 0)
- {
- /* Start looping it */
- x = DistanceMinusLeftBpp;
- do
- {
- /* Write the value */
- WRITE_REGISTER_UCHAR(m, LeftArray[LeftPos]);
-
- /* Go to the next position */
- m++;
- LeftPos++;
- } while (--x);
- }
- }
-
- /* Check if the first flag is on */
- if (SomeYesNoFlag)
- {
- /* Set the mask value */
- __outpw(0x3CE, (rMask << 8) | 8);
-
- /* Read the current Pixel value */
- Value = READ_REGISTER_UCHAR(m);
-
- /* Add our mask */
- Value = (Value & ~(UCHAR)rMask) | LeftArray[LeftPos];
-
- /* Set current left for the loop, and write new pixel value */
- WRITE_REGISTER_UCHAR(m, Value);
- }
- } while (++Plane < 4);
-
- /* Update pixel position, buffer and height */
- PixelPosition += 80;
- i += Delta;
- } while (--j);
-}
-
-VOID
-NTAPI
-RleBitBlt(IN ULONG Left,
- IN ULONG Top,
- IN ULONG Width,
- IN ULONG Height,
- IN PUCHAR Buffer)
-{
- ULONG YDelta;
- ULONG x;
- ULONG RleValue, NewRleValue;
- ULONG Color, Color2;
- ULONG i, j;
- ULONG Code;
-
- /* Set Y height and current X value and start loop */
- YDelta = Top + Height - 1;
- x = Left;
- for (;;)
- {
- /* Get the current value and advance in the buffer */
- RleValue = *Buffer;
- Buffer++;
- if (RleValue)
- {
- /* Check if we've gone past the edge */
- if ((x + RleValue) > (Width + Left))
- {
- /* Fixeup the pixel value */
- RleValue = Left - x + Width;
- }
-
- /* Get the new value */
- NewRleValue = *Buffer;
-
- /* Get the two colors */
- Color = NewRleValue >> 4;
- Color2 = NewRleValue & 0xF;
-
- /* Increase buffer positition */
- Buffer++;
-
- /* Check if we need to do a fill */
- if (Color == Color2)
- {
- /* Do a fill and continue the loop */
- RleValue += x;
- VidSolidColorFill(x, YDelta, RleValue - 1, YDelta, (UCHAR)Color);
- x = RleValue;
- continue;
- }
-
- /* Check if the pixel value is 1 or below */
- if (RleValue > 1)
- {
- /* Set loop variables */
- i = (RleValue - 2) / 2 + 1;
- do
- {
- /* Set the pixels */
- SetPixel(x, YDelta, (UCHAR)Color);
- x++;
- SetPixel(x, YDelta, (UCHAR)Color2);
- x++;
-
- /* Decrease pixel value */
- RleValue -= 2;
- } while (--i);
- }
-
- /* Check if there is any value at all */
- if (RleValue)
- {
- /* Set the pixel and increase posititon */
- SetPixel(x, YDelta, (UCHAR)Color);
- x++;
- }
-
- /* Start over */
- continue;
- }
-
- /* Get the current pixel value */
- RleValue = *Buffer;
- Code = RleValue;
- switch (Code)
- {
- /* Case 0 */
- case 0:
-
- /* Set new x value, decrease distance and restart */
- x = Left;
- YDelta--;
- Buffer++;
- continue;
-
- /* Case 1 */
- case 1:
-
- /* Done */
- return;
-
- /* Case 2 */
- case 2:
-
- /* Set new x value, decrease distance and restart */
- Buffer++;
- x += *Buffer;
- Buffer++;
- YDelta -= *Buffer;
- Buffer++;
- continue;
-
- /* Other values */
- default:
-
- Buffer++;
- break;
- }
-
- /* Check if we've gone past the edge */
- if ((x + RleValue) > (Width + Left))
- {
- /* Set fixed up loop count */
- i = RleValue - Left - Width + x;
-
- /* Fixup pixel value */
- RleValue -= i;
- }
- else
- {
- /* Clear loop count */
- i = 0;
- }
-
- /* Check the value now */
- if (RleValue > 1)
- {
- /* Set loop variables */
- j = (RleValue - 2) / 2 + 1;
- do
- {
- /* Get the new value */
- NewRleValue = *Buffer;
-
- /* Get the two colors */
- Color = NewRleValue >> 4;
- Color2 = NewRleValue & 0xF;
-
- /* Increase buffer position */
- Buffer++;
-
- /* Set the pixels */
- SetPixel(x, YDelta, (UCHAR)Color);
- x++;
- SetPixel(x, YDelta, (UCHAR)Color2);
- x++;
-
- /* Decrease pixel value */
- RleValue -= 2;
- } while (--j);
- }
-
- /* Check if there is any value at all */
- if (RleValue)
- {
- /* Set the pixel and increase position */
- Color = *Buffer >> 4;
- Buffer++;
- SetPixel(x, YDelta, (UCHAR)Color);
- x++;
- i--;
- }
-
- /* Check loop count now */
- if ((LONG)i > 0)
- {
- /* Decrease it */
- i--;
-
- /* Set new position */
- Buffer = Buffer + (i / 2) + 1;
- }
-
- /* Check if we need to increase the buffer */
- if ((ULONG_PTR)Buffer & 1) Buffer++;
- }
-}
-
-/* PUBLIC FUNCTIONS **********************************************************/
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-VidSetTextColor(ULONG Color)
-{
- ULONG OldColor;
-
- /* Save the old color and set the new one */
- OldColor = TextColor;
- TextColor = Color;
- return OldColor;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidDisplayStringXY(PUCHAR String,
- ULONG Left,
- ULONG Top,
- BOOLEAN Transparent)
-{
- ULONG BackColor;
-
- /* If the caller wanted transparent, then send the special value (16), else */
- /* use our default and call the helper routine. */
- BackColor = (Transparent) ? 16 : 14;
- DisplayStringXY(String, Left, Top, 12, BackColor);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidSetScrollRegion(ULONG x1,
- ULONG y1,
- ULONG x2,
- ULONG y2)
-{
- /* Assert alignment */
- ASSERT((x1 & 0x7) == 0);
- ASSERT((x2 & 0x7) == 7);
-
- /* Set Scroll Region */
- ScrollRegion[0] = x1;
- ScrollRegion[1] = y1;
- ScrollRegion[2] = x2;
- ScrollRegion[3] = y2;
-
- /* Set current X and Y */
- curr_x = x1;
- curr_y = y1;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidCleanUp(VOID)
-{
- /* Select bit mask register */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
-
- /* Clear it */
- WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 255);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidBufferToScreenBlt(IN PUCHAR Buffer,
- IN ULONG Left,
- IN ULONG Top,
- IN ULONG Width,
- IN ULONG Height,
- IN ULONG Delta)
-{
- /* Make sure we have a width and height */
- if (!(Width) || !(Height)) return;
-
- /* Call the helper function */
- BitBlt(Left, Top, Width, Height, Buffer, 4, Delta);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidDisplayString(PUCHAR String)
-{
- ULONG TopDelta = 14;
-
- /* Start looping the string */
- while (*String)
- {
- /* Treat new-line separately */
- if (*String == '\n')
- {
- /* Modify Y position */
- curr_y += TopDelta;
- if (curr_y >= ScrollRegion[3])
- {
- /* Scroll the view */
- VgaScroll(TopDelta);
- curr_y -= TopDelta;
-
- /* Preserve row */
- PreserveRow(curr_y, TopDelta, TRUE);
- }
-
- /* Update current X */
- curr_x = ScrollRegion[0];
-
- /* Preseve the current row */
- PreserveRow(curr_y, TopDelta, FALSE);
- }
- else if (*String == '\r')
- {
- /* Update current X */
- curr_x = ScrollRegion[0];
-
- /* Check if we're being followed by a new line */
- if (String[1] != '\n') NextLine = TRUE;
- }
- else
- {
- /* Check if we had a \n\r last time */
- if (NextLine)
- {
- /* We did, preserve the current row */
- PreserveRow(curr_y, TopDelta, TRUE);
- NextLine = FALSE;
- }
-
- /* Display this character */
- DisplayCharacter(*String, curr_x, curr_y, TextColor, 16);
- curr_x += 8;
-
- /* Check if we should scroll */
- if (curr_x > ScrollRegion[2])
- {
- /* Update Y position and check if we should scroll it */
- curr_y += TopDelta;
- if (curr_y > ScrollRegion[3])
- {
- /* Do the scroll */
- VgaScroll(TopDelta);
- curr_y -= TopDelta;
-
- /* Save the row */
- PreserveRow(curr_y, TopDelta, TRUE);
- }
-
- /* Update X */
- curr_x = ScrollRegion[0];
- }
- }
-
- /* Get the next character */
- String++;
- }
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidBitBlt(PUCHAR Buffer,
- ULONG Left,
- ULONG Top)
-{
- PBITMAPINFOHEADER BitmapInfoHeader;
- LONG Delta;
- PUCHAR BitmapOffset;
-
- /* Get the Bitmap Header */
- BitmapInfoHeader = (PBITMAPINFOHEADER)Buffer;
-
- /* Initialize the palette */
- InitPaletteWithTable((PULONG)(Buffer + BitmapInfoHeader->biSize),
- (BitmapInfoHeader->biClrUsed) ?
- BitmapInfoHeader->biClrUsed : 16);
-
- /* Make sure we can support this bitmap */
- ASSERT((BitmapInfoHeader->biBitCount * BitmapInfoHeader->biPlanes) <= 4);
-
- /* Calculate the delta and align it on 32-bytes, then calculate the actual */
- /* start of the bitmap data. */
- Delta = (BitmapInfoHeader->biBitCount * BitmapInfoHeader->biWidth) + 31;
- Delta >>= 3;
- Delta &= ~3;
- BitmapOffset = Buffer + sizeof(BITMAPINFOHEADER) + 16 * sizeof(ULONG);
-
- /* Check the compression of the bitmap */
- if (BitmapInfoHeader->biCompression == 2)
- {
- /* Make sure we have a width and a height */
- if ((BitmapInfoHeader->biWidth) && (BitmapInfoHeader->biHeight))
- {
- /* We can use RLE Bit Blt */
- RleBitBlt(Left,
- Top,
- BitmapInfoHeader->biWidth,
- BitmapInfoHeader->biHeight,
- BitmapOffset);
- }
- }
- else
- {
- /* Check if the height is negative */
- if (BitmapInfoHeader->biHeight < 0)
- {
- /* Make it positive in the header */
- BitmapInfoHeader->biHeight *= -1;
- }
- else
- {
- /* Update buffer offset */
- BitmapOffset += ((BitmapInfoHeader->biHeight -1) * Delta);
- Delta *= -1;
- }
-
- /* Make sure we have a width and a height */
- if ((BitmapInfoHeader->biWidth) && (BitmapInfoHeader->biHeight))
- {
- /* Do the BitBlt */
- BitBlt(Left,
- Top,
- BitmapInfoHeader->biWidth,
- BitmapInfoHeader->biHeight,
- BitmapOffset,
- BitmapInfoHeader->biBitCount,
- Delta);
- }
- }
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidScreenToBufferBlt(PUCHAR Buffer,
- ULONG Left,
- ULONG Top,
- ULONG Width,
- ULONG Height,
- ULONG Delta)
-{
- ULONG Plane;
- ULONG XDistance;
- ULONG LeftDelta, RightDelta;
- ULONG PixelOffset;
- PUCHAR PixelPosition;
- PUCHAR k, i;
- PULONG m;
- UCHAR Value, Value2;
- UCHAR a;
- ULONG b;
- ULONG x, y;
-
- /* Calculate total distance to copy on X */
- XDistance = Left + Width - 1;
-
- /* Start at plane 0 */
- Plane = 0;
-
- /* Calculate the 8-byte left and right deltas */
- LeftDelta = Left & 7;
- RightDelta = 8 - LeftDelta;
-
- /* Clear the destination buffer */
- RtlZeroMemory(Buffer, Delta * Height);
-
- /* Calculate the pixel offset and convert the X distance into byte form */
- PixelOffset = Top * 80 + (Left >> 3);
- XDistance >>= 3;
-
- /* Loop the 4 planes */
- do
- {
- /* Set the current pixel position and reset buffer loop variable */
- PixelPosition = (PUCHAR)VgaBase + PixelOffset;
- i = Buffer;
-
- /* Set Mode 0 */
- ReadWriteMode(0);
-
- /* Set the current plane */
- __outpw(0x3CE, (Plane << 8) | 4);
-
- /* Make sure we have a height */
- if (Height > 0)
- {
- /* Start the outer Y loop */
- y = Height;
- do
- {
- /* Read the current value */
- m = (PULONG)i;
- Value = READ_REGISTER_UCHAR(PixelPosition);
-
- /* Set Pixel Position loop variable */
- k = PixelPosition + 1;
-
- /* Check if we're still within bounds */
- if (Left <= XDistance)
- {
- /* Start X Inner loop */
- x = (XDistance - Left) + 1;
- do
- {
- /* Read the current value */
- Value2 = READ_REGISTER_UCHAR(k);
-
- /* Increase pixel position */
- k++;
-
- /* Do the blt */
- a = Value2 >> (UCHAR)RightDelta;
- a |= Value << (UCHAR)LeftDelta;
- b = lookup[a & 0xF];
- a >>= 4;
- b <<= 16;
- b |= lookup[a];
-
- /* Save new value to buffer */
- *m |= (b << Plane);
-
- /* Move to next destination location */
- m++;
-
- /* Write new value */
- Value = Value2;
- } while (--x);
- }
-
- /* Update pixel position */
- PixelPosition += 80;
- i += Delta;
- } while (--y);
- }
- } while (++Plane < 4);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidSolidColorFill(IN ULONG Left,
- IN ULONG Top,
- IN ULONG Right,
- IN ULONG Bottom,
- IN UCHAR Color)
-{
- ULONG rMask, lMask;
- ULONG LeftOffset, RightOffset, Distance;
- PUCHAR Offset;
- ULONG i, j;
-
- /* Get the left and right masks, shifts, and delta */
- LeftOffset = Left >> 3;
- lMask = (lMaskTable[Left & 0x7] << 8) | 8;
- RightOffset = Right >> 3;
- rMask = (rMaskTable[Right & 0x7] << 8) | 8;
- Distance = RightOffset - LeftOffset;
-
- /* If there is no distance, then combine the right and left masks */
- if (!Distance) lMask &= rMask;
-
- /* Switch to mode 10 */
- ReadWriteMode(10);
-
- /* Clear the 4 planes (we're already in unchained mode here) */
- __outpw(0x3C4, 0xF02);
-
- /* Select the color don't care register */
- __outpw(0x3CE, 7);
-
- /* Calculate pixel position for the read */
- Offset = VgaBase + (Top * 80) + (PUCHAR)LeftOffset;
-
- /* Select the bitmask register and write the mask */
- __outpw(0x3CE, (USHORT)lMask);
-
- /* Check if the top coord is below the bottom one */
- if (Top <= Bottom)
- {
- /* Start looping each line */
- i = (Bottom - Top) + 1;
- do
- {
- /* Read the previous value and add our color */
- WRITE_REGISTER_UCHAR(Offset, READ_REGISTER_UCHAR(Offset) & Color);
-
- /* Move to the next line */
- Offset += 80;
- } while (--i);
- }
-
- /* Check if we have a delta */
- if (Distance)
- {
- /* Calculate new pixel position */
- Offset = VgaBase + (Top * 80) + (PUCHAR)RightOffset;
- Distance--;
-
- /* Select the bitmask register and write the mask */
- __outpw(0x3CE, (USHORT)rMask);
-
- /* Check if the top coord is below the bottom one */
- if (Top <= Bottom)
- {
- /* Start looping each line */
- i = (Bottom - Top) + 1;
- do
- {
- /* Read the previous value and add our color */
- WRITE_REGISTER_UCHAR(Offset,
- READ_REGISTER_UCHAR(Offset) & Color);
-
- /* Move to the next line */
- Offset += 80;
- } while (--i);
- }
-
- /* Check if we still have a delta */
- if (Distance)
- {
- /* Calculate new pixel position */
- Offset = VgaBase + (Top * 80) + (PUCHAR)(LeftOffset + 1);
-
- /* Set the bitmask to 0xFF for all 4 planes */
- __outpw(0x3CE, 0xFF08);
-
- /* Check if the top coord is below the bottom one */
- if (Top <= Bottom)
- {
- /* Start looping each line */
- i = (Bottom - Top) + 1;
- do
- {
- /* Loop the shift delta */
- if (Distance > 0)
- {
- for (j = Distance; j; Offset++, j--)
- {
- /* Write the color */
- WRITE_REGISTER_UCHAR(Offset, Color);
- }
- }
-
- /* Update position in memory */
- Offset += (80 - Distance);
- } while (--i);
- }
- }
- }
-}
-