NT4/private/ntos/nthals/halx86/i386/xxdisp.c

/*++

Copyright (c) 1991  Microsoft Corporation

Module Name:

    xxdisp.c

Abstract:

    This module implements the HAL display initialization and output routines
    for a x86 system.

Author:

    David N. Cutler (davec) 27-Apr-1991

Environment:

    Kernel mode

Revision History:

--*/

#include "halp.h"

//
// Private function prototypes
//
VOID
HalpClearDisplay(
    VOID
    );

VOID
HalpNextLine(
    VOID
    );

VOID
HalpScrollDisplay(
    VOID
    );

VOID
HalpPutCharacter(
    IN UCHAR Character
    );

#define REVERSE_ATTRIBUTE 0x17
#define ROWS 50
#define COLS 80

ULONG HalpCursorX=0;
ULONG HalpCursorY=0;

KSPIN_LOCK HalpDisplayLock;


PUSHORT VideoBuffer;

//
// If someone calls HalDisplayString before HalInitSystem, we need to be
// able to put something up on screen anyway.
//
BOOLEAN HalpDisplayInitialized=FALSE;

//
// This is how we tell if GDI has taken over the display.  If so, we are
// in graphics mode and we need to reset the display to text mode before
// displaying anything.  (Panic stop)
//
BOOLEAN HalpOwnsDisplay=TRUE;
PHAL_RESET_DISPLAY_PARAMETERS HalpResetDisplayParameters;

BOOLEAN HalpDoingCrashDump = FALSE;


VOID
HalAcquireDisplayOwnership (
    IN PHAL_RESET_DISPLAY_PARAMETERS  ResetDisplayParameters
    )

/*++

Routine Description:

    This routine switches ownership of the display away from the HAL to
    the system display driver. It is called when the system has reached
    a point during bootstrap where it is self supporting and can output
    its own messages. Once ownership has passed to the system display
    driver any attempts to output messages using HalDisplayString must
    result in ownership of the display reverting to the HAL and the
    display hardware reinitialized for use by the HAL.

Arguments:

    ResetDisplayParameters - if non-NULL the address of a function
    the hal can call to reset the video card.  The function returns
    TRUE if the display was reset.

Return Value:

    None.

--*/

{
    HalpResetDisplayParameters=ResetDisplayParameters;
    HalpOwnsDisplay=FALSE;
    return;
}

VOID
HalpVideoReboot()
{
    if (HalpResetDisplayParameters && !HalpOwnsDisplay) {
        //
        // Video work-around.  The video driver has a reset function,
        // call it before resetting the system in case the bios doesn't
        // know how to reset the displays video mode.
        //

        if (HalpResetDisplayParameters(COLS, ROWS)) {
            // display was reset, make sure it's blank
            HalpClearDisplay();
        }
    }
}



VOID
HalpInitializeDisplay(
    VOID
    )

/*++

Routine Description:

    Initializes the VGA display.  This uses HalpMapPhysicalMemory to map
    the video buffer at 0xb8000 - 0xba000 into high virtual memory.

Arguments:

    None.

Return Value:

    None.

--*/

{

    if (HalpDisplayInitialized == FALSE) {

        HalpDisplayInitialized = TRUE;

        KeInitializeSpinLock(&HalpDisplayLock);

        //
        // If somebody called HalDisplayString before Phase 0 initialization,
        // the video buffer has already been mapped and cleared, and a
        // message has already been displayed.  So we don't want to clear
        // the screen again, or map the screen again.
        //

        //
        // Map two pages of memory starting at physical address 0xb8000.
        //

        VideoBuffer = (PUSHORT)HalpMapPhysicalMemory((PVOID)0xb8000,2);

        HalpClearDisplay();
    }
}

VOID
HalDisplayString (
    PUCHAR String
    )

/*++

Routine Description:

    This routine displays a character string on the display screen.

Arguments:

    String - Supplies a pointer to the characters that are to be displayed.

Return Value:

    None.

--*/

