RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity
Files
89f57a665ff8a3fa69fd36639ca8043205e90316
rtems/cpukit/libcsupport/src/termios.c
Sebastian Huber 80cf60efec Canonicalize config.h include 
Use the following variant which was already used by most source files:

  #ifdef HAVE_CONFIG_H
  #include "config.h"
  #endif
2020-04-16 07:30:00 +02:00

2292 lines
60 KiB
C
Raw Blame History

/**
* @file
* TERMIOS serial line support
*/
/*
* Author:
* W. Eric Norum
* Saskatchewan Accelerator Laboratory
* University of Saskatchewan
* Saskatoon, Saskatchewan, CANADA
* eric@skatter.usask.ca
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <rtems.h>
#include <rtems/libio.h>
#include <rtems/imfs.h>
#include <rtems/score/assert.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <sys/fcntl.h>
#include <sys/filio.h>
#include <sys/ttycom.h>
#include <rtems/termiostypes.h>
/*
* The size of the cooked buffer
*/
#define CBUFSIZE (rtems_termios_cbufsize)
/*
* The sizes of the raw message buffers.
* On most architectures it is quite a bit more
* efficient if these are powers of two.
*/
#define RAW_INPUT_BUFFER_SIZE (rtems_termios_raw_input_size)
#define RAW_OUTPUT_BUFFER_SIZE (rtems_termios_raw_output_size)
/* fields for "flow_ctrl" status */
#define FL_IREQXOF 1U /* input queue requests stop of incoming data */
#define FL_ISNTXOF 2U /* XOFF has been sent to other side of line */
#define FL_IRTSOFF 4U /* RTS has been turned off for other side.. */
#define FL_ORCVXOF 0x10U /* XOFF has been received */
#define FL_OSTOP 0x20U /* output has been stopped due to XOFF */
#define FL_MDRTS 0x100U /* input controlled with RTS/CTS handshake */
#define FL_MDXON 0x200U /* input controlled with XON/XOFF protocol */
#define FL_MDXOF 0x400U /* output controlled with XON/XOFF protocol */
#define NODISC(n) \
{ NULL, NULL, NULL, NULL, \
NULL, NULL, NULL, NULL }
/*
* FIXME: change rtems_termios_linesw entries consistent
* with rtems_termios_linesw entry usage...
*/
struct rtems_termios_linesw rtems_termios_linesw[MAXLDISC] =
{
NODISC(0), /* 0- termios-built-in */
NODISC(1), /* 1- defunct */
NODISC(2), /* 2- NTTYDISC */
NODISC(3), /* TABLDISC */
NODISC(4), /* SLIPDISC */
NODISC(5), /* PPPDISC */
NODISC(6), /* loadable */
NODISC(7), /* loadable */
};
int rtems_termios_nlinesw =
sizeof (rtems_termios_linesw) / sizeof (rtems_termios_linesw[0]);
static size_t rtems_termios_cbufsize = 256;
static size_t rtems_termios_raw_input_size = 256;
static size_t rtems_termios_raw_output_size = 64;
static const IMFS_node_control rtems_termios_imfs_node_control;
static struct rtems_termios_tty *rtems_termios_ttyHead;
static struct rtems_termios_tty *rtems_termios_ttyTail;
static RTEMS_CHAIN_DEFINE_EMPTY(rtems_termios_devices);
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument);
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument);
/*
* some constants for I/O daemon task creation
*/
#define TERMIOS_TXTASK_PRIO 10
#define TERMIOS_RXTASK_PRIO 9
#define TERMIOS_TXTASK_STACKSIZE 1024
#define TERMIOS_RXTASK_STACKSIZE 1024
/*
* some events to be sent to the I/O tasks
*/
#define TERMIOS_TX_START_EVENT RTEMS_EVENT_1
#define TERMIOS_TX_TERMINATE_EVENT RTEMS_EVENT_0
#define TERMIOS_RX_PROC_EVENT RTEMS_EVENT_1
#define TERMIOS_RX_TERMINATE_EVENT RTEMS_EVENT_0
static void
rtems_termios_obtain (void)
{
rtems_mutex_lock (&rtems_termios_ttyMutex);
}
static void
rtems_termios_release (void)
{
rtems_mutex_unlock (&rtems_termios_ttyMutex);
}
rtems_status_code rtems_termios_device_install(
const char *device_file,
const rtems_termios_device_handler *handler,
const rtems_termios_device_flow *flow,
rtems_termios_device_context *context
)
{
rtems_termios_device_node *new_device_node;
int rv;
new_device_node = calloc (1, sizeof(*new_device_node));
if (new_device_node == NULL) {
return RTEMS_NO_MEMORY;
}
rtems_chain_initialize_node (&new_device_node->node);
new_device_node->handler = handler;
new_device_node->flow = flow;
new_device_node->context = context;
new_device_node->tty = NULL;
rv = IMFS_make_generic_node(
device_file,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_termios_imfs_node_control,
new_device_node
);
if (rv != 0) {
free (new_device_node);
return RTEMS_UNSATISFIED;
}
return RTEMS_SUCCESSFUL;
}
static rtems_termios_tty *
legacyContextToTTY (rtems_termios_device_context *ctx)
{
return RTEMS_CONTAINER_OF (ctx, rtems_termios_tty, legacy_device_context);
}
static bool
rtems_termios_callback_firstOpen(
rtems_termios_tty *tty,
rtems_termios_device_context *ctx,
struct termios *term,
rtems_libio_open_close_args_t *args
)
{
(void) ctx;
(void) term;
(*tty->device.firstOpen) (tty->major, tty->minor, args);
return true;
}
static void
rtems_termios_callback_lastClose(
rtems_termios_tty *tty,
rtems_termios_device_context *ctx,
rtems_libio_open_close_args_t *args
)
{
(void) ctx;
(*tty->device.lastClose) (tty->major, tty->minor, args);
}
static int
rtems_termios_callback_pollRead (rtems_termios_device_context *ctx)
{
rtems_termios_tty *tty = legacyContextToTTY (ctx);
return (*tty->device.pollRead) (tty->minor);
}
static void
rtems_termios_callback_write(
rtems_termios_device_context *ctx,
const char *buf,
size_t len
)
{
rtems_termios_tty *tty = legacyContextToTTY (ctx);
(*tty->device.write) (tty->minor, buf, len);
}
static bool
rtems_termios_callback_setAttributes(
rtems_termios_device_context *ctx,
const struct termios *term
)
{
rtems_termios_tty *tty = legacyContextToTTY (ctx);
(*tty->device.setAttributes) (tty->minor, term);
return true;
}
static void
rtems_termios_callback_stopRemoteTx (rtems_termios_device_context *ctx)
{
rtems_termios_tty *tty = legacyContextToTTY (ctx);
(*tty->device.stopRemoteTx) (tty->minor);
}
static void
rtems_termios_callback_startRemoteTx (rtems_termios_device_context *ctx)
{
rtems_termios_tty *tty = legacyContextToTTY (ctx);
(*tty->device.startRemoteTx) (tty->minor);
}
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
rtems_termios_device_context *ctx = tty->device_context;
rtems_interrupt_lock_context lock_context;
if (tty->handler.mode != TERMIOS_POLLED) {
rtems_termios_device_lock_acquire (ctx, &lock_context);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
rtems_termios_device_lock_release (ctx, &lock_context);
rtems_binary_semaphore_wait (&tty->rawOutBuf.Semaphore);
rtems_termios_device_lock_acquire (ctx, &lock_context);
}
rtems_termios_device_lock_release (ctx, &lock_context);
}
}
static bool
needDeviceMutex (rtems_termios_tty *tty)
{
return tty->handler.mode == TERMIOS_IRQ_SERVER_DRIVEN
|| tty->handler.mode == TERMIOS_TASK_DRIVEN;
}
static void
rtems_termios_destroy_tty (rtems_termios_tty *tty, void *arg, bool last_close)
{
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
/*
* call discipline-specific close
*/
(void) rtems_termios_linesw[tty->t_line].l_close(tty);
} else if (last_close) {
/*
* default: just flush output buffer
*/
rtems_mutex_lock (&tty->osem);
drainOutput (tty);
rtems_mutex_unlock (&tty->osem);
}
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
rtems_status_code sc;
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (last_close && tty->handler.last_close)
(*tty->handler.last_close)(tty, tty->device_context, arg);
if (tty->device_node != NULL)
tty->device_node->tty = NULL;
rtems_mutex_destroy (&tty->isem);
rtems_mutex_destroy (&tty->osem);
rtems_binary_semaphore_destroy (&tty->rawOutBuf.Semaphore);
if ((tty->handler.poll_read == NULL) ||
(tty->handler.mode == TERMIOS_TASK_DRIVEN))
rtems_binary_semaphore_destroy (&tty->rawInBuf.Semaphore);
if (needDeviceMutex (tty)) {
rtems_mutex_destroy (&tty->device_context->lock.mutex);
} else if (tty->device_context == &tty->legacy_device_context) {
rtems_interrupt_lock_destroy (&tty->legacy_device_context.lock.interrupt);
}
free (tty->rawInBuf.theBuf);
free (tty->rawOutBuf.theBuf);
free (tty->cbuf);
free (tty);
}
static void
deviceAcquireMutex(
rtems_termios_device_context *ctx,
rtems_interrupt_lock_context *lock_context
)
{
rtems_mutex_lock (&ctx->lock.mutex);
}
static void
deviceReleaseMutex(
rtems_termios_device_context *ctx,
rtems_interrupt_lock_context *lock_context
)
{
rtems_mutex_unlock (&ctx->lock.mutex);
}
static rtems_termios_tty *
rtems_termios_open_tty(
rtems_device_major_number major,
rtems_device_minor_number minor,
rtems_libio_open_close_args_t *args,
rtems_termios_tty *tty,
rtems_termios_device_node *device_node,
const rtems_termios_callbacks *callbacks
)
{
if (tty == NULL) {
static char c = 'a';
rtems_termios_device_context *ctx;
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
if (tty == NULL) {
return NULL;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
return NULL;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
if (tty->rawOutBuf.theBuf == NULL) {
free((void *)(tty->rawInBuf.theBuf));
free(tty);
return NULL;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
free((void *)(tty->rawInBuf.theBuf));
free(tty);
return NULL;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
tty->tty_snd.sw_arg = NULL;
tty->tty_rcv.sw_pfn = NULL;
tty->tty_rcv.sw_arg = NULL;
tty->tty_rcvwakeup = false;
tty->minor = minor;
tty->major = major;
/*
* Set up mutex semaphores
*/
rtems_mutex_init (&tty->isem, "termios input");
rtems_mutex_init (&tty->osem, "termios output");
rtems_binary_semaphore_init (&tty->rawOutBuf.Semaphore,
"termios raw output");
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
if (device_node != NULL) {
device_node->tty = tty;
tty->handler = *device_node->handler;
if (device_node->flow != NULL) {
tty->flow = *device_node->flow;
}
tty->device_node = device_node;
tty->device_context = device_node->context;
memset(&tty->device, 0, sizeof(tty->device));
} else {
tty->handler.first_open = callbacks->firstOpen != NULL ?
rtems_termios_callback_firstOpen : NULL;
tty->handler.last_close = callbacks->lastClose != NULL ?
rtems_termios_callback_lastClose : NULL;
tty->handler.poll_read = callbacks->pollRead != NULL ?
rtems_termios_callback_pollRead : NULL;
tty->handler.write = callbacks->write != NULL ?
rtems_termios_callback_write : NULL;
tty->handler.set_attributes = callbacks->setAttributes != NULL ?
rtems_termios_callback_setAttributes : NULL;
tty->flow.stop_remote_tx = callbacks->stopRemoteTx != NULL ?
rtems_termios_callback_stopRemoteTx : NULL;
tty->flow.start_remote_tx = callbacks->startRemoteTx != NULL ?
rtems_termios_callback_startRemoteTx : NULL;
tty->handler.mode = callbacks->outputUsesInterrupts;
tty->device_context = NULL;
tty->device_node = NULL;
tty->device = *callbacks;
}
if (tty->device_context == NULL) {
tty->device_context = &tty->legacy_device_context;
rtems_termios_device_context_initialize (tty->device_context, "Termios");
}
ctx = tty->device_context;
if (needDeviceMutex (tty)) {
rtems_mutex_init (&ctx->lock.mutex, "termios device");
ctx->lock_acquire = deviceAcquireMutex;
ctx->lock_release = deviceReleaseMutex;
} else {
ctx->lock_acquire = rtems_termios_device_lock_acquire_default;
ctx->lock_release = rtems_termios_device_lock_release_default;
}
/*
* Create I/O tasks
*/
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
rtems_status_code sc;
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
TERMIOS_TXTASK_PRIO,
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
TERMIOS_RXTASK_PRIO,
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->handler.poll_read == NULL) ||
(tty->handler.mode == TERMIOS_TASK_DRIVEN)){
rtems_binary_semaphore_init (&tty->rawInBuf.Semaphore,
"termios raw input");
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | OXTABS;
tty->termios.c_cflag = CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_ispeed = B9600;
tty->termios.c_ospeed = B9600;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
if (!tty->refcount++) {
if (tty->handler.first_open && !(*tty->handler.first_open)(
tty, tty->device_context, &tty->termios, args)) {
rtems_termios_destroy_tty(tty, args, false);
return NULL;
}
/*
* start I/O tasks, if needed
*/
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
rtems_status_code sc;
sc = rtems_task_start(
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
return tty;
}
/*
* Open a termios device
*/
rtems_status_code
rtems_termios_open (
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
rtems_termios_obtain ();
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
if ((tty->major == major) && (tty->minor == minor))
break;
}
tty = rtems_termios_open_tty(
major, minor, arg, tty, NULL, callbacks);
if (tty == NULL) {
rtems_termios_release ();
return RTEMS_NO_MEMORY;
}
if (tty->refcount == 1) {
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
}
rtems_termios_release ();
return RTEMS_SUCCESSFUL;
}
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_termios_device_context *ctx = tty->device_context;
rtems_interrupt_lock_context lock_context;
rtems_termios_device_lock_acquire (ctx, &lock_context);
tty->rawOutBuf.Tail = 0;
tty->rawOutBuf.Head = 0;
tty->rawOutBufState = rob_idle;
rtems_termios_device_lock_release (ctx, &lock_context);
}
static void
flushInput (struct rtems_termios_tty *tty)
{
rtems_termios_device_context *ctx = tty->device_context;
rtems_interrupt_lock_context lock_context;
rtems_termios_device_lock_acquire (ctx, &lock_context);
tty->rawInBuf.Tail = 0;
tty->rawInBuf.Head = 0;
rtems_termios_device_lock_release (ctx, &lock_context);
}
static void
rtems_termios_close_tty (rtems_termios_tty *tty, void *arg)
{
if (--tty->refcount == 0) {
rtems_termios_destroy_tty (tty, arg, true);
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_termios_obtain ();
if (tty->refcount == 1) {
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
}
}
rtems_termios_close_tty (tty, arg);
rtems_termios_release ();
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_termios_bufsize (
size_t cbufsize,
size_t raw_input,
size_t raw_output
)
{
rtems_termios_cbufsize = cbufsize;
rtems_termios_raw_input_size = raw_input;
rtems_termios_raw_output_size = raw_output;
return RTEMS_SUCCESSFUL;
}
static void
termios_set_flowctrl(struct rtems_termios_tty *tty)
{
rtems_termios_device_context *ctx = tty->device_context;
rtems_interrupt_lock_context lock_context;
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_termios_device_lock_acquire (ctx, &lock_context);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->handler.write)(
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_termios_device_lock_release (ctx, &lock_context);
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) &&
(tty->flow.start_remote_tx != NULL)) {
tty->flow.start_remote_tx(ctx);
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
}
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
tty->flow_ctrl |= FL_MDXOF;
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
tty->flow_ctrl |= FL_MDXON;
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
int flags;
sc = RTEMS_SUCCESSFUL;
args->ioctl_return = 0;
rtems_mutex_lock (&tty->osem);
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
} else if (tty->handler.ioctl) {
args->ioctl_return = (*tty->handler.ioctl) (tty->device_context,
args->command, args->buffer);
sc = RTEMS_SUCCESSFUL;
} else {
sc = RTEMS_INVALID_NUMBER;
}
break;
case TIOCGETA:
*(struct termios *)args->buffer = tty->termios;
break;
case TIOCSETA:
case TIOCSETAW:
case TIOCSETAF:
tty->termios = *(struct termios *)args->buffer;
if (args->command == TIOCSETAW || args->command == TIOCSETAF) {
drainOutput (tty);
if (args->command == TIOCSETAF) {
flushInput (tty);
}
}
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreWait = true;
tty->rawInBufSemaphoreTimeout = 0;
tty->rawInBufSemaphoreFirstTimeout = 0;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreWait = true;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = 0;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreWait = true;
tty->rawInBufSemaphoreTimeout = 0;
tty->rawInBufSemaphoreFirstTimeout = 0;
} else {
tty->rawInBufSemaphoreWait = false;
}
}
}
if (tty->handler.set_attributes) {
sc = (*tty->handler.set_attributes)(tty->device_context, &tty->termios) ?
RTEMS_SUCCESSFUL : RTEMS_IO_ERROR;
}
break;
case TIOCDRAIN:
drainOutput (tty);
break;
case TIOCFLUSH:
flags = *((int *)args->buffer);
if (flags == 0) {
flags = FREAD | FWRITE;
} else {
flags &= FREAD | FWRITE;
}
if (flags & FWRITE) {
flushOutput (tty);
}
if (flags & FREAD) {
flushInput (tty);
}
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
break;
/*
* FIXME: add various ioctl code handlers
*/
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_mutex_unlock (&tty->osem);
return sc;
}
/*
* Send as many chars at once as possible to device-specific code.
* If transmitting==true then assume transmission is already running and
* an explicit write(0) is needed if output has to stop for flow control.
*/
static unsigned int
startXmit (
struct rtems_termios_tty *tty,
unsigned int newTail,
bool transmitting
)
{
unsigned int nToSend;
tty->rawOutBufState = rob_busy;
/* if XOFF was received, do not (re)start output */
if (tty->flow_ctrl & FL_ORCVXOF) {
/* set flag, that output has been stopped */
tty->flow_ctrl |= FL_OSTOP;
nToSend = 0;
/* stop transmitter */
if (transmitting) {
(*tty->handler.write) (tty->device_context, NULL, 0);
}
} else {
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF))
nToSend = 1;
else if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
(*tty->handler.write)(
tty->device_context, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
return nToSend;
}
/*
* Send characters to device-specific code
*/
static size_t
doTransmit (const char *buf, size_t len, rtems_termios_tty *tty,
bool wait, bool nextWait)
{
unsigned int newHead;
rtems_termios_device_context *ctx = tty->device_context;
rtems_interrupt_lock_context lock_context;
size_t todo;
if (tty->handler.mode == TERMIOS_POLLED) {
(*tty->handler.write)(ctx, buf, len);
return len;
}
todo = len;
while (todo > 0) {
size_t nToCopy;
size_t nAvail;
/* Check space for at least one char */
newHead = tty->rawOutBuf.Head + 1;
if (newHead >= tty->rawOutBuf.Size)
newHead -= tty->rawOutBuf.Size;
rtems_termios_device_lock_acquire (ctx, &lock_context);
if (newHead == tty->rawOutBuf.Tail) {
if (wait) {
do {
tty->rawOutBufState = rob_wait;
rtems_termios_device_lock_release (ctx, &lock_context);
rtems_binary_semaphore_wait (&tty->rawOutBuf.Semaphore);
rtems_termios_device_lock_acquire (ctx, &lock_context);
} while (newHead == tty->rawOutBuf.Tail);
} else {
rtems_termios_device_lock_release (ctx, &lock_context);
return len - todo;
}
}
/* Determine free space up to current tail or end of ring buffer */
nToCopy = todo;
if (tty->rawOutBuf.Tail > tty->rawOutBuf.Head) {
/* Available space is contiguous from Head to Tail */
nAvail = tty->rawOutBuf.Tail - tty->rawOutBuf.Head - 1;
} else {
/* Available space wraps at buffer end. To keep it simple, utilize
only the free space from Head to end during this iteration */
nAvail = tty->rawOutBuf.Size - tty->rawOutBuf.Head;
/* Head may not touch Tail after wraparound */
if (tty->rawOutBuf.Tail == 0)
nAvail--;
}
if (nToCopy > nAvail)
nToCopy = nAvail;
/* To minimize latency, the memcpy could be done
* with interrupts enabled or with limit on nToCopy (TBD)
*/
memcpy(&tty->rawOutBuf.theBuf[tty->rawOutBuf.Head], buf, nToCopy);
newHead = tty->rawOutBuf.Head + nToCopy;
if (newHead >= tty->rawOutBuf.Size)
newHead -= tty->rawOutBuf.Size;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
startXmit (tty, tty->rawOutBuf.Tail, false);
}
rtems_termios_device_lock_release (ctx, &lock_context);
buf += nToCopy;
todo -= nToCopy;
wait = nextWait;
}
return len;
}
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
doTransmit (_buf, len, tty, true, true);
}
static bool
canTransmit (rtems_termios_tty *tty, bool wait, size_t len)
{
rtems_termios_device_context *ctx;
rtems_interrupt_lock_context lock_context;
unsigned int capacity;
if (wait || tty->handler.mode == TERMIOS_POLLED) {
return true;
}
ctx = tty->device_context;
rtems_termios_device_lock_acquire (ctx, &lock_context);
capacity = (tty->rawOutBuf.Tail - tty->rawOutBuf.Head - 1) %
tty->rawOutBuf.Size;
rtems_termios_device_lock_release (ctx, &lock_context);
return capacity >= len;
}
/*
* Handle output processing
*/
static bool
oproc (unsigned char c, rtems_termios_tty *tty, bool wait)
{
char buf[8];
size_t len;
buf[0] = c;
len = 1;
if (tty->termios.c_oflag & OPOST) {
int oldColumn = tty->column;
int columnAdj = 0;
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
columnAdj = -oldColumn;
if (tty->termios.c_oflag & ONLCR) {
len = 2;
if (!canTransmit (tty, wait, len)) {
return false;
}
columnAdj = -oldColumn;
buf[0] = '\r';
buf[1] = c;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (oldColumn == 0))
return true;
if (tty->termios.c_oflag & OCRNL) {
buf[0] = '\n';
if (tty->termios.c_oflag & ONLRET)
columnAdj = -oldColumn;
} else {
columnAdj = -oldColumn;
}
break;
case '\t':
columnAdj = 8 - (oldColumn & 7);
if ((tty->termios.c_oflag & TABDLY) == OXTABS) {
int i;
len = (size_t) columnAdj;
if (!canTransmit (tty, wait, len)) {
return false;
}
for (i = 0; i < columnAdj; ++i) {
buf[i] = ' ';
}
}
break;
case '\b':
if (oldColumn > 0)
columnAdj = -1;
break;
default:
if (tty->termios.c_oflag & OLCUC) {
c = toupper(c);
buf[0] = c;
}
if (!iscntrl(c))
columnAdj = 1;
break;
}
tty->column = oldColumn + columnAdj;
}
return doTransmit (buf, len, tty, wait, true) > 0;
}
static uint32_t
rtems_termios_write_tty (rtems_libio_t *iop, rtems_termios_tty *tty,
const char *buf, uint32_t len)
{
bool wait = !rtems_libio_iop_is_no_delay (iop);
if (tty->termios.c_oflag & OPOST) {
uint32_t todo = len;
while (todo > 0) {
if (!oproc (*buf, tty, wait)) {
break;
}
++buf;
--todo;
wait = false;
}
return len - todo;
} else {
return doTransmit (buf, len, tty, wait, false);
}
}
rtems_status_code
rtems_termios_write (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_mutex_lock (&tty->osem);
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
rtems_status_code sc;
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_mutex_unlock (&tty->osem);
return sc;
}
args->bytes_moved = rtems_termios_write_tty (args->iop, tty,
args->buffer, args->count);
rtems_mutex_unlock (&tty->osem);
return RTEMS_SUCCESSFUL;
}
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
doTransmit (echobuf, 2, tty, true, true);
tty->column += 2;
} else {
oproc (c, tty, true);
}
}
/*
* Erase a character or line
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
}
}
/*
* Back up over the tab
*/
while (tty->column > col) {
doTransmit ("\b", 1, tty, true, true);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
doTransmit ("\b \b", 3, tty, true, true);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
doTransmit ("\b \b", 3, tty, true, true);
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
break;
}
}
static unsigned char
iprocEarly (unsigned char c, rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if (c == '\n') {
if (tty->termios.c_iflag & INLCR)
c = '\r';
}
return c;
}
/*
* This points to the currently registered method to perform
* ISIG processing of VKILL and VQUIT characters.
*/
static rtems_termios_isig_handler termios_isig_handler =
rtems_termios_default_isig_handler;
/*
* This is the default method to process VKILL or VQUIT characters if
* ISIG processing is enabled. Note that it does nothing.
*/
rtems_termios_isig_status_code rtems_termios_default_isig_handler(
unsigned char c,
struct rtems_termios_tty *tty
)
{
return RTEMS_TERMIOS_ISIG_WAS_NOT_PROCESSED;
}
/*
* Register a method to process VKILL or VQUIT characters if
* ISIG processing is enabled.
*/
rtems_status_code rtems_termios_register_isig_handler(
rtems_termios_isig_handler handler
)
{
if (handler == NULL) {
return RTEMS_INVALID_ADDRESS;
}
termios_isig_handler = handler;
return RTEMS_SUCCESSFUL;
}
/**
* @brief Type returned by all input processing (iproc) methods
*/
typedef enum {
/**
* This indicates that the input processing can continue.
*/
RTEMS_TERMIOS_IPROC_CONTINUE,
/**
* This indicates that the input processing is done.
*/
RTEMS_TERMIOS_IPROC_DONE,
/**
* This indicates that the character was processed and determined
* to be one that requires a signal to be raised (e.g. VINTR or
* VKILL). The tty must be in the right termios mode for this to
* occur. There is no further processing of this character required and
* the pending read() operation should be interrupted.
*/
RTEMS_TERMIOS_IPROC_INTERRUPT
} rtems_termios_iproc_status_code;
/*
* Process a single input character
*/
static rtems_termios_iproc_status_code
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
/*
* If signals are enabled, then allow possibility of VINTR causing
* SIGINTR and VQUIT causing SIGQUIT. Invoke user provided isig handler.
*/
if ((tty->termios.c_lflag & ISIG)) {
if ((c == tty->termios.c_cc[VINTR]) || (c == tty->termios.c_cc[VQUIT])) {
rtems_termios_isig_status_code rc;
rc = (*termios_isig_handler)(c, tty);
if (rc == RTEMS_TERMIOS_ISIG_INTERRUPT_READ) {
return RTEMS_TERMIOS_IPROC_INTERRUPT;
}
return RTEMS_TERMIOS_IPROC_CONTINUE;
}
}
/*
* Perform canonical character processing.
*/
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return RTEMS_TERMIOS_IPROC_CONTINUE;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return RTEMS_TERMIOS_IPROC_CONTINUE;
}
else if (c == tty->termios.c_cc[VEOF]) {
return RTEMS_TERMIOS_IPROC_DONE;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return RTEMS_TERMIOS_IPROC_DONE;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return RTEMS_TERMIOS_IPROC_DONE;
}
}
/*
* Perform non-canonical character processing.
*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return RTEMS_TERMIOS_IPROC_CONTINUE;
}
/*
* Process input character, with semaphore.
*/
static rtems_termios_iproc_status_code
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
rtems_termios_iproc_status_code rc;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_mutex_lock (&tty->osem);
rc = iproc (c, tty);
rtems_mutex_unlock (&tty->osem);
}
else {
rc = iproc (c, tty);
}
return rc;
}
static rtems_termios_iproc_status_code
siprocPoll (unsigned char c, rtems_termios_tty *tty)
{
if (c == '\r' && (tty->termios.c_iflag & IGNCR) != 0) {
return RTEMS_TERMIOS_IPROC_CONTINUE;
}
/*
* iprocEarly is done at the interrupt level for interrupt driven
* devices so we need to perform those actions before processing
* the character.
*/
c = iprocEarly (c, tty);
return siproc (c, tty);
}
/*
* Fill the input buffer by polling the device
*/
static rtems_termios_iproc_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
rtems_termios_iproc_status_code rc;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->handler.poll_read)(tty->device_context);
if (n < 0) {
rtems_task_wake_after (1);
} else {
rc = siprocPoll (n, tty);
if (rc != RTEMS_TERMIOS_IPROC_CONTINUE) {
return rc;
}
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->handler.poll_read)(tty->device_context);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
if (tty->termios.c_cc[VTIME] && tty->ccount) {
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
break;
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
} else {
rc = siprocPoll (n, tty);
if (rc != RTEMS_TERMIOS_IPROC_CONTINUE) {
return rc;
}
if (tty->ccount >= tty->termios.c_cc[VMIN])
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
then = rtems_clock_get_ticks_since_boot();
}
}
}
return RTEMS_TERMIOS_IPROC_CONTINUE;
}
/*
* Fill the input buffer from the raw input queue
*/
static rtems_termios_iproc_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_termios_device_context *ctx = tty->device_context;
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
bool wait = true;
while ( wait ) {
rtems_interrupt_lock_context lock_context;
/*
* Process characters read from raw queue
*/
rtems_termios_device_lock_acquire (ctx, &lock_context);
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
rtems_termios_iproc_status_code rc;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail - newHead) % tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->handler.write)(
tty->device_context, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
/* activate RTS line */
if (tty->flow.start_remote_tx != NULL) {
tty->flow.start_remote_tx(tty->device_context);
}
}
}
rtems_termios_device_lock_release (ctx, &lock_context);
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
rc = siproc (c, tty);
if (rc != RTEMS_TERMIOS_IPROC_CONTINUE) {
return rc;
}
} else {
rc = siproc (c, tty);
/* in non-canonical mode only stop on interrupt */
if (rc == RTEMS_TERMIOS_IPROC_INTERRUPT) {
return rc;
}
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = false;
}
timeout = tty->rawInBufSemaphoreTimeout;
rtems_termios_device_lock_acquire (ctx, &lock_context);
}
rtems_termios_device_lock_release (ctx, &lock_context);
/*
* Wait for characters
*/
if (wait) {
if (tty->ccount < CBUFSIZE - 1) {
rtems_binary_semaphore *sem;
int eno;
sem = &tty->rawInBuf.Semaphore;
if (tty->rawInBufSemaphoreWait) {
eno = rtems_binary_semaphore_wait_timed_ticks (sem, timeout);
} else {
eno = rtems_binary_semaphore_try_wait (sem);
}
if (eno != 0) {
break;
}
} else {
break;
}
}
}
return RTEMS_TERMIOS_IPROC_CONTINUE;
}
static rtems_status_code
rtems_termios_read_tty (
struct rtems_termios_tty *tty,
char *buffer,
uint32_t initial_count,
uint32_t *count_read
)
{
uint32_t count;
rtems_termios_iproc_status_code rc;
count = initial_count;
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->handler.poll_read != NULL && tty->handler.mode == TERMIOS_POLLED)
rc = fillBufferPoll (tty);
else
rc = fillBufferQueue (tty);
} else {
rc = RTEMS_TERMIOS_IPROC_CONTINUE;
}
/*
* If there are characters in the buffer, then copy them to the caller.
*/
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
tty->tty_rcvwakeup = false;
*count_read = initial_count - count;
/*
* fillBufferPoll and fillBufferQueue can indicate that the operation
* was interrupted. The isig handler can do nothing, have POSIX behavior
* and cause a signal, or a user defined action.
*/
if (rc == RTEMS_TERMIOS_IPROC_INTERRUPT) {
return RTEMS_INTERRUPTED;
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
rtems_mutex_lock (&tty->isem);
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
tty->tty_rcvwakeup = false;
rtems_mutex_unlock (&tty->isem);
return sc;
}
sc = rtems_termios_read_tty(
tty,
args->buffer,
args->count,
&args->bytes_moved
);
rtems_mutex_unlock (&tty->isem);
return sc;
}
/*
* signal receive interrupt to rx daemon
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
*/
void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty)
{
/*
* send event to rx daemon task
*/
rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);
}
static bool
mustCallReceiveCallback (const rtems_termios_tty *tty, unsigned char c,
unsigned int newTail, unsigned int head)
{
if ((tty->termios.c_lflag & ICANON) != 0) {
return c == '\n' || c == tty->termios.c_cc[VEOF] ||
c == tty->termios.c_cc[VEOL] || c == tty->termios.c_cc[VEOL2];
} else {
unsigned int rawContentSize = (newTail - head) % tty->rawInBuf.Size;
return rawContentSize >= tty->termios.c_cc[VMIN];
}
}
/*
* Place characters on raw queue.
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
struct rtems_termios_tty *tty = ttyp;
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_termios_device_context *ctx = tty->device_context;
rtems_interrupt_lock_context lock_context;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
}
/*
* check to see if rcv wakeup callback was set
*/
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
tty->tty_rcvwakeup = true;
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
}
return 0;
}
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_termios_device_lock_acquire (ctx, &lock_context);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->handler.write)(
ctx, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_termios_device_lock_release (ctx, &lock_context);
}
} else {
unsigned int head;
unsigned int oldTail;
unsigned int newTail;
bool callReciveCallback;
if (c == '\r' && (tty->termios.c_iflag & IGNCR) != 0) {
continue;
}
c = iprocEarly (c, tty);
rtems_termios_device_lock_acquire (ctx, &lock_context);
head = tty->rawInBuf.Head;
oldTail = tty->rawInBuf.Tail;
newTail = (oldTail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
if ((tty->flow_ctrl & FL_IREQXOF) != 0 && (((newTail - head) %
tty->rawInBuf.Size) > tty->highwater)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->handler.write)(ctx,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
/* deactivate RTS line */
if (tty->flow.stop_remote_tx != NULL) {
tty->flow.stop_remote_tx(ctx);
}
}
}
callReciveCallback = false;
if (newTail != head) {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
if (mustCallReceiveCallback (tty, c, newTail, head)) {
tty->tty_rcvwakeup = true;
callReciveCallback = true;
}
}
} else {
++dropped;
if (tty->tty_rcv.sw_pfn != NULL && !tty->tty_rcvwakeup) {
tty->tty_rcvwakeup = true;
callReciveCallback = true;
}
}
rtems_termios_device_lock_release (ctx, &lock_context);
if (callReciveCallback) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
}
}
}
tty->rawInBufDropped += dropped;
rtems_binary_semaphore_post (&tty->rawInBuf.Semaphore);
return dropped;
}
/*
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
static int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
bool wakeUpWriterTask = false;
unsigned int newTail;
int nToSend;
rtems_termios_device_context *ctx = tty->device_context;
rtems_interrupt_lock_context lock_context;
int len;
rtems_termios_device_lock_acquire (ctx, &lock_context);
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->handler.write)(ctx, (void *)&(tty->termios.c_cc[VSTOP]), 1);
tty->t_dqlen--;
tty->flow_ctrl |= FL_ISNTXOF;
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
/* NOTE: send XON even, if no longer in XON/XOFF mode... */
/* XON should be sent now... */
/*
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->handler.write)(ctx, (void *)&(tty->termios.c_cc[VSTART]), 1);
tty->t_dqlen--;
tty->flow_ctrl &= ~FL_ISNTXOF;
nToSend = 1;
} else if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
/*
* this should never happen...
*/
wakeUpWriterTask = true;
}
(*tty->handler.write) (ctx, NULL, 0);
nToSend = 0;
} else {
len = tty->t_dqlen;
tty->t_dqlen = 0;
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
wakeUpWriterTask = true;
}
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
(*tty->handler.write) (ctx, NULL, 0);
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
} else {
/*
* Buffer not empty, check flow control, start transmitter
*/
nToSend = startXmit (tty, newTail, true);
}
}
rtems_termios_device_lock_release (ctx, &lock_context);
if (wakeUpWriterTask) {
rtems_binary_semaphore_post (&tty->rawOutBuf.Semaphore);
}
return nToSend;
}
/*
* Characters have been transmitted
* NOTE: This routine runs in the context of the
* device transmit interrupt handler.
* The second argument is the number of characters transmitted so far.
* This value will always be 1 for devices which generate an interrupt
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
struct rtems_termios_tty *tty = ttyp;
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
/*
* call PPP line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
struct rtems_termios_tty *tty = (struct rtems_termios_tty *)argument;
rtems_event_set the_event;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
tty->txTaskId = 0;
rtems_task_exit();
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
rtems_termios_linesw[tty->t_line].l_start(tty);
if (tty->t_line == PPPDISC) {
/*
* Do not call rtems_termios_refill_transmitter() in this case similar
* to rtems_termios_dequeue_characters().
*/
continue;
}
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
}
}
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
struct rtems_termios_tty *tty = (struct rtems_termios_tty *)argument;
rtems_termios_device_context *ctx = tty->device_context;
rtems_event_set the_event;
int c;
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
tty->rxTaskId = 0;
rtems_task_exit();
}
/*
* do something
*/
c = tty->handler.poll_read(ctx);
if (c != EOF) {
/*
* poll_read did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
}
}
}
static int
rtems_termios_imfs_open (rtems_libio_t *iop,
const char *path, int oflag, mode_t mode)
{
rtems_termios_device_node *device_node;
rtems_libio_open_close_args_t args;
struct rtems_termios_tty *tty;
device_node = IMFS_generic_get_context_by_iop (iop);
memset (&args, 0, sizeof (args));
args.iop = iop;
args.flags = rtems_libio_iop_flags (iop);
args.mode = mode;
rtems_termios_obtain ();
tty = rtems_termios_open_tty (device_node->major, device_node->minor, &args,
device_node->tty, device_node, NULL);
if (tty == NULL) {
rtems_termios_release ();
rtems_set_errno_and_return_minus_one (ENOMEM);
}
rtems_termios_release ();
return 0;
}
static int
rtems_termios_imfs_close (rtems_libio_t *iop)
{
rtems_libio_open_close_args_t args;
struct rtems_termios_tty *tty;
memset (&args, 0, sizeof (args));
args.iop = iop;
tty = iop->data1;
rtems_termios_obtain ();
rtems_termios_close_tty (tty, &args);
rtems_termios_release ();
return 0;
}
static ssize_t
rtems_termios_imfs_read (rtems_libio_t *iop, void *buffer, size_t count)
{
struct rtems_termios_tty *tty;
uint32_t bytes_moved;
rtems_status_code sc;
tty = iop->data1;
rtems_mutex_lock (&tty->isem);
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
rtems_libio_rw_args_t args;
rtems_status_code sc;
memset (&args, 0, sizeof (args));
args.iop = iop;
args.buffer = buffer;
args.count = count;
args.flags = rtems_libio_iop_flags (iop);
sc = rtems_termios_linesw[tty->t_line].l_read (tty, &args);
tty->tty_rcvwakeup = false;
rtems_mutex_unlock (&tty->isem);
if (sc != RTEMS_SUCCESSFUL) {
return rtems_status_code_to_errno (sc);
}
return (ssize_t) args.bytes_moved;
}
sc = rtems_termios_read_tty(tty, buffer, count, &bytes_moved);
rtems_mutex_unlock (&tty->isem);
if (sc != RTEMS_SUCCESSFUL) {
return rtems_status_code_to_errno (sc);
}
return (ssize_t) bytes_moved;
}
static ssize_t
rtems_termios_imfs_write (rtems_libio_t *iop, const void *buffer, size_t count)
{
struct rtems_termios_tty *tty;
uint32_t bytes_moved;
tty = iop->data1;
rtems_mutex_lock (&tty->osem);
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
rtems_libio_rw_args_t args;
rtems_status_code sc;
memset (&args, 0, sizeof (args));
args.iop = iop;
args.buffer = RTEMS_DECONST (void *, buffer);
args.count = count;
args.flags = rtems_libio_iop_flags (iop);
sc = rtems_termios_linesw[tty->t_line].l_write (tty, &args);
rtems_mutex_unlock (&tty->osem);
if (sc != RTEMS_SUCCESSFUL) {
return rtems_status_code_to_errno (sc);
}
return (ssize_t) args.bytes_moved;
}
bytes_moved = rtems_termios_write_tty (iop, tty, buffer, count);
rtems_mutex_unlock (&tty->osem);
return (ssize_t) bytes_moved;
}
static int
rtems_termios_imfs_ioctl (rtems_libio_t *iop, ioctl_command_t request,
void *buffer)
{
rtems_status_code sc;
rtems_libio_ioctl_args_t args;
memset (&args, 0, sizeof (args));
args.iop = iop;
args.command = request;
args.buffer = buffer;
sc = rtems_termios_ioctl (&args);
if ( sc == RTEMS_SUCCESSFUL ) {
return args.ioctl_return;
} else {
return rtems_status_code_to_errno (sc);
}
}
static const rtems_filesystem_file_handlers_r rtems_termios_imfs_handler = {
.open_h = rtems_termios_imfs_open,
.close_h = rtems_termios_imfs_close,
.read_h = rtems_termios_imfs_read,
.write_h = rtems_termios_imfs_write,
.ioctl_h = rtems_termios_imfs_ioctl,
.lseek_h = rtems_filesystem_default_lseek,
.fstat_h = IMFS_stat,
.ftruncate_h = rtems_filesystem_default_ftruncate,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl,
.kqfilter_h = rtems_termios_kqfilter,
.mmap_h = rtems_termios_mmap,
.poll_h = rtems_termios_poll,
.readv_h = rtems_filesystem_default_readv,
.writev_h = rtems_filesystem_default_writev
};
static IMFS_jnode_t *
rtems_termios_imfs_node_initialize (IMFS_jnode_t *node, void *arg)
{
rtems_termios_device_node *device_node;
dev_t dev;
node = IMFS_node_initialize_generic (node, arg);
device_node = IMFS_generic_get_context_by_node (node);
dev = IMFS_generic_get_device_identifier_by_node (node);
device_node->major = rtems_filesystem_dev_major_t (dev);
device_node->minor = rtems_filesystem_dev_minor_t (dev);
return node;
}
static void
rtems_termios_imfs_node_destroy (IMFS_jnode_t *node)
{
rtems_termios_device_node *device_node;
device_node = IMFS_generic_get_context_by_node (node);
free (device_node);
IMFS_node_destroy_default (node);
}
static const IMFS_node_control rtems_termios_imfs_node_control =
IMFS_GENERIC_INITIALIZER(
&rtems_termios_imfs_handler,
rtems_termios_imfs_node_initialize,
rtems_termios_imfs_node_destroy
);
View Git Blame Copy Permalink