kdterminal.c File Reference

#include <ntoskrnl.h>
#include "kd.h"
#include "kdterminal.h"

Include dependency graph for kdterminal.c:

Go to the source code of this file.

Macros
#define	KdbpGetCharKeyboard(ScanCode)   KdbpTryGetCharKeyboard((ScanCode), 0)
#define	KdbpGetCharSerial()   KdbpTryGetCharSerial(0)

Functions
CHAR	KdbpTryGetCharKeyboard (PULONG ScanCode, ULONG Retry)
CHAR	KdbpTryGetCharSerial (_In_ ULONG Retry)
VOID	KdbpSendCommandSerial (_In_ PCSTR Command)
BOOLEAN	KdpInitTerminal (VOID)
	Initializes the controlling terminal.
BOOLEAN	KdpUpdateTerminalSize (_Out_ PSIZE TermSize)
VOID	KdpFlushTerminalInput (VOID)
	Flushes terminal input (either serial or PS/2).
CHAR	KdpReadTermKey (_Out_ PULONG ScanCode)
	Reads one character from the terminal. This function returns a scan code even when reading is done from a serial terminal.

Variables
ULONG	KdbDebugState = 0
SIZE	KdTermSize = {0,0}
BOOLEAN	KdTermConnected = FALSE
BOOLEAN	KdTermSerial = FALSE
BOOLEAN	KdTermReportsSize = TRUE
static CHAR	KdTermNextKey = ANSI_NULL

Macro Definition Documentation

KdbpGetCharKeyboard

#define KdbpGetCharKeyboard

(

ScanCode

)

KdbpTryGetCharKeyboard((ScanCode), 0)

Definition at line 15 of file kdterminal.c.

KdbpGetCharSerial

#define KdbpGetCharSerial

(

)

KdbpTryGetCharSerial(0)

Definition at line 19 of file kdterminal.c.

Function Documentation

KdbpSendCommandSerial()

VOID KdbpSendCommandSerial

(

_In_ PCSTR

Command

)

Definition at line 17 of file kdserial.c.

{
    while (*Command)
        KdPortPutByteEx(&SerialPortInfo, *Command++);
}

Referenced by KdpInitTerminal(), and KdpUpdateTerminalSize().

KdbpTryGetCharKeyboard()

CHAR KdbpTryGetCharKeyboard	(	PULONG	ScanCode,
		ULONG	Retry
	)

Definition at line 104 of file kdps2kbd.c.

{
    static byte_t last_key = 0;
    static byte_t shift = 0;
    char c;
    BOOLEAN KeepRetrying = (Retry == 0);
 
    while (KeepRetrying || Retry-- > 0)
    {
        while (kbd_read_status() & KBD_STAT_OBF)
        {
            byte_t scancode;
 
            scancode = kbd_read_input();
 
            /* check for SHIFT-keys */
            if (((scancode & 0x7F) == 42) || ((scancode & 0x7F) == 54))
            {
                shift = !(scancode & 0x80);
                continue;
            }
 
            /* ignore all other RELEASED-codes */
            if (scancode & 0x80)
            {
                last_key = 0;
            }
            else if (last_key != scancode)
            {
                //printf("kbd: %d, %d, %c\n", scancode, last_key, keyb_layout[shift][scancode]);
                last_key = scancode;
                c = keyb_layout[shift][scancode];
                *ScanCode = scancode;
 
                if (c > 0)
                    return c;
            }
        }
    }
 
    return -1;
}

Referenced by KdpFlushTerminalInput(), and KdpReadTermKey().

KdbpTryGetCharSerial()

CHAR KdbpTryGetCharSerial

(

_In_ ULONG

Retry

)

Definition at line 25 of file kdserial.c.

{
    CHAR Result = -1;
 
    if (Retry == 0)
        while (!KdPortGetByteEx(&SerialPortInfo, (PUCHAR)&Result));
    else
        while (!KdPortGetByteEx(&SerialPortInfo, (PUCHAR)&Result) && Retry-- > 0);
 
    return Result;
}

Referenced by KdpFlushTerminalInput(), KdpInitTerminal(), KdpReadTermKey(), and KdpUpdateTerminalSize().

KdpFlushTerminalInput()

VOID KdpFlushTerminalInput

(

VOID

)

Flushes terminal input (either serial or PS/2).

Definition at line 197 of file kdterminal.c.