{
    if (!HalpDisplayInitialized && HalpOwnsDisplay) {

        //
        // If somebody has called HalDisplayString before Phase 0
        // initialization, we need to make sure we get our message out
        // anyway.  So we initialize the display before HalInitSystem does.
        // HalpInitializeDisplay is smart enough to only map the video
        // buffer and clear the screen the first time it is called.
        //

        HalpInitializeDisplay();
    }

    //
    // Synchronize access to the display so that MP systems won't
    // get garbage output due to simultaneous calls.  It also prevents
    // two processors from attempting to call BIOS and reset the display
    // simultaneously.
    //

    KiAcquireSpinLock(&HalpDisplayLock);

    if (HalpOwnsDisplay == FALSE) {

        //
        // The display has been put in graphics mode, and we need to
        // reset it to text mode before we can display any text on it.
        //

        if (HalpResetDisplayParameters) {
            HalpOwnsDisplay = HalpResetDisplayParameters(COLS, ROWS);
        }

        if (HalpOwnsDisplay == FALSE) {
            HalpBiosDisplayReset();
        }

        HalpOwnsDisplay = TRUE;
        HalpDoingCrashDump = TRUE;
        HalpClearDisplay();
    }

    while (*String) {

        switch (*String) {
            case '\n':
                HalpNextLine();
                break;
            case '\r':
                HalpCursorX = 0;
                break;
            default:
                HalpPutCharacter(*String);
                if (++HalpCursorX == COLS) {
                    HalpNextLine();
                }
        }
        ++String;
    }

    KiReleaseSpinLock(&HalpDisplayLock);
    return;
}

VOID
HalpDisplayDebugStatus (
    PUCHAR str,
    ULONG  len
    )
{
    PUSHORT p;

    if (!HalpDisplayInitialized || !HalpOwnsDisplay) {
        return;
    }

    for (p = &VideoBuffer [COLS - len]; len; str++, p++, len--) {
        *p = (USHORT)((REVERSE_ATTRIBUTE << 8) | *str);
    }
}

VOID
HalQueryDisplayParameters (
    OUT PULONG WidthInCharacters,
    OUT PULONG HeightInLines,
    OUT PULONG CursorColumn,
    OUT PULONG CursorRow
    )
/*++

Routine Description:

    This routine return information about the display area and current
    cursor position.

Arguments:

    WidthInCharacter - Supplies a pointer to a varible that receives
        the width of the display area in characters.

    HeightInLines - Supplies a pointer to a variable that receives the
        height of the display area in lines.

    CursorColumn - Supplies a pointer to a variable that receives the
        current display column position.

    CursorRow - Supplies a pointer to a variable that receives the
        current display row position.

Return Value:

    None.

--*/
{
    *WidthInCharacters = COLS;
    *HeightInLines = ROWS;
    *CursorColumn = HalpCursorX;
    *CursorRow = HalpCursorX;

}

VOID
HalSetDisplayParameters (
    IN ULONG CursorColumn,
    IN ULONG CursorRow
    )
/*++

Routine Description:

    This routine set the current cursor position on the display area.

Arguments:

    CursorColumn - Supplies the new display column position.

    CursorRow - Supplies a the new display row position.

Return Value:

    None.

--*/
{
    HalpCursorX = CursorColumn >= COLS ? COLS-1 : CursorColumn;
    HalpCursorY = CursorRow >= ROWS ? ROWS-1 : CursorRow;
}

VOID
HalpNextLine(
    VOID
    )

/*++

Routine Description:

    Moves the cursor to the start of the next line, scrolling if necessary.

Arguments:

    None.

Return Value:

    None.

--*/

{
    if (HalpCursorY==ROWS-1) {
        HalpScrollDisplay();
    } else {
        ++HalpCursorY;
    }
    HalpCursorX = 0;
}

VOID
HalpScrollDisplay(
    VOID
    )

/*++

Routine Description:

    Scrolls the text on the display up one line.

Arguments:

    None

Return Value:

    None.

--*/

{
    PUSHORT NewStart;
    ULONG i;


    NewStart = VideoBuffer+COLS;
    RtlMoveMemory(VideoBuffer, NewStart, (ROWS-1)*COLS*sizeof(USHORT));

    for (i=(ROWS-1)*COLS; i<ROWS*COLS; i++) {
        VideoBuffer[i] = (REVERSE_ATTRIBUTE << 8) | ' ';
    }
}

VOID
HalpPutCharacter(
    IN UCHAR Character
    )

/*++

Routine Description:

    Places a character on the console screen.  It uses the variables
    HalpCursorX and HalpCursorY to determine the character's location.

Arguments:

    Character - Supplies the character to be displayed

Return Value:

    None.

--*/

{
    VideoBuffer[HalpCursorY*COLS + HalpCursorX] =
            (USHORT)((REVERSE_ATTRIBUTE << 8) | Character);
}

VOID
HalpClearDisplay(
    VOID
    )

/*++

Routine Description:

    Clears the video display and sets the current cursor position to the
    upper left-hand corner.

Arguments:

    None

Return Value:

    None.

--*/

{
    USHORT Attribute;
    ULONG i;

    Attribute = (REVERSE_ATTRIBUTE << 8) | ' ';
    for (i=0; i < ROWS*COLS; i++) {
       VideoBuffer[i] = Attribute;
    }
    HalpCursorX=0;
    HalpCursorY=0;

}