nvidia.c File Reference

#include "common.h"

Functions
BOOLEAN	Uart16550InitializePortCommon (_In_opt_ _Null_terminated_ PCHAR LoadOptions, _Inout_ PCPPORT Port, BOOLEAN MemoryMapped, UCHAR AccessSize, UCHAR BitWidth)
BOOLEAN	Uart16550SetBaud (_Inout_ PCPPORT Port, ULONG Rate)
UART_STATUS	Uart16550GetByte (_Inout_ PCPPORT Port, _Out_ PUCHAR Byte)
UART_STATUS	Uart16550PutByte (_Inout_ PCPPORT Port, UCHAR Byte, BOOLEAN BusyWait)
BOOLEAN	Uart16550RxReady (_Inout_ PCPPORT Port)
BOOLEAN	NvidiaInitializePort (_In_opt_ _Null_terminated_ PCHAR LoadOptions, _Inout_ PCPPORT Port, BOOLEAN MemoryMapped, UCHAR AccessSize, UCHAR BitWidth)

Variables
UART_HARDWARE_DRIVER	NvidiaHardwareDriver

Function Documentation

NvidiaInitializePort()

BOOLEAN NvidiaInitializePort	(	_In_opt_ _Null_terminated_ PCHAR	LoadOptions,
		_Inout_ PCPPORT	Port,
		BOOLEAN	MemoryMapped,
		UCHAR	AccessSize,
		UCHAR	BitWidth )

{
    UNREFERENCED_PARAMETER(AccessSize);
    UNREFERENCED_PARAMETER(BitWidth);
 
    if (MemoryMapped == FALSE)
    {
        return FALSE;
    }
 
    //
    // Initialize the flags and set the bit to disable baud rate setting.
    //
 
    Port->Flags = PORT_DEFAULT_RATE;
    return Uart16550InitializePortCommon(LoadOptions,
                                         Port,
                                         MemoryMapped,
                                         AcpiGenericAccessSizeByte,
                                         32);
}

Uart16550GetByte()

UART_STATUS Uart16550GetByte	(	_Inout_ PCPPORT	Port,
		_Out_ PUCHAR	Byte )

{
    UCHAR Data;
    UCHAR Lsr;
    UCHAR Msr;
 
    *Byte = 0;
 
    if ((Port == NULL) || (Port->Address == NULL))
    {
        return UartNotReady;
    }
 
    //
    // Check to see if all bits are set in LSR. If this is the case, it means
    // the port I/O address is invalid as 0xFF is nonsense for LSR.
    //
 
    Lsr = Port->Read(Port, COM_LSR);
    if (Lsr == SERIAL_LSR_NOT_PRESENT)
    {
        return UartNotReady;
    }
 
    if (CHECK_FLAG(Lsr, COM_DATRDY))
    {
        //
        // Return unsuccessfully if any errors are indicated by the
        // LSR.
        //
 
        if (CHECK_FLAG(Lsr, COM_PE) ||
            CHECK_FLAG(Lsr, COM_FE) ||
            CHECK_FLAG(Lsr, COM_OE))
        {
            return UartError;
        }
 
        Data = Port->Read(Port, COM_DAT);
 
        //
        // When using modem control, ignore any bytes that don't have
        // the carrier detect flag set.
        //
 
        if (CHECK_FLAG(Port->Flags, PORT_MODEM_CONTROL))
        {
            Msr = Port->Read(Port, COM_MSR);
            if (CHECK_FLAG(Msr, MS_CD) == FALSE)
            {
                return UartNoData;
            }
        }
 
        *Byte = Data;
        return UartSuccess;
    }
    else
    {
        //
        // Data is not available. Determine if the ring indicator has toggled.
        // If so, enable modem control.
        //
 
        Msr = Port->Read(Port, COM_MSR);
        if ((CHECK_FLAG(Port->Flags, PORT_RING_INDICATOR) &&
             !CHECK_FLAG(Msr, SERIAL_MSR_RI)) ||
            (!CHECK_FLAG(Port->Flags, PORT_RING_INDICATOR) &&
             CHECK_FLAG(Msr, SERIAL_MSR_RI)))
        {
            Port->Flags |= PORT_MODEM_CONTROL;
        }
 
        return UartNoData;
    }
}

Uart16550InitializePortCommon()

BOOLEAN Uart16550InitializePortCommon	(	_In_opt_ _Null_terminated_ PCHAR	LoadOptions,
		_Inout_ PCPPORT	Port,
		BOOLEAN	MemoryMapped,
		UCHAR	AccessSize,
		UCHAR	BitWidth )

