omap.c File Reference

#include "common.h"
#include "kdcom.h"

Macros
#define	CLOCK_RATE   2995200ul
#define	COM_EFR   0x2
#define	COM_MDR1   0x8
#define	LC_DATA_SIZE   0x03

Functions
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	OmapSetBaud (_Inout_ PCPPORT Port, ULONG Rate)
BOOLEAN	OmapInitializePort (_In_opt_ _Null_terminated_ PCHAR LoadOptions, _Inout_ PCPPORT Port, BOOLEAN MemoryMapped, UCHAR AccessSize, UCHAR BitWidth)

Variables
UART_HARDWARE_DRIVER	OmapHardwareDriver

Macro Definition Documentation

CLOCK_RATE

#define CLOCK_RATE   2995200ul

COM_EFR

#define COM_EFR   0x2

COM_MDR1

#define COM_MDR1   0x8

LC_DATA_SIZE

#define LC_DATA_SIZE   0x03

Function Documentation

OmapInitializePort()

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

{
    UNREFERENCED_PARAMETER(LoadOptions);
    UNREFERENCED_PARAMETER(AccessSize);
    UNREFERENCED_PARAMETER(BitWidth);
 
    Port->Flags = 0;
 
    //
    // Set the Read / Write function pointers for this serial port.
    //
 
    UartpSetAccess(Port, MemoryMapped, AcpiGenericAccessSizeByte, 32);
 
    //
    // Set baud Rate.
    //
 
    OmapSetBaud(Port, Port->BaudRate);
 
    //
    // Put in operational mode.
    //
 
    Port->Write(Port, COM_LCR, Port->Read(Port, COM_LCR) & ~LC_DLAB);
 
    //
    // Disable device interrupts.
    //
 
    Port->Write(Port, COM_IEN, 0);
 
    //
    // Reset and disable the FIFO queue.
    //
 
    Port->Write(Port, COM_FCR, (FC_CLEAR_TRANSMIT | FC_CLEAR_RECEIVE));
 
    //
    // Configure the Modem Control Register. Disable device interrupts and
    // turn off loopback.
    //
 
    Port->Write(Port, COM_MCR, Port->Read(Port, COM_MCR) & MC_DTRRTS);
 
    //
    // Initialize the Modem Control Register. Indicate to the device that
    // we are able to send and receive data.
    //
 
    Port->Write(Port, COM_MCR, MC_DTRRTS);
 
    //
    // Enable the FIFO queues.
    //
 
    Port->Write(Port, COM_FCR, FC_ENABLE);
    return TRUE;
}

OmapSetBaud()

BOOLEAN OmapSetBaud	(	_Inout_ PCPPORT	Port,
		ULONG	Rate )

{
    ULONG DivisorLatch;
    UCHAR Enhanced;
 
    UNREFERENCED_PARAMETER(Rate);
 
    if ((Port == NULL) || (Port->Address == NULL))
    {
        return FALSE;
    }
 
    //
    // Disable UART.
    //
 
    Port->Write(Port, COM_MDR1, 0x7);
 
    //
    // Set register configuration mode B.
    //
 
    Port->Write(Port, COM_LCR, 0xBF);
 
    //
    // Set enhanced mode.
    //
 
    Enhanced = Port->Read(Port, COM_EFR);
    Port->Write(Port, COM_EFR, (Enhanced | (1 << 4)));
 
    //
    // Switch to operational mode.
    //
 
    Port->Write(Port, COM_LCR, 0);
 
    //
    // Clear sleep mode.
    //
 
    Port->Write(Port, COM_IEN, 0);
 
    //
    // Set register configuration mode B.
    //
 
    Port->Write(Port, COM_LCR, 0xBF);
 
    //
    // Compute the divsor.
    //
 
    DivisorLatch = CLOCK_RATE / 115200;
 
    //
    // Write the divisor latch value to DLL and DLM.
    //
 
    Port->Write(Port, COM_DLM, (UCHAR)((DivisorLatch >> 8) & 0xFF));
    Port->Write(Port, COM_DLL, (UCHAR)(DivisorLatch & 0xFF));
 
    //
    // Restore enhanced mode.
    //
 
    Port->Write(Port, COM_EFR, Enhanced);
 
    //
    // Reset the Line Control Register.
    //
 
    Port->Write(Port, COM_LCR, LC_DATA_SIZE);
 
    //
    // Enable UART.
    //
 
    Port->Write(Port, COM_MDR1, 0);
    return TRUE;
}

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;
    }
}

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;
}

Variable Documentation

OmapHardwareDriver

UART_HARDWARE_DRIVER OmapHardwareDriver

Initial value:

                                    = {
OmapInitializePort,
OmapSetBaud,
Uart16550GetByte,
Uart16550PutByte,
Uart16550RxReady}

                                        {
    OmapInitializePort,
    OmapSetBaud,
    Uart16550GetByte,
    Uart16550PutByte,
    Uart16550RxReady};