{
    KdTermNextKey = ANSI_NULL;
    if (KdbDebugState & KD_DEBUG_KDSERIAL)
    {
        while (KdbpTryGetCharSerial(1) != -1);
    }
    else
    {
        ULONG ScanCode;
        while (KdbpTryGetCharKeyboard(&ScanCode, 1) != -1);
    }
}

Referenced by KdIoReadLine(), KdpInitTerminal(), and KdpUpdateTerminalSize().

KdpInitTerminal()

BOOLEAN KdpInitTerminal

(

VOID

)

Initializes the controlling terminal.

Returns

TRUE if the controlling terminal is serial and detected as being connected, or FALSE if not.

Definition at line 51 of file kdterminal.c.

{
    /* Determine whether the controlling terminal is a serial terminal:
     * serial output is enabled *and* KDSERIAL is set (i.e. user input
     * through serial). */
    KdTermSerial =
#if 0
    // Old logic where KDSERIAL also enables serial output.
    (KdbDebugState & KD_DEBUG_KDSERIAL) ||
    (KdpDebugMode.Serial && !KdpDebugMode.Screen);
#else
    // New logic where KDSERIAL does not necessarily enable serial output.
    KdpDebugMode.Serial &&
    ((KdbDebugState & KD_DEBUG_KDSERIAL) || !KdpDebugMode.Screen);
#endif
 
    /* Flush the input buffer */
    KdpFlushTerminalInput();
 
    if (KdTermSerial)
    {
        ULONG Length;
 
        /* Enable line-wrap */
        KdbpSendCommandSerial("\x1b[?7h");
 
        /*
         * Query terminal type.
         * Historically it was done with CTRL-E ('\x05'), however nowadays
         * terminals respond to it with an empty (or a user-configurable)
         * string. Instead, use the VT52-compatible 'ESC Z' sequence or the
         * VT100-compatible 'ESC[c' one.
         */
        KdbpSendCommandSerial("\x1b[c");
        KeStallExecutionProcessor(100000);
 
        Length = 0;
        for (;;)
        {
            /* Verify we get an answer, but don't care about it */
            if (KdbpTryGetCharSerial(5000) == -1)
                break;
            ++Length;
        }
 
        /* Terminal is connected (TRUE) or not connected (FALSE) */
        KdTermConnected = (Length > 0);
    }
    else
    {
        /* Terminal is not serial, assume it's *not* connected */
        KdTermConnected = FALSE;
    }
    return KdTermConnected;
}

Referenced by KdbpPagerInternal().

KdpReadTermKey()

CHAR KdpReadTermKey

(

_Out_ PULONG

ScanCode

)

Reads one character from the terminal. This function returns a scan code even when reading is done from a serial terminal.

Definition at line 217 of file kdterminal.c.

{
    CHAR Key;
 
    *ScanCode = 0;
 
    if (KdbDebugState & KD_DEBUG_KDSERIAL)
    {
        Key = (!KdTermNextKey ? KdbpGetCharSerial() : KdTermNextKey);
        KdTermNextKey = ANSI_NULL;
        if (Key == KEY_ESC) /* ESC */
        {
            Key = KdbpGetCharSerial();
            if (Key == '[')
            {
                Key = KdbpGetCharSerial();
                switch (Key)
                {
                    case 'A':
                        *ScanCode = KEY_SCAN_UP;
                        break;
                    case 'B':
                        *ScanCode = KEY_SCAN_DOWN;
                        break;
                    case 'C':
                        break;
                    case 'D':
                        break;
                }
            }
        }
    }
    else
    {
        Key = (!KdTermNextKey ? KdbpGetCharKeyboard(ScanCode) : KdTermNextKey);
        KdTermNextKey = ANSI_NULL;
    }
 
    /* Check for return */
    if (Key == '\r')
    {
        /*
         * We might need to discard the next '\n' which most clients
         * should send after \r. Wait a bit to make sure we receive it.
         */
        KeStallExecutionProcessor(100000);
 
        if (KdbDebugState & KD_DEBUG_KDSERIAL)
            KdTermNextKey = KdbpTryGetCharSerial(5);
        else
            KdTermNextKey = KdbpTryGetCharKeyboard(ScanCode, 5);
 
        if (KdTermNextKey == '\n' || KdTermNextKey == -1) /* \n or no response at all */
            KdTermNextKey = ANSI_NULL;
    }
 
    return Key;
}

