40c03d50a36759663e0d8e1ba2d6321dea10844e
[reactos.git] / reactos / hal / halx86 / display.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 1998, 1999, 2000, 2001, 2002 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /* $Id: display.c,v 1.7 2003/08/24 11:58:16 dwelch Exp $
20 *
21 * COPYRIGHT: See COPYING in the top level directory
22 * PROJECT: ReactOS kernel
23 * FILE: ntoskrnl/hal/x86/display.c
24 * PURPOSE: Blue screen display
25 * PROGRAMMER: Eric Kohl (ekohl@rz-online.de)
26 * UPDATE HISTORY:
27 * Created 08/10/99
28 */
29
30 /* DISPLAY OWNERSHIP
31 *
32 * So, who owns the physical display and is allowed to write to it?
33 *
34 * In MS NT, upon boot HAL owns the display. Somewhere in the boot
35 * sequence (haven't figured out exactly where or by who), some
36 * component calls HalAcquireDisplayOwnership. From that moment on,
37 * the display is owned by that component and is switched to graphics
38 * mode. The display is not supposed to return to text mode, except
39 * in case of a bug check. The bug check will call HalDisplayString
40 * to output a string to the text screen. HAL will notice that it
41 * currently doesn't own the display and will re-take ownership, by
42 * calling the callback function passed to HalAcquireDisplayOwnership.
43 * After the bugcheck, execution is halted. So, under NT, the only
44 * possible sequence of display modes is text mode -> graphics mode ->
45 * text mode (the latter hopefully happening very infrequently).
46 *
47 * Things are a little bit different in the current state of ReactOS.
48 * We want to have a functional interactive text mode. We should be
49 * able to switch from text mode to graphics mode when a GUI app is
50 * started and switch back to text mode when it's finished. Then, when
51 * another GUI app is started, another switch to and from graphics mode
52 * is possible. Also, when the system bugchecks in graphics mode we want
53 * to switch back to text mode to show the registers and stack trace.
54 * Last but not least, HalDisplayString is used a lot more in ReactOS,
55 * e.g. to print debug messages when the /DEBUGPORT=SCREEN boot option
56 * is present.
57 * 3 Components are involved in Reactos: HAL, BLUE.SYS and VIDEOPRT.SYS.
58 * As in NT, on boot HAL owns the display. When entering the text mode
59 * command interpreter, BLUE.SYS kicks in. It will write directly to the
60 * screen, more or less behind HALs back.
61 * When a GUI app is started, WIN32K.SYS will open the DISPLAY device.
62 * This open call will end up in VIDEOPRT.SYS. That component will then
63 * take ownership of the display by calling HalAcquireDisplayOwnership.
64 * When the GUI app terminates (WIN32K.SYS will close the DISPLAY device),
65 * we want to give ownership of the display back to HAL. Using the
66 * standard exported HAL functions, that's a bit of a problem, because
67 * there is no function defined to do that. In NT, this is handled by
68 * HalDisplayString, but that solution isn't satisfactory in ReactOS,
69 * because HalDisplayString is (in some cases) also used to output debug
70 * messages. If we do it the NT way, the first debug message output while
71 * in graphics mode would switch the display back to text mode.
72 * So, instead, if HalDisplayString detects that HAL doesn't have ownership
73 * of the display, it doesn't do anything.
74 * To return ownership to HAL, a new function is exported,
75 * HalReleaseDisplayOwnership. This function is called by the DISPLAY
76 * device Close routine in VIDEOPRT.SYS. It is also called at the beginning
77 * of a bug check, so HalDisplayString is activated again.
78 * Now, while the display is in graphics mode (not owned by HAL), BLUE.SYS
79 * should also refrain from writing to the screen buffer. The text mode
80 * screen buffer might overlap the graphics mode screen buffer, so changing
81 * something in the text mode buffer might mess up the graphics screen. To
82 * allow BLUE.SYS to detect if HAL owns the display, another new function is
83 * exported, HalQueryDisplayOwnership. BLUE.SYS will call this function to
84 * check if it's allowed to touch the text mode buffer.
85 *
86 * In an ideal world, when HAL takes ownership of the display, it should set
87 * up the CRT using real-mode (actually V86 mode, but who cares) INT 0x10
88 * calls. Unfortunately, this will require HAL to setup a real-mode interrupt
89 * table etc. So, we chickened out of that by having the loader set up the
90 * display before switching to protected mode. If HAL is given back ownership
91 * after a GUI app terminates, the INT 0x10 calls are made by VIDEOPRT.SYS,
92 * since there is already support for them via the VideoPortInt10 routine.
93 */
94
95 #include <ddk/ntddk.h>
96 #include <mps.h>
97
98 #define SCREEN_SYNCHRONIZATION
99
100 #define VGA_AC_INDEX 0x3c0
101 #define VGA_AC_READ 0x3c0
102 #define VGA_AC_WRITE 0x3c1
103
104 #define VGA_MISC_WRITE 0x3c2
105
106 #define VGA_SEQ_INDEX 0x3c4
107 #define VGA_SEQ_DATA 0x3c5
108
109 #define VGA_DAC_READ_INDEX 0x3c7
110 #define VGA_DAC_WRITE_INDEX 0x3c8
111 #define VGA_DAC_DATA 0x3c9
112
113 #define VGA_MISC_READ 0x3cc
114
115 #define VGA_GC_INDEX 0x3ce
116 #define VGA_GC_DATA 0x3cf
117
118 #define VGA_CRTC_INDEX 0x3d4
119 #define VGA_CRTC_DATA 0x3d5
120
121 #define VGA_INSTAT_READ 0x3da
122
123 #define VGA_SEQ_NUM_REGISTERS 5
124 #define VGA_CRTC_NUM_REGISTERS 25
125 #define VGA_GC_NUM_REGISTERS 9
126 #define VGA_AC_NUM_REGISTERS 21
127
128 #define CRTC_COLUMNS 0x01
129 #define CRTC_OVERFLOW 0x07
130 #define CRTC_ROWS 0x12
131 #define CRTC_SCANLINES 0x09
132
133 #define CRTC_CURHI 0x0e
134 #define CRTC_CURLO 0x0f
135
136
137 #define CHAR_ATTRIBUTE_BLACK 0x00 /* black on black */
138 #define CHAR_ATTRIBUTE 0x17 /* grey on blue */
139
140
141 /* VARIABLES ****************************************************************/
142
143 static ULONG CursorX = 0; /* Cursor Position */
144 static ULONG CursorY = 0;
145 static ULONG SizeX = 80; /* Display size */
146 static ULONG SizeY = 25;
147
148 static BOOLEAN DisplayInitialized = FALSE;
149 static BOOLEAN HalOwnsDisplay = TRUE;
150
151 static WORD *VideoBuffer = NULL;
152
153 static PHAL_RESET_DISPLAY_PARAMETERS HalResetDisplayParameters = NULL;
154
155 static UCHAR TextPalette[64][3] =
156 {
157 {0, 0, 0} /* 0 */,
158 {0, 0, 42} /* 1 */,
159 {0, 42, 0} /* 2 */,
160 {0, 42, 42} /* 3 */,
161 {42, 0, 0} /* 4 */,
162 {42, 42, 42} /* 5 */,
163 {42, 42, 0} /* 6 */,
164 {42, 42, 42} /* 7 */,
165 {0, 0, 21} /* 8 */,
166 {0, 0, 63} /* 9 */,
167 {0, 42, 21} /* 10 */,
168 {0, 42, 63} /* 11 */,
169 {42, 0, 21} /* 12 */,
170 {42, 0, 63} /* 13 */,
171 {42, 42, 21} /* 14 */,
172 {42, 42, 63} /* 15 */,
173 {0, 21, 0} /* 16 */,
174 {0, 21, 42} /* 17 */,
175 {0, 63, 0} /* 18 */,
176 {0, 63, 42} /* 19 */,
177 {42, 21, 0} /* 20 */,
178 {42, 21, 42} /* 21 */,
179 {42, 63, 0} /* 22 */,
180 {42, 63, 42} /* 23 */,
181 {0, 21, 21} /* 24 */,
182 {0, 21, 63} /* 25 */,
183 {0, 63, 21} /* 26 */,
184 {0, 63, 63} /* 27 */,
185 {42, 21, 21} /* 28 */,
186 {42, 21, 63} /* 29 */,
187 {42, 63, 21} /* 30 */,
188 {42, 63, 63} /* 31 */,
189 {21, 0, 0} /* 32 */,
190 {21, 0, 42} /* 33 */,
191 {21, 42, 0} /* 34 */,
192 {21, 42, 42} /* 35 */,
193 {63, 0, 0} /* 36 */,
194 {63, 0, 42} /* 37 */,
195 {63, 42, 0} /* 38 */,
196 {63, 42, 42} /* 39 */,
197 {21, 0, 21} /* 40 */,
198 {21, 0, 63} /* 41 */,
199 {21, 42, 21} /* 42 */,
200 {21, 42, 63} /* 43 */,
201 {63, 42, 0} /* 44 */,
202 {63, 0, 63} /* 45 */,
203 {63, 42, 21} /* 46 */,
204 {63, 42, 63} /* 47 */,
205 {21, 21, 0} /* 48 */,
206 {21, 21, 42} /* 49 */,
207 {21, 63, 0} /* 50 */,
208 {21, 63, 42} /* 51 */,
209 {63, 21, 0} /* 52 */,
210 {63, 21, 42} /* 53 */,
211 {63, 63, 0} /* 54 */,
212 {63, 63, 42} /* 55 */,
213 {21, 21, 21} /* 56 */,
214 {21, 21, 63} /* 57 */,
215 {21, 63, 21} /* 58 */,
216 {21, 63, 63} /* 59 */,
217 {63, 21, 21} /* 60 */,
218 {63, 21, 63} /* 61 */,
219 {63, 63, 21} /* 62 */,
220 {63, 63, 63} /* 63 */,
221 };
222
223 static UCHAR Text80x25Registers[] =
224 {
225 /* MISC */
226 0x67,
227 /* SEQ */
228 0x03, 0x00, 0x03, 0x00, 0x02,
229 /* CRTC */
230 0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F,
231 0x00, 0x4F, 0x0D, 0x0E, 0x00, 0x00, 0x00, 0x50,
232 0x9C, 0x0E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3,
233 0xFF,
234 /* GC */
235 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0E, 0x00,
236 0xFF,
237 /* AC */
238 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07,
239 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
240 0x0C, 0x00, 0x0F, 0x08, 0x00
241 };
242
243 static UCHAR Text80x50Registers[] =
244 {
245 /* MISC */
246 0x67,
247 /* SEQ */
248 0x03, 0x00, 0x03, 0x00, 0x02,
249 /* CRTC */
250 0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F,
251 0x00, 0x47, 0x06, 0x07, 0x00, 0x00, 0x01, 0x40,
252 0x9C, 0x8E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3,
253 0xFF,
254 /* GC */
255 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0E, 0x00,
256 0xFF,
257 /* AC */
258 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07,
259 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
260 0x0C, 0x00, 0x0F, 0x08, 0x00,
261 };
262
263
264 /* STATIC FUNCTIONS *********************************************************/
265
266 VOID
267 HalClearDisplay (UCHAR CharAttribute)
268 {
269 WORD *ptr = (WORD*)VideoBuffer;
270 ULONG i;
271
272 for (i = 0; i < SizeX * SizeY; i++, ptr++)
273 *ptr = ((CharAttribute << 8) + ' ');
274
275 CursorX = 0;
276 CursorY = 0;
277 }
278
279
280 VOID
281 HalScrollDisplay (VOID)
282 {
283 WORD *ptr;
284 int i;
285
286 ptr = VideoBuffer + SizeX;
287 RtlMoveMemory(VideoBuffer,
288 ptr,
289 SizeX * (SizeY - 1) * 2);
290
291 ptr = VideoBuffer + (SizeX * (SizeY - 1));
292 for (i = 0; i < SizeX; i++, ptr++)
293 {
294 *ptr = (CHAR_ATTRIBUTE << 8) + ' ';
295 }
296 }
297
298
299 static VOID
300 HalPutCharacter (CHAR Character)
301 {
302 WORD *ptr;
303
304 ptr = VideoBuffer + ((CursorY * SizeX) + CursorX);
305 *ptr = (CHAR_ATTRIBUTE << 8) + Character;
306 }
307
308 VOID STATIC
309 HalSetDisplayMode(PUCHAR Registers)
310 {
311 UCHAR Port;
312 ULONG i;
313
314 /* Write MISC register. */
315 WRITE_PORT_UCHAR((PUCHAR)VGA_MISC_WRITE, *Registers);
316 Registers++;
317 /* Write SEQUENCER registers. */
318 for (i = 0; i < VGA_SEQ_NUM_REGISTERS; i++)
319 {
320 WRITE_PORT_UCHAR((PUCHAR)VGA_SEQ_INDEX, i);
321 WRITE_PORT_UCHAR((PUCHAR)VGA_SEQ_DATA, *Registers);
322 Registers++;
323 }
324 /* Unlock CRTC registers. */
325 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, 0x03);
326 Port = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA);
327 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA, Port | 0x80);
328 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, 0x11);
329 Port = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA);
330 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA, Port & ~0x80);
331 /* Make sure they stay unlocked. */
332 Registers[0x03] |= 0x80;
333 Registers[0x11] &= ~0x80;
334 /* Write CRTC registers. */
335 for (i = 0; i < VGA_CRTC_NUM_REGISTERS; i++)
336 {
337 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, i);
338 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA, *Registers);
339 Registers++;
340 }
341 /* Write GC registers. */
342 for (i = 0; i < VGA_GC_NUM_REGISTERS; i++)
343 {
344 WRITE_PORT_UCHAR((PUCHAR)VGA_GC_INDEX, i);
345 WRITE_PORT_UCHAR((PUCHAR)VGA_GC_DATA, *Registers);
346 Registers++;
347 }
348 /* Write AC registers. */
349 for (i = 0; i < VGA_AC_NUM_REGISTERS; i++)
350 {
351 (VOID)READ_PORT_UCHAR((PUCHAR)VGA_INSTAT_READ);
352 WRITE_PORT_UCHAR((PUCHAR)VGA_AC_INDEX, i);
353 WRITE_PORT_UCHAR((PUCHAR)VGA_AC_WRITE, *Registers);
354 Registers++;
355 }
356 /* Reset palette. */
357 for (i = 0; i < 64; i++)
358 {
359 WRITE_PORT_UCHAR((PUCHAR)0x03c8, i);
360 WRITE_PORT_UCHAR((PUCHAR)0x03c9, TextPalette[i][0]);
361 WRITE_PORT_UCHAR((PUCHAR)0x03c9, TextPalette[i][1]);
362 WRITE_PORT_UCHAR((PUCHAR)0x03c9, TextPalette[i][2]);
363 }
364 /* Lock 16-colour palette and unblank display. */
365 (VOID)READ_PORT_UCHAR((PUCHAR)VGA_INSTAT_READ);
366 WRITE_PORT_UCHAR((PUCHAR)VGA_AC_INDEX, 0x20);
367 }
368
369 /* PRIVATE FUNCTIONS ********************************************************/
370
371 VOID
372 HalInitializeDisplay (PLOADER_PARAMETER_BLOCK LoaderBlock)
373 /*
374 * FUNCTION: Initalize the display
375 * ARGUMENTS:
376 * InitParameters = Parameters setup by the boot loader
377 */
378 {
379 if (DisplayInitialized == FALSE)
380 {
381 ULONG ScanLines;
382 ULONG Data;
383
384 VideoBuffer = (WORD *)(0xd0000000 + 0xb8000);
385 // VideoBuffer = HalMapPhysicalMemory (0xb8000, 2);
386
387 /* Set cursor position */
388 // CursorX = LoaderBlock->cursorx;
389 // CursorY = LoaderBlock->cursory;
390 CursorX = 0;
391 CursorY = 0;
392
393 /* read screen size from the crtc */
394 /* FIXME: screen size should be read from the boot parameters */
395 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_COLUMNS);
396 SizeX = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA) + 1;
397 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_ROWS);
398 SizeY = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA);
399 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_OVERFLOW);
400 Data = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA);
401 SizeY |= (((Data & 0x02) << 7) | ((Data & 0x40) << 3));
402 SizeY++;
403 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_SCANLINES);
404 ScanLines = (READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA) & 0x1F) + 1;
405 SizeY = SizeY / ScanLines;
406
407 #ifdef BOCHS_30ROWS
408 SizeY=30;
409 #endif
410 HalClearDisplay(CHAR_ATTRIBUTE_BLACK);
411
412 DisplayInitialized = TRUE;
413 }
414 }
415
416
417 /* PUBLIC FUNCTIONS *********************************************************/
418
419 VOID STDCALL
420 HalReleaseDisplayOwnership()
421 /*
422 * FUNCTION: Release ownership of display back to HAL
423 */
424 {
425 if (HalResetDisplayParameters == NULL)
426 return;
427
428 if (HalOwnsDisplay == TRUE)
429 return;
430
431 if (!HalResetDisplayParameters(SizeX, SizeY))
432 {
433 if (SizeX == 80 && SizeY == 25)
434 {
435 HalSetDisplayMode(Text80x25Registers);
436 }
437 else
438 {
439 SizeX = 80;
440 SizeY = 50;
441 HalSetDisplayMode(Text80x50Registers);
442 }
443 }
444 HalOwnsDisplay = TRUE;
445 HalClearDisplay(CHAR_ATTRIBUTE);
446 }
447
448
449 VOID STDCALL
450 HalAcquireDisplayOwnership(IN PHAL_RESET_DISPLAY_PARAMETERS ResetDisplayParameters)
451 /*
452 * FUNCTION:
453 * ARGUMENTS:
454 * ResetDisplayParameters = Pointer to a driver specific
455 * reset routine.
456 */
457 {
458 HalOwnsDisplay = FALSE;
459 HalResetDisplayParameters = ResetDisplayParameters;
460 }
461
462 VOID STDCALL
463 HalDisplayString(IN PCH String)
464 /*
465 * FUNCTION: Switches the screen to HAL console mode (BSOD) if not there
466 * already and displays a string
467 * ARGUMENT:
468 * string = ASCII string to display
469 * NOTE: Use with care because there is no support for returning from BSOD
470 * mode
471 */
472 {
473 PCH pch;
474 #ifdef SCREEN_SYNCHRONIZATION
475 int offset;
476 #endif
477 static KSPIN_LOCK Lock;
478 ULONG Flags;
479
480 /* See comment at top of file */
481 if (! HalOwnsDisplay)
482 {
483 return;
484 }
485
486 pch = String;
487
488 pushfl(Flags);
489 __asm__ ("cli\n\t");
490 KeAcquireSpinLockAtDpcLevel(&Lock);
491
492 #if 0
493 if (HalOwnsDisplay == FALSE)
494 {
495 HalReleaseDisplayOwnership();
496 }
497 #endif
498
499 #ifdef SCREEN_SYNCHRONIZATION
500 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_CURHI);
501 offset = READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA)<<8;
502 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_CURLO);
503 offset += READ_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA);
504
505 CursorY = offset / SizeX;
506 CursorX = offset % SizeX;
507 #endif
508
509 while (*pch != 0)
510 {
511 if (*pch == '\n')
512 {
513 CursorY++;
514 CursorX = 0;
515 }
516 else if (*pch != '\r')
517 {
518 HalPutCharacter (*pch);
519 CursorX++;
520
521 if (CursorX >= SizeX)
522 {
523 CursorY++;
524 CursorX = 0;
525 }
526 }
527
528 if (CursorY >= SizeY)
529 {
530 HalScrollDisplay ();
531 CursorY = SizeY - 1;
532 }
533
534 pch++;
535 }
536
537 #ifdef SCREEN_SYNCHRONIZATION
538 offset = (CursorY * SizeX) + CursorX;
539
540 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_CURLO);
541 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA, offset & 0xff);
542 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_INDEX, CRTC_CURHI);
543 WRITE_PORT_UCHAR((PUCHAR)VGA_CRTC_DATA, (offset >> 8) & 0xff);
544 #endif
545 KeReleaseSpinLockFromDpcLevel(&Lock);
546 popfl(Flags);
547 }
548
549 VOID STDCALL
550 HalQueryDisplayParameters(OUT PULONG DispSizeX,
551 OUT PULONG DispSizeY,
552 OUT PULONG CursorPosX,
553 OUT PULONG CursorPosY)
554 {
555 if (DispSizeX)
556 *DispSizeX = SizeX;
557 if (DispSizeY)
558 *DispSizeY = SizeY;
559 if (CursorPosX)
560 *CursorPosX = CursorX;
561 if (CursorPosY)
562 *CursorPosY = CursorY;
563 }
564
565
566 VOID STDCALL
567 HalSetDisplayParameters(IN ULONG CursorPosX,
568 IN ULONG CursorPosY)
569 {
570 CursorX = (CursorPosX < SizeX) ? CursorPosX : SizeX - 1;
571 CursorY = (CursorPosY < SizeY) ? CursorPosY : SizeY - 1;
572 }
573
574 BOOLEAN STDCALL
575 HalQueryDisplayOwnership()
576 {
577 return ! HalOwnsDisplay;
578 }
579
580 /* EOF */