{
    UCHAR RegisterValue;
 
    UNREFERENCED_PARAMETER(LoadOptions);
 
    //
    // Set the Read / Write function pointers for this serial port.
    //
 
    UartpSetAccess(Port, MemoryMapped, AccessSize, BitWidth);
 
    //
    // Set DLAB to zero. The DLAB controls the meaning of the first two
    // registers. When zero, the first register is used for all byte transfers
    // and the second register controls device interrupts.
    //
 
    RegisterValue = Port->Read(Port, COM_LCR);
    RegisterValue &= ~LC_DLAB;
    Port->Write(Port, COM_LCR, RegisterValue);
 
    //
    // Disable device interrupts.  This implementation will handle state
    // transitions by request only.
    //
 
    Port->Write(Port, COM_IEN, 0);
 
    //
    // Reset and disable the FIFO queue.
    // N.B. FIFO will be re-enabled before returning from this routine.
    //
 
    Port->Write(Port, COM_FCR, FC_CLEAR_TRANSMIT | FC_CLEAR_RECEIVE);
 
    //
    // Configure the baud rate and mode.
    //
 
    Uart16550SetBaud(Port, Port->BaudRate);
 
    //
    // Enable the FIFO.
    //
 
    Port->Write(Port, COM_FCR, FC_ENABLE);
 
    //
    // Assert DTR, RTS. Disable loopback. Indicate to the device that
    // we are able to send and receive data.
    //
 
    Port->Write(Port, COM_MCR, MC_DTRRTS);
 
    //
    // Initialize ring indicator bit based on hardware state.
    //
 
    RegisterValue = Port->Read(Port, COM_MSR);
    if (CHECK_FLAG(RegisterValue, SERIAL_MSR_RI))
    {
        Port->Flags |= PORT_RING_INDICATOR;
    }
 
    return TRUE;
}

Uart16550PutByte()

UART_STATUS Uart16550PutByte	(	_Inout_ PCPPORT	Port,
		UCHAR	Byte,
		BOOLEAN	BusyWait )

{
    UCHAR Lsr;
    UCHAR Msr;
 
    if ((Port == NULL) || (Port->Address == NULL))
    {
        return UartNotReady;
    }
 
    //
    // When using modem control, DSR, CTS, and CD flags must all be set before
    // sending any data.
    //
 
    if (CHECK_FLAG(Port->Flags, PORT_MODEM_CONTROL))
    {
        Msr = Port->Read(Port, COM_MSR);
        while ((Msr & MS_DSRCTSCD) != MS_DSRCTSCD)
        {
            //
            // If there's a byte ready, discard it from the input queue.
            //
 
            if (!CHECK_FLAG(Msr, MS_CD))
            {
                Lsr = Port->Read(Port, COM_LSR);
                if (CHECK_FLAG(Port->Flags, COM_DATRDY))
                {
                    Port->Read(Port, COM_DAT);
                }
            }
 
            Msr = Port->Read(Port, COM_MSR);
        }
    }
 
    //
    // Check to see if all bits are set in LSR. If this is the case, it means
    // the port I/O address is invalid as 0xFF is nonsense for LSR. This
    // prevents writing a byte to non-existent hardware.
    //
 
    Lsr = Port->Read(Port, COM_LSR);
    if (Lsr == SERIAL_LSR_NOT_PRESENT)
    {
        return UartNotReady;
    }
 
    //
    // The port must be ready to accept a byte for output before continuing.
    //
 
    while (!CHECK_FLAG(Lsr, COM_OUTRDY))
    {
        //
        // Determine if the ring indicator has toggled.
        // If so, enable modem control.
        //
 
        Msr = Port->Read(Port, COM_MSR);
        if ((CHECK_FLAG(Port->Flags, PORT_RING_INDICATOR) &&
             !CHECK_FLAG(Msr, SERIAL_MSR_RI)) ||
            (!CHECK_FLAG(Port->Flags, PORT_RING_INDICATOR) &&
             CHECK_FLAG(Msr, SERIAL_MSR_RI)))
        {
            Port->Flags |= PORT_MODEM_CONTROL;
        }
 
        if (BusyWait == FALSE)
        {
            return UartNotReady;
        }
 
        Lsr = Port->Read(Port, COM_LSR);
    }
 
    //
    // Transmitter holding register is empty. Send the byte.
    //
 
    Port->Write(Port, COM_DAT, Byte);
    return UartSuccess;
}

Uart16550RxReady()

BOOLEAN Uart16550RxReady

(

_Inout_ PCPPORT

Port

)

{
    UCHAR Lsr;
 
    if ((Port == NULL) || (Port->Address == NULL))
    {
        return FALSE;
    }
 
    //
    // Check to see if all bits are set in LSR. If this is the case, it means
    // the port I/O address is invalid as 0xFF is nonsense for LSR. This
    // prevents the DATRDY check below from returning TRUE, which could cause
    // a caller to think that data is pending when in actuality there is no
    // UART present.
    //
 
    Lsr = Port->Read(Port, COM_LSR);
    if (Lsr == SERIAL_LSR_NOT_PRESENT)
    {
        return FALSE;
    }
 
    //
    // Look at the Line Status Register to determine if there is pending data.
    //
 
    if (CHECK_FLAG(Lsr, COM_DATRDY))
    {
        return TRUE;
    }
 
    return FALSE;
}

Uart16550SetBaud()

BOOLEAN Uart16550SetBaud	(	_Inout_ PCPPORT	Port,
		ULONG	Rate )

{
    if (CHECK_FLAG(Port->Flags, PORT_DEFAULT_RATE))
    {
        return FALSE;
    }
 
    return Uart16550SetBaudCommon(Port, Rate, CLOCK_RATE);
}

Variable Documentation

NvidiaHardwareDriver

UART_HARDWARE_DRIVER NvidiaHardwareDriver

Initial value:

                                      = {
NvidiaInitializePort,
Uart16550SetBaud,
Uart16550GetByte,
Uart16550PutByte,
Uart16550RxReady}

                                          {
    NvidiaInitializePort,
    Uart16550SetBaud,
    Uart16550GetByte,
    Uart16550PutByte,
    Uart16550RxReady};