Referenced by KdbpPagerInternal(), and KdIoReadLine().

KdpUpdateTerminalSize()

BOOLEAN KdpUpdateTerminalSize

(

_Out_ PSIZE

TermSize

)

Definition at line 108 of file kdterminal.c.

{
    static CHAR Buffer[128];
    CHAR c;
    LONG NumberOfCols = -1; // Or initialize to TermSize->cx ??
    LONG NumberOfRows = -1; // Or initialize to TermSize->cy ??
 
    /* Retrieve the size of the controlling terminal only when it is serial */
    if (KdTermConnected && KdTermSerial && KdTermReportsSize)
    {
        /* Flush the input buffer */
        KdpFlushTerminalInput();
 
        /* Try to query the terminal size. A reply looks like "\x1b[8;24;80t" */
        KdTermReportsSize = FALSE;
        KdbpSendCommandSerial("\x1b[18t");
        KeStallExecutionProcessor(100000);
 
        c = KdbpTryGetCharSerial(5000);
        if (c == KEY_ESC)
        {
            c = KdbpTryGetCharSerial(5000);
            if (c == '[')
            {
                ULONG Length = 0;
                for (;;)
                {
                    c = KdbpTryGetCharSerial(5000);
                    if (c == -1)
                        break;
 
                    Buffer[Length++] = c;
                    if (isalpha(c) || Length >= (sizeof(Buffer) - 1))
                        break;
                }
                Buffer[Length] = ANSI_NULL;
 
                if (Buffer[0] == '8' && Buffer[1] == ';')
                {
                    SIZE_T i;
                    for (i = 2; (i < Length) && (Buffer[i] != ';'); i++);
 
                    if (Buffer[i] == ';')
                    {
                        Buffer[i++] = ANSI_NULL;
 
                        /* Number of rows is now at Buffer + 2
                         * and number of columns at Buffer + i */
                        NumberOfRows = strtoul(Buffer + 2, NULL, 0);
                        NumberOfCols = strtoul(Buffer + i, NULL, 0);
                        KdTermReportsSize = TRUE;
                    }
                }
            }
            /* Clear further characters */
            while (KdbpTryGetCharSerial(5000) != -1);
        }
    }
 
    if (NumberOfCols <= 0)
    {
        /* Set the number of columns to the default */
        if (KdpDebugMode.Screen && !KdTermSerial)
            NumberOfCols = (SCREEN_WIDTH / 8 /*BOOTCHAR_WIDTH*/);
        else
            NumberOfCols = 80;
    }
    if (NumberOfRows <= 0)
    {
        /* Set the number of rows to the default */
        if (KdpDebugMode.Screen && !KdTermSerial)
            NumberOfRows = (SCREEN_HEIGHT / (13 /*BOOTCHAR_HEIGHT*/ + 1));
        else
            NumberOfRows = 24;
    }
 
    TermSize->cx = NumberOfCols;
    TermSize->cy = NumberOfRows;
 
    // KdIoPrintf("Cols/Rows: %dx%d\n", TermSize->cx, TermSize->cy);
 
    return KdTermReportsSize;
}

Referenced by KdbpPagerInternal().

Variable Documentation

KdbDebugState

ULONG KdbDebugState = 0

Definition at line 32 of file kdterminal.c.

Referenced by KdIoReadLine(), KdpFlushTerminalInput(), KdpGetTerminalSettings(), KdpInitTerminal(), KdpReadTermKey(), and KdReceivePacket().

KdTermConnected

BOOLEAN KdTermConnected = FALSE

Definition at line 34 of file kdterminal.c.

Referenced by KdbpPagerInternal(), KdpInitTerminal(), and KdpUpdateTerminalSize().

KdTermNextKey

CHAR KdTermNextKey = ANSI_NULL

static

Definition at line 38 of file kdterminal.c.

Referenced by KdpFlushTerminalInput(), and KdpReadTermKey().

KdTermReportsSize

BOOLEAN KdTermReportsSize = TRUE

Definition at line 36 of file kdterminal.c.

Referenced by KdpUpdateTerminalSize().

KdTermSerial

BOOLEAN KdTermSerial = FALSE

Definition at line 35 of file kdterminal.c.

Referenced by KdpInitTerminal(), and KdpUpdateTerminalSize().

KdTermSize

SIZE KdTermSize = {0,0}

Definition at line 33 of file kdterminal.c.

Referenced by KdbpPagerInternal().