forked from Imagelibrary/rtems
bsps: Move console drivers to bsps
This patch is a part of the BSP source reorganization. Update #3285.
This commit is contained in:
Sebastian Huber
711
bsps/m68k/av5282/console/console.c
Normal file
711
bsps/m68k/av5282/console/console.c
Normal file
@@ -0,0 +1,711 @@
|
||||
/*
|
||||
* Multi UART console serial I/O.
|
||||
*
|
||||
* TO DO: Add DMA input/output
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <fcntl.h>
|
||||
#include <termios.h>
|
||||
#include <bsp.h>
|
||||
#include <malloc.h>
|
||||
|
||||
#include <rtems/bspIo.h>
|
||||
#include <rtems/console.h>
|
||||
#include <rtems/libio.h>
|
||||
#include <rtems/termiostypes.h>
|
||||
|
||||
#define UART_INTC0_IRQ_VECTOR(x) (64+13+(x))
|
||||
|
||||
#define MCF5282_UART_USR_ERROR ( MCF5282_UART_USR_RB | \
|
||||
MCF5282_UART_USR_FE | \
|
||||
MCF5282_UART_USR_PE | \
|
||||
MCF5282_UART_USR_OE )
|
||||
|
||||
static ssize_t IntUartPollWrite(int minor, const char *buf, size_t len);
|
||||
static ssize_t IntUartInterruptWrite (int minor, const char *buf, size_t len);
|
||||
|
||||
static void _BSP_null_char( char c )
|
||||
{
|
||||
rtems_interrupt_level level;
|
||||
|
||||
rtems_interrupt_disable(level);
|
||||
while ( (MCF5282_UART_USR(CONSOLE_PORT) & MCF5282_UART_USR_TXRDY) == 0 )
|
||||
continue;
|
||||
|
||||
MCF5282_UART_UTB(CONSOLE_PORT) = c;
|
||||
while ( (MCF5282_UART_USR(CONSOLE_PORT) & MCF5282_UART_USR_TXRDY) == 0 )
|
||||
continue;
|
||||
|
||||
rtems_interrupt_enable(level);
|
||||
}
|
||||
BSP_output_char_function_type BSP_output_char = _BSP_null_char;
|
||||
BSP_polling_getchar_function_type BSP_poll_char = NULL;
|
||||
|
||||
#define MAX_UART_INFO 3
|
||||
#define RX_BUFFER_SIZE 512
|
||||
|
||||
struct IntUartInfoStruct
|
||||
{
|
||||
int iomode;
|
||||
volatile int uimr;
|
||||
int baud;
|
||||
int databits;
|
||||
int parity;
|
||||
int stopbits;
|
||||
int hwflow;
|
||||
int rx_in;
|
||||
int rx_out;
|
||||
char rx_buffer[RX_BUFFER_SIZE];
|
||||
void *ttyp;
|
||||
};
|
||||
|
||||
struct IntUartInfoStruct IntUartInfo[MAX_UART_INFO];
|
||||
|
||||
/*
|
||||
* Function : IntUartSet
|
||||
*
|
||||
* Description : This updates the hardware UART settings.
|
||||
*/
|
||||
static void IntUartSet(
|
||||
int minor,
|
||||
int baud,
|
||||
int databits,
|
||||
int parity,
|
||||
int stopbits,
|
||||
int hwflow
|
||||
)
|
||||
{
|
||||
int divisor;
|
||||
uint32_t clock_speed;
|
||||
uint8_t umr1 = 0;
|
||||
uint8_t umr2 = 0;
|
||||
struct IntUartInfoStruct *info = &IntUartInfo[minor];
|
||||
rtems_interrupt_level level;
|
||||
|
||||
rtems_interrupt_disable(level);
|
||||
|
||||
/* disable interrupts, clear RTS line, and disable the UARTS */
|
||||
MCF5282_UART_UIMR(minor) = 0;
|
||||
MCF5282_UART_UOP0(minor) = 1;
|
||||
MCF5282_UART_UCR(minor) =
|
||||
(MCF5282_UART_UCR_TX_DISABLED | MCF5282_UART_UCR_RX_DISABLED);
|
||||
|
||||
/* save the current values */
|
||||
info->uimr = 0;
|
||||
info->baud = baud;
|
||||
info->databits = databits;
|
||||
info->parity = parity;
|
||||
info->stopbits = stopbits;
|
||||
info->hwflow = hwflow;
|
||||
|
||||
clock_speed = get_CPU_clock_speed();
|
||||
/* determine the baud divisor value */
|
||||
divisor = (clock_speed / ( 32 * baud ));
|
||||
if ( divisor < 2 )
|
||||
divisor = 2;
|
||||
|
||||
/* check to see if doing hardware flow control */
|
||||
if ( hwflow ) {
|
||||
/* set hardware flow options */
|
||||
umr1 |= MCF5282_UART_UMR1_RXRTS;
|
||||
umr2 |= MCF5282_UART_UMR2_TXCTS;
|
||||
}
|
||||
|
||||
/* determine the new umr values */
|
||||
umr1 |= (parity | databits);
|
||||
umr2 |= (stopbits);
|
||||
|
||||
/* reset the uart */
|
||||
MCF5282_UART_UCR(minor) = MCF5282_UART_UCR_RESET_ERROR;
|
||||
MCF5282_UART_UCR(minor) = MCF5282_UART_UCR_RESET_RX;
|
||||
MCF5282_UART_UCR(minor) = MCF5282_UART_UCR_RESET_TX;
|
||||
|
||||
/* reset the uart mode register and update values */
|
||||
MCF5282_UART_UCR(minor) = MCF5282_UART_UCR_RESET_MR;
|
||||
MCF5282_UART_UMR(minor) = umr1;
|
||||
MCF5282_UART_UMR(minor) = umr2;
|
||||
|
||||
/* set the baud rate values */
|
||||
MCF5282_UART_UCSR(minor) =
|
||||
(MCF5282_UART_UCSR_RCS_SYS_CLK | MCF5282_UART_UCSR_TCS_SYS_CLK);
|
||||
MCF5282_UART_UBG1(minor) = (divisor & 0xff00) >> 8;
|
||||
MCF5282_UART_UBG2(minor) = (divisor & 0x00ff);
|
||||
|
||||
/* enable the uart */
|
||||
MCF5282_UART_UCR(minor) =
|
||||
(MCF5282_UART_UCR_TX_ENABLED | MCF5282_UART_UCR_RX_ENABLED);
|
||||
|
||||
/* check to see if interrupts need to be enabled */
|
||||
if ( info->iomode != TERMIOS_POLLED ) {
|
||||
/* enable rx interrupts */
|
||||
info->uimr |= MCF5282_UART_UIMR_FFULL;
|
||||
MCF5282_UART_UIMR(minor) = info->uimr;
|
||||
}
|
||||
|
||||
/* check to see if doing hardware flow control */
|
||||
if ( hwflow ) {
|
||||
/* assert the RTS line */
|
||||
MCF5282_UART_UOP1(minor) = 1;
|
||||
}
|
||||
|
||||
rtems_interrupt_enable(level);
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : IntUartSetAttributes
|
||||
*
|
||||
* Description : This provides the hardware-dependent portion of tcsetattr().
|
||||
* value and sets it. At the moment this just sets the baud rate.
|
||||
*
|
||||
* Note: The highest baudrate is 115200 as this stays within
|
||||
* an error of +/- 5% at 25MHz processor clock
|
||||
*/
|
||||
static int IntUartSetAttributes(
|
||||
int minor,
|
||||
const struct termios *t
|
||||
)
|
||||
{
|
||||
/* set default index values */
|
||||
int baud = (int)19200;
|
||||
int databits = (int)MCF5282_UART_UMR1_BC_8;
|
||||
int parity = (int)MCF5282_UART_UMR1_PM_NONE;
|
||||
int stopbits = (int)MCF5282_UART_UMR2_STOP_BITS_1;
|
||||
int hwflow = (int)0;
|
||||
struct IntUartInfoStruct *info = &IntUartInfo[minor];
|
||||
|
||||
/* check to see if input is valid */
|
||||
if ( t != (const struct termios *)0 ) {
|
||||
/* determine baud rate index */
|
||||
baud = rtems_termios_baud_to_number(t->c_ospeed);
|
||||
|
||||
/* determine data bits */
|
||||
switch ( t->c_cflag & CSIZE ) {
|
||||
case CS5:
|
||||
databits = (int)MCF5282_UART_UMR1_BC_5;
|
||||
break;
|
||||
case CS6:
|
||||
databits = (int)MCF5282_UART_UMR1_BC_6;
|
||||
break;
|
||||
case CS7:
|
||||
databits = (int)MCF5282_UART_UMR1_BC_7;
|
||||
break;
|
||||
case CS8:
|
||||
databits = (int)MCF5282_UART_UMR1_BC_8;
|
||||
break;
|
||||
}
|
||||
|
||||
/* determine if parity is enabled */
|
||||
if ( t->c_cflag & PARENB ) {
|
||||
if ( t->c_cflag & PARODD ) {
|
||||
/* odd parity */
|
||||
parity = (int)MCF5282_UART_UMR1_PM_ODD;
|
||||
} else {
|
||||
/* even parity */
|
||||
parity = (int)MCF5282_UART_UMR1_PM_EVEN;
|
||||
}
|
||||
}
|
||||
|
||||
/* determine stop bits */
|
||||
if ( t->c_cflag & CSTOPB ) {
|
||||
/* two stop bits */
|
||||
stopbits = (int)MCF5282_UART_UMR2_STOP_BITS_2;
|
||||
}
|
||||
|
||||
/* check to see if hardware flow control */
|
||||
if ( t->c_cflag & CRTSCTS ) {
|
||||
hwflow = 1;
|
||||
}
|
||||
}
|
||||
|
||||
/* check to see if values have changed */
|
||||
if ( ( baud != info->baud ) ||
|
||||
( databits != info->databits ) ||
|
||||
( parity != info->parity ) ||
|
||||
( stopbits != info->stopbits ) ||
|
||||
( hwflow != info->hwflow ) ) {
|
||||
|
||||
/* call function to set values */
|
||||
IntUartSet(minor, baud, databits, parity, stopbits, hwflow);
|
||||
}
|
||||
|
||||
return RTEMS_SUCCESSFUL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : IntUartInterruptHandler
|
||||
*
|
||||
* Description : This is the interrupt handler for the internal uart. It
|
||||
* determines which channel caused the interrupt before queueing any received
|
||||
* chars and dequeueing chars waiting for transmission.
|
||||
*/
|
||||
static rtems_isr IntUartInterruptHandler(rtems_vector_number v)
|
||||
{
|
||||
unsigned int chan = v - UART_INTC0_IRQ_VECTOR(0);
|
||||
struct IntUartInfoStruct *info = &IntUartInfo[chan];
|
||||
|
||||
/* check to see if received data */
|
||||
if ( MCF5282_UART_UISR(chan) & MCF5282_UART_UISR_RXRDY ) {
|
||||
/* read data and put into the receive buffer */
|
||||
while ( MCF5282_UART_USR(chan) & MCF5282_UART_USR_RXRDY ) {
|
||||
|
||||
if ( MCF5282_UART_USR(chan) & MCF5282_UART_USR_ERROR ) {
|
||||
/* clear the error */
|
||||
MCF5282_UART_UCR(chan) = MCF5282_UART_UCR_RESET_ERROR;
|
||||
}
|
||||
/* put data in rx buffer and check for errors */
|
||||
info->rx_buffer[info->rx_in] = MCF5282_UART_URB(chan);
|
||||
|
||||
/* update buffer values */
|
||||
info->rx_in++;
|
||||
|
||||
if ( info->rx_in >= RX_BUFFER_SIZE ) {
|
||||
info->rx_in = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* Make sure the port has been opened */
|
||||
if ( info->ttyp ) {
|
||||
|
||||
/* check to see if task driven */
|
||||
if ( info->iomode == TERMIOS_TASK_DRIVEN ) {
|
||||
/* notify rx task that rx buffer has data */
|
||||
rtems_termios_rxirq_occured(info->ttyp);
|
||||
} else {
|
||||
/* Push up the received data */
|
||||
rtems_termios_enqueue_raw_characters(
|
||||
info->ttyp, info->rx_buffer, info->rx_in);
|
||||
info->rx_in = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* check to see if data needs to be transmitted */
|
||||
if ( ( info->uimr & MCF5282_UART_UIMR_TXRDY ) &&
|
||||
( MCF5282_UART_UISR(chan) & MCF5282_UART_UISR_TXRDY ) )
|
||||
{
|
||||
|
||||
/* disable tx interrupts */
|
||||
info->uimr &= ~MCF5282_UART_UIMR_TXRDY;
|
||||
MCF5282_UART_UIMR(chan) = info->uimr;
|
||||
|
||||
/* tell upper level that character has been sent */
|
||||
if ( info->ttyp )
|
||||
rtems_termios_dequeue_characters(info->ttyp, 1);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : IntUartInitialize
|
||||
*
|
||||
* Description : This initialises the internal uart hardware for all
|
||||
* internal uarts. If the internal uart is to be interrupt driven then the
|
||||
* interrupt vectors are hooked.
|
||||
*/
|
||||
static void IntUartInitialize(void)
|
||||
{
|
||||
unsigned int chan;
|
||||
struct IntUartInfoStruct *info;
|
||||
rtems_isr_entry old_handler;
|
||||
rtems_interrupt_level level;
|
||||
|
||||
for ( chan = 0; chan < MAX_UART_INFO; chan++ ) {
|
||||
info = &IntUartInfo[chan];
|
||||
|
||||
info->ttyp = NULL;
|
||||
info->rx_in = 0;
|
||||
info->rx_out = 0;
|
||||
info->baud = -1;
|
||||
info->databits = -1;
|
||||
info->parity = -1;
|
||||
info->stopbits = -1;
|
||||
info->hwflow = -1;
|
||||
info->iomode = TERMIOS_POLLED;
|
||||
|
||||
MCF5282_UART_UACR(chan) = 0;
|
||||
MCF5282_UART_UIMR(chan) = 0;
|
||||
if ( info->iomode != TERMIOS_POLLED ) {
|
||||
rtems_interrupt_catch (IntUartInterruptHandler,
|
||||
UART_INTC0_IRQ_VECTOR(chan),
|
||||
&old_handler);
|
||||
}
|
||||
|
||||
/* set uart default values */
|
||||
IntUartSetAttributes(chan, NULL);
|
||||
|
||||
/* unmask interrupt */
|
||||
rtems_interrupt_disable(level);
|
||||
switch(chan) {
|
||||
case 0:
|
||||
MCF5282_INTC0_ICR13 = MCF5282_INTC_ICR_IL(UART0_IRQ_LEVEL) |
|
||||
MCF5282_INTC_ICR_IP(UART0_IRQ_PRIORITY);
|
||||
MCF5282_INTC0_IMRL &= ~(MCF5282_INTC_IMRL_INT13 |
|
||||
MCF5282_INTC_IMRL_MASKALL);
|
||||
break;
|
||||
|
||||
case 1:
|
||||
MCF5282_INTC0_ICR14 = MCF5282_INTC_ICR_IL(UART1_IRQ_LEVEL) |
|
||||
MCF5282_INTC_ICR_IP(UART1_IRQ_PRIORITY);
|
||||
MCF5282_INTC0_IMRL &= ~(MCF5282_INTC_IMRL_INT14 |
|
||||
MCF5282_INTC_IMRL_MASKALL);
|
||||
break;
|
||||
|
||||
case 2:
|
||||
MCF5282_INTC0_ICR15 = MCF5282_INTC_ICR_IL(UART2_IRQ_LEVEL) |
|
||||
MCF5282_INTC_ICR_IP(UART2_IRQ_PRIORITY);
|
||||
MCF5282_INTC0_IMRL &= ~(MCF5282_INTC_IMRL_INT15 |
|
||||
MCF5282_INTC_IMRL_MASKALL);
|
||||
break;
|
||||
}
|
||||
rtems_interrupt_enable(level);
|
||||
|
||||
} /* of chan loop */
|
||||
|
||||
|
||||
} /* IntUartInitialise */
|
||||
|
||||
|
||||
/*
|
||||
* Function : IntUartInterruptWrite
|
||||
*
|
||||
* Description : This writes a single character to the appropriate uart
|
||||
* channel. This is either called during an interrupt or in the user's task
|
||||
* to initiate a transmit sequence. Calling this routine enables Tx
|
||||
* interrupts.
|
||||
*/
|
||||
static ssize_t IntUartInterruptWrite(
|
||||
int minor,
|
||||
const char *buf,
|
||||
size_t len
|
||||
)
|
||||
{
|
||||
if (len > 0) {
|
||||
/* write out character */
|
||||
MCF5282_UART_UTB(minor) = *buf;
|
||||
|
||||
/* enable tx interrupt */
|
||||
IntUartInfo[minor].uimr |= MCF5282_UART_UIMR_TXRDY;
|
||||
MCF5282_UART_UIMR(minor) = IntUartInfo[minor].uimr;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : IntUartInterruptOpen
|
||||
*
|
||||
* Description : This enables interrupts when the tty is opened.
|
||||
*/
|
||||
static int IntUartInterruptOpen(
|
||||
int major,
|
||||
int minor,
|
||||
void *arg
|
||||
)
|
||||
{
|
||||
struct IntUartInfoStruct *info = &IntUartInfo[minor];
|
||||
|
||||
/* enable the uart */
|
||||
MCF5282_UART_UCR(minor) = (MCF5282_UART_UCR_TX_ENABLED |
|
||||
MCF5282_UART_UCR_RX_ENABLED);
|
||||
|
||||
/* check to see if interrupts need to be enabled */
|
||||
if ( info->iomode != TERMIOS_POLLED ) {
|
||||
/* enable rx interrupts */
|
||||
info->uimr |= MCF5282_UART_UIMR_FFULL;
|
||||
MCF5282_UART_UIMR(minor) = info->uimr;
|
||||
}
|
||||
|
||||
/* check to see if doing hardware flow control */
|
||||
if ( info->hwflow ) {
|
||||
/* assert the RTS line */
|
||||
MCF5282_UART_UOP1(minor) = 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : IntUartInterruptClose
|
||||
*
|
||||
* Description : This disables interrupts when the tty is closed.
|
||||
*/
|
||||
static int IntUartInterruptClose(
|
||||
int major,
|
||||
int minor,
|
||||
void *arg
|
||||
)
|
||||
{
|
||||
struct IntUartInfoStruct *info = &IntUartInfo[minor];
|
||||
|
||||
/* disable the interrupts and the uart */
|
||||
MCF5282_UART_UIMR(minor) = 0;
|
||||
MCF5282_UART_UCR(minor) =
|
||||
(MCF5282_UART_UCR_TX_DISABLED | MCF5282_UART_UCR_RX_DISABLED);
|
||||
|
||||
/* reset values */
|
||||
info->ttyp = NULL;
|
||||
info->uimr = 0;
|
||||
info->rx_in = 0;
|
||||
info->rx_out = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : IntUartTaskRead
|
||||
*
|
||||
* Description : This reads all available characters from the internal uart
|
||||
* and places them into the termios buffer. The rx interrupts will be
|
||||
* re-enabled after all data has been read.
|
||||
*/
|
||||
static int IntUartTaskRead(int minor)
|
||||
{
|
||||
char buffer[RX_BUFFER_SIZE];
|
||||
int count;
|
||||
int rx_in;
|
||||
int index = 0;
|
||||
struct IntUartInfoStruct *info = &IntUartInfo[minor];
|
||||
|
||||
/* determine number of values to copy out */
|
||||
rx_in = info->rx_in;
|
||||
if ( info->rx_out <= rx_in ) {
|
||||
count = rx_in - info->rx_out;
|
||||
} else {
|
||||
count = (RX_BUFFER_SIZE - info->rx_out) + rx_in;
|
||||
}
|
||||
|
||||
/* copy data into local buffer from rx buffer */
|
||||
while ( ( index < count ) && ( index < RX_BUFFER_SIZE ) ) {
|
||||
/* copy data byte */
|
||||
buffer[index] = info->rx_buffer[info->rx_out];
|
||||
index++;
|
||||
|
||||
/* increment rx buffer values */
|
||||
info->rx_out++;
|
||||
if ( info->rx_out >= RX_BUFFER_SIZE ) {
|
||||
info->rx_out = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* check to see if buffer is not empty */
|
||||
if ( count > 0 ) {
|
||||
/* set characters into termios buffer */
|
||||
rtems_termios_enqueue_raw_characters(info->ttyp, buffer, count);
|
||||
}
|
||||
|
||||
return EOF;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Function : IntUartPollRead
|
||||
*
|
||||
* Description : This reads a character from the internal uart. It returns
|
||||
* to the caller without blocking if not character is waiting.
|
||||
*/
|
||||
static int IntUartPollRead(int minor)
|
||||
{
|
||||
if ( (MCF5282_UART_USR(minor) & MCF5282_UART_USR_RXRDY) == 0 )
|
||||
return-1;
|
||||
|
||||
return MCF5282_UART_URB(minor);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Function : IntUartPollWrite
|
||||
*
|
||||
* Description : This writes out each character in the buffer to the
|
||||
* appropriate internal uart channel waiting till each one is sucessfully
|
||||
* transmitted.
|
||||
*/
|
||||
static ssize_t IntUartPollWrite(
|
||||
int minor,
|
||||
const char *buf,
|
||||
size_t len
|
||||
)
|
||||
{
|
||||
size_t retval = len;
|
||||
/* loop over buffer */
|
||||
|
||||
while ( len-- ) {
|
||||
/* block until we can transmit */
|
||||
while ( (MCF5282_UART_USR(minor) & MCF5282_UART_USR_TXRDY) == 0 )
|
||||
continue;
|
||||
/* transmit data byte */
|
||||
MCF5282_UART_UTB(minor) = *buf++;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : console_initialize
|
||||
*
|
||||
* Description : This initialises termios, both sets of uart hardware before
|
||||
* registering /dev/tty devices for each channel and the system /dev/console.
|
||||
*/
|
||||
rtems_device_driver console_initialize(
|
||||
rtems_device_major_number major,
|
||||
rtems_device_minor_number minor,
|
||||
void *arg
|
||||
)
|
||||
{
|
||||
rtems_status_code status;
|
||||
|
||||
/* Set up TERMIOS */
|
||||
rtems_termios_initialize ();
|
||||
|
||||
/* set io modes for the different channels and initialize device */
|
||||
IntUartInfo[minor].iomode = TERMIOS_IRQ_DRIVEN;
|
||||
IntUartInitialize();
|
||||
|
||||
/* Register the console port */
|
||||
status = rtems_io_register_name ("/dev/console", major, CONSOLE_PORT);
|
||||
if ( status != RTEMS_SUCCESSFUL ) {
|
||||
rtems_fatal_error_occurred (status);
|
||||
}
|
||||
|
||||
/* Register the other port */
|
||||
if ( CONSOLE_PORT != 0 ) {
|
||||
status = rtems_io_register_name ("/dev/tty00", major, 0);
|
||||
if ( status != RTEMS_SUCCESSFUL ) {
|
||||
rtems_fatal_error_occurred (status);
|
||||
}
|
||||
}
|
||||
if ( CONSOLE_PORT != 1 ) {
|
||||
status = rtems_io_register_name ("/dev/tty01", major, 1);
|
||||
if ( status != RTEMS_SUCCESSFUL ) {
|
||||
rtems_fatal_error_occurred (status);
|
||||
}
|
||||
}
|
||||
|
||||
return RTEMS_SUCCESSFUL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : console_open
|
||||
*
|
||||
* Description : This actually opens the device depending on the minor
|
||||
* number set during initialisation. The device specific access routines are
|
||||
* passed to termios when the devices is opened depending on whether it is
|
||||
* polled or not.
|
||||
*/
|
||||
rtems_device_driver console_open(
|
||||
rtems_device_major_number major,
|
||||
rtems_device_minor_number minor,
|
||||
void * arg
|
||||
)
|
||||
{
|
||||
rtems_status_code status = RTEMS_INVALID_NUMBER;
|
||||
rtems_libio_open_close_args_t *args = (rtems_libio_open_close_args_t *)arg;
|
||||
struct IntUartInfoStruct *info;
|
||||
|
||||
static const rtems_termios_callbacks IntUartPollCallbacks = {
|
||||
NULL, /* firstOpen */
|
||||
NULL, /* lastClose */
|
||||
IntUartPollRead, /* pollRead */
|
||||
IntUartPollWrite, /* write */
|
||||
IntUartSetAttributes, /* setAttributes */
|
||||
NULL, /* stopRemoteTx */
|
||||
NULL, /* startRemoteTx */
|
||||
TERMIOS_POLLED /* mode */
|
||||
};
|
||||
static const rtems_termios_callbacks IntUartIntrCallbacks = {
|
||||
IntUartInterruptOpen, /* firstOpen */
|
||||
IntUartInterruptClose, /* lastClose */
|
||||
NULL, /* pollRead */
|
||||
IntUartInterruptWrite, /* write */
|
||||
IntUartSetAttributes, /* setAttributes */
|
||||
NULL, /* stopRemoteTx */
|
||||
NULL, /* startRemoteTx */
|
||||
TERMIOS_IRQ_DRIVEN /* mode */
|
||||
};
|
||||
|
||||
static const rtems_termios_callbacks IntUartTaskCallbacks = {
|
||||
IntUartInterruptOpen, /* firstOpen */
|
||||
IntUartInterruptClose, /* lastClose */
|
||||
IntUartTaskRead, /* pollRead */
|
||||
IntUartInterruptWrite, /* write */
|
||||
IntUartSetAttributes, /* setAttributes */
|
||||
NULL, /* stopRemoteTx */
|
||||
NULL, /* startRemoteTx */
|
||||
TERMIOS_TASK_DRIVEN /* mode */
|
||||
};
|
||||
|
||||
/* open the port depending on the minor device number */
|
||||
if ( ( minor >= 0 ) && ( minor < MAX_UART_INFO ) ) {
|
||||
info = &IntUartInfo[minor];
|
||||
switch ( info->iomode ) {
|
||||
case TERMIOS_POLLED:
|
||||
status = rtems_termios_open(major, minor, arg, &IntUartPollCallbacks);
|
||||
break;
|
||||
case TERMIOS_IRQ_DRIVEN:
|
||||
status = rtems_termios_open(major, minor, arg, &IntUartIntrCallbacks);
|
||||
info->ttyp = args->iop->data1;
|
||||
break;
|
||||
case TERMIOS_TASK_DRIVEN:
|
||||
status = rtems_termios_open(major, minor, arg, &IntUartTaskCallbacks);
|
||||
info->ttyp = args->iop->data1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : console_close
|
||||
*
|
||||
* Description : This closes the device via termios
|
||||
*/
|
||||
rtems_device_driver console_close(
|
||||
rtems_device_major_number major,
|
||||
rtems_device_minor_number minor,
|
||||
void * arg
|
||||
)
|
||||
{
|
||||
return rtems_termios_close(arg);
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : console_read
|
||||
*
|
||||
* Description : Read from the device via termios
|
||||
*/
|
||||
rtems_device_driver console_read(
|
||||
rtems_device_major_number major,
|
||||
rtems_device_minor_number minor,
|
||||
void *arg
|
||||
)
|
||||
{
|
||||
return rtems_termios_read(arg);
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : console_write
|
||||
*
|
||||
* Description : Write to the device via termios
|
||||
*/
|
||||
rtems_device_driver console_write(
|
||||
rtems_device_major_number major,
|
||||
rtems_device_minor_number minor,
|
||||
void *arg
|
||||
)
|
||||
{
|
||||
return rtems_termios_write(arg);
|
||||
}
|
||||
|
||||
/*
|
||||
* Function : console_ioctl
|
||||
*
|
||||
* Description : Pass the IOCtl call to termios
|
||||
*/
|
||||
rtems_device_driver console_control(
|
||||
rtems_device_major_number major,
|
||||
rtems_device_minor_number minor,
|
||||
void *arg
|
||||
)
|
||||
{
|
||||
return rtems_termios_ioctl(arg);
|
||||
}
|
||||
Reference in New Issue
Block a user