sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
fc05f89c78
nuttx/drivers/serial/serial.c
Tido Klaassen 93ff68e75a serial: Prevent RX stall 
Re-check RX queue status after uart_enablerxint() and before blocking
the reading task on the receive semaphore. cdcacm (and maybe other UART
drivers) can push buffered data into the receive queue during
uart_enablerxint(), leading to a blocked task while data is already
available.

Signed-off-by: Tido Klaassen <tido@4gh.eu>
2020-11-20 04:16:35 -08:00

1797 lines
50 KiB
C
Raw Blame History

/************************************************************************************
* drivers/serial/serial.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
************************************************************************************/
/************************************************************************************
* Included Files
************************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <poll.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/irq.h>
#include <nuttx/arch.h>
#include <nuttx/clock.h>
#include <nuttx/sched.h>
#include <nuttx/signal.h>
#include <nuttx/fs/fs.h>
#include <nuttx/serial/serial.h>
#include <nuttx/fs/ioctl.h>
#include <nuttx/power/pm.h>
/************************************************************************************
* Pre-processor Definitions
************************************************************************************/
/* Check watermark levels */
#if defined(CONFIG_SERIAL_IFLOWCONTROL) && \
defined(CONFIG_SERIAL_IFLOWCONTROL_WATERMARKS)
# if CONFIG_SERIAL_IFLOWCONTROL_LOWER_WATERMARK < 1
# warning CONFIG_SERIAL_IFLOWCONTROL_LOWER_WATERMARK too small
# endif
# if CONFIG_SERIAL_IFLOWCONTROL_UPPER_WATERMARK > 99
# warning CONFIG_SERIAL_IFLOWCONTROL_UPPER_WATERMARK too large
# endif
# if CONFIG_SERIAL_IFLOWCONTROL_LOWER_WATERMARK >= CONFIG_SERIAL_IFLOWCONTROL_UPPER_WATERMARK
# warning CONFIG_SERIAL_IFLOWCONTROL_LOWER_WATERMARK too large
# warning Must be less than CONFIG_SERIAL_IFLOWCONTROL_UPPER_WATERMARK
# endif
#endif
/* Timing */
#define POLL_DELAY_USEC 1000
/************************************************************************************
* Private Types
************************************************************************************/
/************************************************************************************
* Private Function Prototypes
************************************************************************************/
static int uart_takesem(FAR sem_t *sem, bool errout);
static void uart_pollnotify(FAR uart_dev_t *dev, pollevent_t eventset);
/* Write support */
static int uart_putxmitchar(FAR uart_dev_t *dev, int ch, bool oktoblock);
static inline ssize_t uart_irqwrite(FAR uart_dev_t *dev, FAR const char *buffer,
size_t buflen);
static int uart_tcdrain(FAR uart_dev_t *dev, clock_t timeout);
/* Character driver methods */
static int uart_open(FAR struct file *filep);
static int uart_close(FAR struct file *filep);
static ssize_t uart_read(FAR struct file *filep, FAR char *buffer, size_t buflen);
static ssize_t uart_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen);
static int uart_ioctl(FAR struct file *filep, int cmd, unsigned long arg);
static int uart_poll(FAR struct file *filep, FAR struct pollfd *fds, bool setup);
/************************************************************************************
* Private Data
************************************************************************************/
static const struct file_operations g_serialops =
{
uart_open, /* open */
uart_close, /* close */
uart_read, /* read */
uart_write, /* write */
0, /* seek */
uart_ioctl, /* ioctl */
uart_poll /* poll */
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
, NULL /* unlink */
#endif
};
/************************************************************************************
* Private Functions
************************************************************************************/
/************************************************************************************
* Name: uart_takesem
************************************************************************************/
static int uart_takesem(FAR sem_t *sem, bool errout)
{
if (errout)
{
return nxsem_wait(sem);
}
else
{
return nxsem_wait_uninterruptible(sem);
}
}
/************************************************************************************
* Name: uart_givesem
************************************************************************************/
#define uart_givesem(sem) (void)nxsem_post(sem)
/************************************************************************************
* Name: uart_pollnotify
************************************************************************************/
static void uart_pollnotify(FAR uart_dev_t *dev, pollevent_t eventset)
{
int i;
for (i = 0; i < CONFIG_SERIAL_NPOLLWAITERS; i++)
{
struct pollfd *fds = dev->fds[i];
if (fds)
{
#ifdef CONFIG_SERIAL_REMOVABLE
fds->revents |= ((fds->events | (POLLERR | POLLHUP)) & eventset);
#else
fds->revents |= (fds->events & eventset);
#endif
if (fds->revents != 0)
{
irqstate_t flags;
int semcount;
finfo("Report events: %02x\n", fds->revents);
/* Limit the number of times that the semaphore is posted.
* The critical section is needed to make the following
* operation atomic.
*/
flags = enter_critical_section();
nxsem_get_value(fds->sem, &semcount);
if (semcount < 1)
{
nxsem_post(fds->sem);
}
leave_critical_section(flags);
}
}
}
}
/************************************************************************************
* Name: uart_putxmitchar
************************************************************************************/
static int uart_putxmitchar(FAR uart_dev_t *dev, int ch, bool oktoblock)
{
irqstate_t flags;
int nexthead;
int ret;
#ifdef CONFIG_SMP
irqstate_t flags2 = enter_critical_section();
#endif
/* Increment to see what the next head pointer will be. We need to use the "next"
* head pointer to determine when the circular buffer would overrun
*/
nexthead = dev->xmit.head + 1;
if (nexthead >= dev->xmit.size)
{
nexthead = 0;
}
/* Loop until we are able to add the character to the TX buffer. */
for (; ; )
{
/* Check if the TX buffer is full */
if (nexthead != dev->xmit.tail)
{
/* No.. not full. Add the character to the TX buffer and return. */
dev->xmit.buffer[dev->xmit.head] = ch;
dev->xmit.head = nexthead;
ret = OK;
goto err_out;
}
/* The TX buffer is full. Should be block, waiting for the hardware
* to remove some data from the TX buffer?
*/
else if (oktoblock)
{
/* The following steps must be atomic with respect to serial
* interrupt handling.
*/
flags = enter_critical_section();
/* Check again... In certain race conditions an interrupt may
* have occurred between the test at the top of the loop and
* entering the critical section and the TX buffer may no longer
* be full.
*
* NOTE: On certain devices, such as USB CDC/ACM, the entire TX
* buffer may have been emptied in this race condition. In that
* case, the logic would hang below waiting for space in the TX
* buffer without this test.
*/
if (nexthead != dev->xmit.tail)
{
ret = OK;
}
#ifdef CONFIG_SERIAL_REMOVABLE
/* Check if the removable device is no longer connected while we
* have interrupts off. We do not want the transition to occur
* as a race condition before we begin the wait.
*/
else if (dev->disconnected)
{
ret = -ENOTCONN;
}
#endif
else
{
/* Inform the interrupt level logic that we are waiting. */
dev->xmitwaiting = true;
/* Wait for some characters to be sent from the buffer with
* the TX interrupt enabled. When the TX interrupt is enabled,
* uart_xmitchars() should execute and remove some of the data
* from the TX buffer.
*
* NOTE that interrupts will be re-enabled while we wait for
* the semaphore.
*/
#ifdef CONFIG_SERIAL_TXDMA
uart_dmatxavail(dev);
#endif
uart_enabletxint(dev);
ret = uart_takesem(&dev->xmitsem, true);
uart_disabletxint(dev);
}
leave_critical_section(flags);
#ifdef CONFIG_SERIAL_REMOVABLE
/* Check if the removable device was disconnected while we were
* waiting.
*/
if (dev->disconnected)
{
ret = -ENOTCONN;
goto err_out;
}
#endif
/* Check if we were awakened by signal. */
if (ret < 0)
{
/* A signal received while waiting for the xmit buffer to become
* non-full will abort the transfer.
*/
ret = -EINTR;
goto err_out;
}
}
/* The caller has request that we not block for data. So return the
* EAGAIN error to signal this situation.
*/
else
{
ret = -EAGAIN;
goto err_out;
}
}
/* We won't get here. Some compilers may complain that this code is
* unreachable.
*/
ret = OK;
err_out:
#ifdef CONFIG_SMP
leave_critical_section(flags2);
#endif
return ret;
}
/************************************************************************************
* Name: uart_putc
************************************************************************************/
static inline void uart_putc(FAR uart_dev_t *dev, int ch)
{
while (!uart_txready(dev))
{
}
uart_send(dev, ch);
}
/************************************************************************************
* Name: uart_irqwrite
************************************************************************************/
static inline ssize_t uart_irqwrite(FAR uart_dev_t *dev, FAR const char *buffer,
size_t buflen)
{
ssize_t ret = buflen;
/* Force each character through the low level interface */
for (; buflen; buflen--)
{
int ch = *buffer++;
#ifdef CONFIG_SERIAL_TERMIOS
/* Do output post-processing */
if ((dev->tc_oflag & OPOST) != 0)
{
/* Mapping CR to NL? */
if ((ch == '\r') && (dev->tc_oflag & OCRNL) != 0)
{
ch = '\n';
}
/* Are we interested in newline processing? */
if ((ch == '\n') && (dev->tc_oflag & (ONLCR | ONLRET)) != 0)
{
uart_putc(dev, '\r');
}
}
#else /* !CONFIG_SERIAL_TERMIOS */
/* If this is the console, then we should replace LF with CR-LF */
if (dev->isconsole && ch == '\n')
{
uart_putc(dev, '\r');
}
#endif
/* Output the character, using the low-level direct UART interfaces */
uart_putc(dev, ch);
}
return ret;
}
/************************************************************************************
* Name: uart_tcdrain
*
* Description:
* Block further TX input. Wait until all data has been transferred from the TX
* buffer and until the hardware TX FIFOs are empty.
*
************************************************************************************/
static int uart_tcdrain(FAR uart_dev_t *dev, clock_t timeout)
{
int ret;
/* Get exclusive access to the to dev->tmit. We cannot permit new data to be
* written while we are trying to flush the old data.
*
* A signal received while waiting for access to the xmit.head will abort the
* operation with EINTR.
*/
ret = (ssize_t)uart_takesem(&dev->xmit.sem, true);
if (ret >= 0)
{
irqstate_t flags;
clock_t start;
/* Trigger emission to flush the contents of the tx buffer */
flags = enter_critical_section();
#ifdef CONFIG_SERIAL_REMOVABLE
/* Check if the removable device is no longer connected while we have
* interrupts off. We do not want the transition to occur as a race
* condition before we begin the wait.
*/
if (dev->disconnected)
{
dev->xmit.tail = dev->xmit.head; /* Drop the buffered TX data */
ret = -ENOTCONN;
}
else
#endif
{
/* Continue waiting while the TX buffer is not empty.
*
* NOTE: There is no timeout on the following loop. In
* situations were this loop could hang (with hardware flow
* control, as an example), the caller should call
* tcflush() first to discard this buffered Tx data.
*/
ret = OK;
while (ret >= 0 && dev->xmit.head != dev->xmit.tail)
{
/* Inform the interrupt level logic that we are waiting. */
dev->xmitwaiting = true;
/* Wait for some characters to be sent from the buffer with
* the TX interrupt enabled. When the TX interrupt is
* enabled, uart_xmitchars() should execute and remove some
* of the data from the TX buffer. We may have to wait several
* times for the TX buffer to be entirely emptied.
*
* NOTE that interrupts will be re-enabled while we wait for
* the semaphore.
*/
#ifdef CONFIG_SERIAL_TXDMA
uart_dmatxavail(dev);
#endif
uart_enabletxint(dev);
ret = uart_takesem(&dev->xmitsem, true);
uart_disabletxint(dev);
}
}
leave_critical_section(flags);
/* The TX buffer is empty (or an error occurred). But there still may
* be data in the UART TX FIFO. We get no asynchronous indication of
* this event, so we have to do a busy wait poll.
*/
/* Set up for the timeout
*
* REVISIT: This is a kludge. The correct fix would be add an
* interface to the lower half driver so that the tcflush() operation
* all also cause the lower half driver to clear and reset the Tx FIFO.
*/
start = clock_systime_ticks();
if (ret >= 0)
{
while (!uart_txempty(dev))
{
clock_t elapsed;
nxsig_usleep(POLL_DELAY_USEC);
/* Check for a timeout */
elapsed = clock_systime_ticks() - start;
if (elapsed >= timeout)
{
return -ETIMEDOUT;
}
}
}
uart_givesem(&dev->xmit.sem);
}
return ret;
}
/************************************************************************************
* Name: uart_open
*
* Description:
* This routine is called whenever a serial port is opened.
*
************************************************************************************/
static int uart_open(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR uart_dev_t *dev = inode->i_private;
uint8_t tmp;
int ret;
/* If the port is the middle of closing, wait until the close is finished.
* If a signal is received while we are waiting, then return EINTR.
*/
ret = uart_takesem(&dev->closesem, true);
if (ret < 0)
{
/* A signal received while waiting for the last close operation. */
return ret;
}
#ifdef CONFIG_SERIAL_REMOVABLE
/* If the removable device is no longer connected, refuse to open the
* device. We check this after obtaining the close semaphore because
* we might have been waiting when the device was disconnected.
*/
if (dev->disconnected)
{
ret = -ENOTCONN;
goto errout_with_sem;
}
#endif
/* Start up serial port */
/* Increment the count of references to the device. */
tmp = dev->open_count + 1;
if (tmp == 0)
{
/* More than 255 opens; uint8_t overflows to zero */
ret = -EMFILE;
goto errout_with_sem;
}
/* Check if this is the first time that the driver has been opened. */
if (tmp == 1)
{
irqstate_t flags = enter_critical_section();
/* If this is the console, then the UART has already been initialized. */
if (!dev->isconsole)
{
/* Perform one time hardware initialization */
ret = uart_setup(dev);
if (ret < 0)
{
leave_critical_section(flags);
goto errout_with_sem;
}
}
/* In any event, we do have to configure for interrupt driven mode of
* operation. Attach the hardware IRQ(s). Hmm.. should shutdown() the
* the device in the rare case that uart_attach() fails, tmp==1, and
* this is not the console.
*/
ret = uart_attach(dev);
if (ret < 0)
{
uart_shutdown(dev);
leave_critical_section(flags);
goto errout_with_sem;
}
#ifdef CONFIG_SERIAL_RXDMA
/* Notify DMA that there is free space in the RX buffer */
uart_dmarxfree(dev);
#endif
/* Enable the RX interrupt */
uart_enablerxint(dev);
leave_critical_section(flags);
}
/* Save the new open count on success */
dev->open_count = tmp;
errout_with_sem:
uart_givesem(&dev->closesem);
return ret;
}
/************************************************************************************
* Name: uart_close
*
* Description:
* This routine is called when the serial port gets closed.
* It waits for the last remaining data to be sent.
*
************************************************************************************/
static int uart_close(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR uart_dev_t *dev = inode->i_private;
irqstate_t flags;
/* Get exclusive access to the close semaphore (to synchronize open/close
* operations. NOTE: that we do not let this wait be interrupted by a signal.
* Technically, we should, but almost no one every checks the return value from
* close() so we avoid a potential memory leak by ignoring signals in this case.
*/
uart_takesem(&dev->closesem, false);
if (dev->open_count > 1)
{
dev->open_count--;
uart_givesem(&dev->closesem);
return OK;
}
/* There are no more references to the port */
dev->open_count = 0;
/* Stop accepting input */
uart_disablerxint(dev);
/* Prevent blocking if the device is opened with O_NONBLOCK */
if ((filep->f_oflags & O_NONBLOCK) == 0)
{
/* Now we wait for the transmit buffer(s) to clear */
uart_tcdrain(dev, 4 * TICK_PER_SEC);
}
/* Free the IRQ and disable the UART */
flags = enter_critical_section(); /* Disable interrupts */
uart_detach(dev); /* Detach interrupts */
if (!dev->isconsole) /* Check for the serial console UART */
{
uart_shutdown(dev); /* Disable the UART */
}
leave_critical_section(flags);
/* Wake up read and poll functions */
uart_datareceived(dev);
/* We need to re-initialize the semaphores if this is the last close
* of the device, as the close might be caused by pthread_cancel() of
* a thread currently blocking on any of them.
*/
uart_reset_sem(dev);
uart_givesem(&dev->closesem);
return OK;
}
/************************************************************************************
* Name: uart_read
************************************************************************************/
static ssize_t uart_read(FAR struct file *filep, FAR char *buffer, size_t buflen)
{
FAR struct inode *inode = filep->f_inode;
FAR uart_dev_t *dev = inode->i_private;
FAR struct uart_buffer_s *rxbuf = &dev->recv;
#ifdef CONFIG_SERIAL_IFLOWCONTROL_WATERMARKS
unsigned int nbuffered;
unsigned int watermark;
#endif
irqstate_t flags;
ssize_t recvd = 0;
int16_t tail;
char ch;
int ret;
/* Only one user can access rxbuf->tail at a time */
ret = uart_takesem(&rxbuf->sem, true);
if (ret < 0)
{
/* A signal received while waiting for access to the recv.tail will avort
* the transfer. After the transfer has started, we are committed and
* signals will be ignored.
*/
return ret;
}
/* Loop while we still have data to copy to the receive buffer.
* we add data to the head of the buffer; uart_xmitchars takes the
* data from the end of the buffer.
*/
while ((size_t)recvd < buflen)
{
#ifdef CONFIG_SERIAL_REMOVABLE
/* If the removable device is no longer connected, refuse to read any
* further from the device.
*/
if (dev->disconnected)
{
if (recvd == 0)
{
recvd = -ENOTCONN;
}
break;
}
#endif
/* Check if there is more data to return in the circular buffer.
* NOTE: Rx interrupt handling logic may asynchronously increment
* the head index but must not modify the tail index. The tail
* index is only modified in this function. Therefore, no
* special handshaking is required here.
*
* The head and tail pointers are 16-bit values. The only time that
* the following could be unsafe is if the CPU made two non-atomic
* 8-bit accesses to obtain the 16-bit head index.
*/
tail = rxbuf->tail;
if (rxbuf->head != tail)
{
/* Take the next character from the tail of the buffer */
ch = rxbuf->buffer[tail];
/* Increment the tail index. Most operations are done using the
* local variable 'tail' so that the final rxbuf->tail update
* is atomic.
*/
if (++tail >= rxbuf->size)
{
tail = 0;
}
rxbuf->tail = tail;
#ifdef CONFIG_SERIAL_TERMIOS
/* Do input processing if any is enabled */
if (dev->tc_iflag & (INLCR | IGNCR | ICRNL))
{
/* \n -> \r or \r -> \n translation? */
if ((ch == '\n') && (dev->tc_iflag & INLCR))
{
ch = '\r';
}
else if ((ch == '\r') && (dev->tc_iflag & ICRNL))
{
ch = '\n';
}
/* Discarding \r ? */
if ((ch == '\r') & (dev->tc_iflag & IGNCR))
{
continue;
}
}
/* Specifically not handled:
*
* All of the local modes; echo, line editing, etc.
* Anything to do with break or parity errors.
* ISTRIP - we should be 8-bit clean.
* IUCLC - Not Posix
* IXON/OXOFF - no xon/xoff flow control.
*/
#endif
/* Store the received character */
*buffer++ = ch;
recvd++;
}
#ifdef CONFIG_DEV_SERIAL_FULLBLOCKS
/* No... then we would have to wait to get receive more data.
* If the user has specified the O_NONBLOCK option, then just
* return what we have.
*/
else if ((filep->f_oflags & O_NONBLOCK) != 0)
{
/* If nothing was transferred, then return the -EAGAIN
* error (not zero which means end of file).
*/
if (recvd < 1)
{
recvd = -EAGAIN;
}
break;
}
#else
/* No... the circular buffer is empty. Have we returned anything
* to the caller?
*/
else if (recvd > 0)
{
/* Yes.. break out of the loop and return the number of bytes
* received up to the wait condition.
*/
break;
}
else if (filep->f_inode == 0)
{
/* File has been closed.
* Descriptor is not valid.
*/
recvd = -EBADFD;
break;
}
/* No... then we would have to wait to get receive some data.
* If the user has specified the O_NONBLOCK option, then do not
* wait.
*/
else if ((filep->f_oflags & O_NONBLOCK) != 0)
{
/* Break out of the loop returning -EAGAIN */
recvd = -EAGAIN;
break;
}
#endif
/* Otherwise we are going to have to wait for data to arrive */
else
{
#ifdef CONFIG_SERIAL_RXDMA
/* Disable all interrupts and test again...
* uart_disablerxint() is insufficient for the check in DMA mode.
*/
flags = enter_critical_section();
#else
/* Disable Rx interrupts and test again... */
uart_disablerxint(dev);
#endif
/* If the Rx ring buffer still empty? Bytes may have been added
* between the last time that we checked and when we disabled
* interrupts.
*/
if (rxbuf->head == rxbuf->tail)
{
/* Yes.. the buffer is still empty. We will need to wait for
* additional data to be received.
*/
#ifdef CONFIG_SERIAL_RXDMA
/* Notify DMA that there is free space in the RX buffer */
uart_dmarxfree(dev);
#else
/* Wait with the RX interrupt re-enabled. All interrupts are
* disabled briefly to assure that the following operations
* are atomic.
*/
flags = enter_critical_section();
/* Re-enable UART Rx interrupts */
uart_enablerxint(dev);
/* Check again if the RX buffer is empty. The UART driver
* might have buffered data received between disabling the
* RX interrupt and entering the critical section. Some
* drivers (looking at you, cdcacm...) will push the buffer
* to the receive queue during uart_enablerxint().
* Just continue processing the RX queue if this happens.
*/
if (rxbuf->head != rxbuf->tail)
{
leave_critical_section(flags);
continue;
}
#endif
#ifdef CONFIG_SERIAL_REMOVABLE
/* Check again if the removable device is still connected
* while we have interrupts off. We do not want the transition
* to occur as a race condition before we begin the wait.
*/
if (dev->disconnected)
{
ret = -ENOTCONN;
}
else
#endif
{
/* Now wait with the Rx interrupt enabled. NuttX will
* automatically re-enable global interrupts when this
* thread goes to sleep.
*/
dev->recvwaiting = true;
ret = uart_takesem(&dev->recvsem, true);
}
leave_critical_section(flags);
/* Was a signal received while waiting for data to be
* received? Was a removable device disconnected while
* we were waiting?
*/
#ifdef CONFIG_SERIAL_REMOVABLE
if (ret < 0 || dev->disconnected)
#else
if (ret < 0)
#endif
{
/* POSIX requires that we return after a signal is received.
* If some bytes were read, we need to return the number of bytes
* read; if no bytes were read, we need to return -1 with the
* errno set correctly.
*/
if (recvd == 0)
{
/* No bytes were read, return -EINTR (the VFS layer will
* set the errno value appropriately.
*/
#ifdef CONFIG_SERIAL_REMOVABLE
recvd = dev->disconnected ? -ENOTCONN : -EINTR;
#else
recvd = -EINTR;
#endif
}
break;
}
}
else
{
/* No... the ring buffer is no longer empty. Just re-enable Rx
* interrupts and accept the new data on the next time through
* the loop.
*/
#ifdef CONFIG_SERIAL_RXDMA
leave_critical_section(flags);
#else
uart_enablerxint(dev);
#endif
}
}
}
#ifdef CONFIG_SERIAL_RXDMA
/* Notify DMA that there is free space in the RX buffer */
flags = enter_critical_section();
uart_dmarxfree(dev);
leave_critical_section(flags);
#endif
#ifndef CONFIG_SERIAL_RXDMA
/* RX interrupt could be disabled by RX buffer overflow. Enable it now. */
uart_enablerxint(dev);
#endif
#ifdef CONFIG_SERIAL_IFLOWCONTROL
#ifdef CONFIG_SERIAL_IFLOWCONTROL_WATERMARKS
/* How many bytes are now buffered */
rxbuf = &dev->recv;
if (rxbuf->head >= rxbuf->tail)
{
nbuffered = rxbuf->head - rxbuf->tail;
}
else
{
nbuffered = rxbuf->size - rxbuf->tail + rxbuf->head;
}
/* Is the level now below the watermark level that we need to report? */
watermark = (CONFIG_SERIAL_IFLOWCONTROL_LOWER_WATERMARK * rxbuf->size) / 100;
if (nbuffered <= watermark)
{
/* Let the lower level driver know that the watermark level has been
* crossed. It will probably deactivate RX flow control.
*/
uart_rxflowcontrol(dev, nbuffered, false);
}
#else
/* Is the RX buffer empty? */
if (rxbuf->head == rxbuf->tail)
{
/* Deactivate RX flow control. */
uart_rxflowcontrol(dev, 0, false);
}
#endif
#endif
uart_givesem(&dev->recv.sem);
return recvd;
}
/************************************************************************************
* Name: uart_write
************************************************************************************/
static ssize_t uart_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen)
{
FAR struct inode *inode = filep->f_inode;
FAR uart_dev_t *dev = inode->i_private;
ssize_t nwritten = buflen;
bool oktoblock;
int ret;
char ch;
/* We may receive serial writes through this path from interrupt handlers and
* from debug output in the IDLE task! In these cases, we will need to do things
* a little differently.
*/
if (up_interrupt_context() || sched_idletask())
{
irqstate_t flags;
#ifdef CONFIG_SERIAL_REMOVABLE
/* If the removable device is no longer connected, refuse to write to
* the device.
*/
if (dev->disconnected)
{
return -ENOTCONN;
}
#endif
flags = enter_critical_section();
ret = uart_irqwrite(dev, buffer, buflen);
leave_critical_section(flags);
return ret;
}
/* Only one user can access dev->xmit.head at a time */
ret = (ssize_t)uart_takesem(&dev->xmit.sem, true);
if (ret < 0)
{
/* A signal received while waiting for access to the xmit.head will
* abort the transfer. After the transfer has started, we are committed
* and signals will be ignored.
*/
return ret;
}
#ifdef CONFIG_SERIAL_REMOVABLE
/* If the removable device is no longer connected, refuse to write to the
* device. This check occurs after taking the xmit.sem because the
* disconnection event might have occurred while we were waiting for
* access to the transmit buffers.
*/
if (dev->disconnected)
{
uart_givesem(&dev->xmit.sem);
return -ENOTCONN;
}
#endif
/* Can the following loop block, waiting for space in the TX
* buffer?
*/
oktoblock = ((filep->f_oflags & O_NONBLOCK) == 0);
/* Loop while we still have data to copy to the transmit buffer.
* we add data to the head of the buffer; uart_xmitchars takes the
* data from the end of the buffer.
*/
uart_disabletxint(dev);
for (; buflen; buflen--)
{
ch = *buffer++;
ret = OK;
#ifdef CONFIG_SERIAL_TERMIOS
/* Do output post-processing */
if ((dev->tc_oflag & OPOST) != 0)
{
/* Mapping CR to NL? */
if ((ch == '\r') && (dev->tc_oflag & OCRNL) != 0)
{
ch = '\n';
}
/* Are we interested in newline processing? */
if ((ch == '\n') && (dev->tc_oflag & (ONLCR | ONLRET)) != 0)
{
ret = uart_putxmitchar(dev, '\r', oktoblock);
}
/* Specifically not handled:
*
* OXTABS - primarily a full-screen terminal optimization
* ONOEOT - Unix interoperability hack
* OLCUC - Not specified by POSIX
* ONOCR - low-speed interactive optimization
*/
}
#else /* !CONFIG_SERIAL_TERMIOS */
/* If this is the console, convert \n -> \r\n */
if (dev->isconsole && ch == '\n')
{
ret = uart_putxmitchar(dev, '\r', oktoblock);
}
#endif
/* Put the character into the transmit buffer */
if (ret >= 0)
{
ret = uart_putxmitchar(dev, ch, oktoblock);
}
/* uart_putxmitchar() might return an error under one of two
* conditions: (1) The wait for buffer space might have been
* interrupted by a signal (ret should be -EINTR), (2) if
* CONFIG_SERIAL_REMOVABLE is defined, then uart_putxmitchar()
* might also return if the serial device was disconnected
* (with -ENOTCONN), or (3) if O_NONBLOCK is specified, then
* then uart_putxmitchar() might return -EAGAIN if the output
* TX buffer is full.
*/
if (ret < 0)
{
/* POSIX requires that we return -1 and errno set if no data was
* transferred. Otherwise, we return the number of bytes in the
* interrupted transfer.
*/
if (buflen < (size_t)nwritten)
{
/* Some data was transferred. Return the number of bytes that
* were successfully transferred.
*/
nwritten -= buflen;
}
else
{
/* No data was transferred. Return the negated errno value.
* The VFS layer will set the errno value appropriately).
*/
nwritten = ret;
}
break;
}
}
if (dev->xmit.head != dev->xmit.tail)
{
#ifdef CONFIG_SERIAL_TXDMA
uart_dmatxavail(dev);
#endif
uart_enabletxint(dev);
}
uart_givesem(&dev->xmit.sem);
return nwritten;
}
/************************************************************************************
* Name: uart_ioctl
************************************************************************************/
static int uart_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
FAR struct inode *inode = filep->f_inode;
FAR uart_dev_t *dev = inode->i_private;
/* Handle TTY-level IOCTLs here */
/* Let low-level driver handle the call first */
int ret = dev->ops->ioctl(filep, cmd, arg);
/* The device ioctl() handler returns -ENOTTY when it doesn't know
* how to handle the command. Check if we can handle it here.
*/
if (ret == -ENOTTY)
{
switch (cmd)
{
/* Get the number of bytes that may be read from the RX buffer
* (without waiting)
*/
case FIONREAD:
{
int count;
irqstate_t flags = enter_critical_section();
/* Determine the number of bytes available in the RX buffer */
if (dev->recv.tail <= dev->recv.head)
{
count = dev->recv.head - dev->recv.tail;
}
else
{
count = dev->recv.size - (dev->recv.tail - dev->recv.head);
}
leave_critical_section(flags);
*(FAR int *)((uintptr_t)arg) = count;
ret = 0;
}
break;
/* Get the number of bytes that have been written to the TX buffer. */
case FIONWRITE:
{
int count;
irqstate_t flags = enter_critical_section();
/* Determine the number of bytes waiting in the TX buffer */
if (dev->xmit.tail <= dev->xmit.head)
{
count = dev->xmit.head - dev->xmit.tail;
}
else
{
count = dev->xmit.size - (dev->xmit.tail - dev->xmit.head);
}
leave_critical_section(flags);
*(FAR int *)((uintptr_t)arg) = count;
ret = 0;
}
break;
/* Get the number of free bytes in the TX buffer */
case FIONSPACE:
{
int count;
irqstate_t flags = enter_critical_section();
/* Determine the number of bytes free in the TX buffer */
if (dev->xmit.head < dev->xmit.tail)
{
count = dev->xmit.tail - dev->xmit.head - 1;
}
else
{
count = dev->xmit.size - (dev->xmit.head - dev->xmit.tail) - 1;
}
leave_critical_section(flags);
*(FAR int *)((uintptr_t)arg) = count;
ret = 0;
}
break;
#ifdef CONFIG_SERIAL_TERMIOS
case TCFLSH:
{
/* Empty the tx/rx buffers */
irqstate_t flags = enter_critical_section();
if (arg == TCIFLUSH || arg == TCIOFLUSH)
{
dev->recv.tail = dev->recv.head;
#ifdef CONFIG_SERIAL_IFLOWCONTROL
/* De-activate RX flow control. */
uart_rxflowcontrol(dev, 0, false);
#endif
}
if (arg == TCOFLUSH || arg == TCIOFLUSH)
{
dev->xmit.tail = dev->xmit.head;
/* Inform any waiters there there is space available. */
uart_datasent(dev);
}
leave_critical_section(flags);
ret = 0;
}
break;
case TCDRN:
{
ret = uart_tcdrain(dev, 10 * TICK_PER_SEC);
}
break;
#endif
#if defined(CONFIG_TTY_SIGINT) || defined(CONFIG_TTY_SIGTSTP)
/* Make the controlling terminal of the calling process */
case TIOCSCTTY:
{
/* Save the PID of the recipient of the SIGINT signal. */
dev->pid = (pid_t)arg;
DEBUGASSERT((unsigned long)(dev->pid) == arg);
}
break;
#endif
}
}
#ifdef CONFIG_SERIAL_TERMIOS
/* Append any higher level TTY flags */
else if (ret == OK)
{
switch (cmd)
{
case TCGETS:
{
FAR struct termios *termiosp = (FAR struct termios *)arg;
if (!termiosp)
{
ret = -EINVAL;
break;
}
/* And update with flags from this layer */
termiosp->c_iflag = dev->tc_iflag;
termiosp->c_oflag = dev->tc_oflag;
termiosp->c_lflag = dev->tc_lflag;
}
break;
case TCSETS:
{
FAR struct termios *termiosp = (FAR struct termios *)arg;
if (!termiosp)
{
ret = -EINVAL;
break;
}
/* Update the flags we keep at this layer */
dev->tc_iflag = termiosp->c_iflag;
dev->tc_oflag = termiosp->c_oflag;
dev->tc_lflag = termiosp->c_lflag;
}
break;
}
}
#endif
return ret;
}
/************************************************************************************
* Name: uart_poll
************************************************************************************/
static int uart_poll(FAR struct file *filep, FAR struct pollfd *fds, bool setup)
{
FAR struct inode *inode = filep->f_inode;
FAR uart_dev_t *dev = inode->i_private;
pollevent_t eventset;
int ndx;
int ret;
int i;
/* Some sanity checking */
#ifdef CONFIG_DEBUG_FEATURES
if (dev == NULL || fds == NULL)
{
return -ENODEV;
}
#endif
/* Are we setting up the poll? Or tearing it down? */
ret = uart_takesem(&dev->pollsem, true);
if (ret < 0)
{
/* A signal received while waiting for access to the poll data
* will abort the operation.
*/
return ret;
}
if (setup)
{
/* This is a request to set up the poll. Find an available
* slot for the poll structure reference
*/
for (i = 0; i < CONFIG_SERIAL_NPOLLWAITERS; i++)
{
/* Find an available slot */
if (!dev->fds[i])
{
/* Bind the poll structure and this slot */
dev->fds[i] = fds;
fds->priv = &dev->fds[i];
break;
}
}
if (i >= CONFIG_SERIAL_NPOLLWAITERS)
{
fds->priv = NULL;
ret = -EBUSY;
goto errout;
}
/* Should we immediately notify on any of the requested events?
* First, check if the xmit buffer is full.
*
* Get exclusive access to the xmit buffer indices. NOTE: that we do not
* let this wait be interrupted by a signal (we probably should, but that
* would be a little awkward).
*/
eventset = 0;
uart_takesem(&dev->xmit.sem, false);
ndx = dev->xmit.head + 1;
if (ndx >= dev->xmit.size)
{
ndx = 0;
}
if (ndx != dev->xmit.tail)
{
eventset |= (fds->events & POLLOUT);
}
uart_givesem(&dev->xmit.sem);
/* Check if the receive buffer is empty.
*
* Get exclusive access to the recv buffer indices. NOTE: that we do not
* let this wait be interrupted by a signal (we probably should, but that
* would be a little awkward).
*/
uart_takesem(&dev->recv.sem, false);
if (dev->recv.head != dev->recv.tail)
{
eventset |= (fds->events & POLLIN);
}
uart_givesem(&dev->recv.sem);
#ifdef CONFIG_SERIAL_REMOVABLE
/* Check if a removable device has been disconnected. */
if (dev->disconnected)
{
eventset |= (POLLERR | POLLHUP);
}
#endif
if (eventset)
{
uart_pollnotify(dev, eventset);
}
}
else if (fds->priv != NULL)
{
/* This is a request to tear down the poll. */
FAR struct pollfd **slot = (FAR struct pollfd **)fds->priv;
#ifdef CONFIG_DEBUG_FEATURES
if (!slot)
{
ret = -EIO;
goto errout;
}
#endif
/* Remove all memory of the poll setup */
*slot = NULL;
fds->priv = NULL;
}
errout:
uart_givesem(&dev->pollsem);
return ret;
}
/************************************************************************************
* Public Functions
************************************************************************************/
/************************************************************************************
* Name: uart_register
*
* Description:
* Register serial console and serial ports.
*
************************************************************************************/
int uart_register(FAR const char *path, FAR uart_dev_t *dev)
{
#ifdef CONFIG_SERIAL_TERMIOS
# if defined(CONFIG_TTY_SIGINT) || defined(CONFIG_TTY_SIGTSTP)
/* Initialize of the task that will receive SIGINT signals. */
dev->pid = (pid_t)-1;
# endif
/* If this UART is a serial console */
if (dev->isconsole)
{
/* Enable signals by default */
dev->tc_lflag |= ISIG;
/* Enable \n -> \r\n translation for the console */
dev->tc_oflag = OPOST | ONLCR;
}
#endif
/* Initialize semaphores */
nxsem_init(&dev->xmit.sem, 0, 1);
nxsem_init(&dev->recv.sem, 0, 1);
nxsem_init(&dev->closesem, 0, 1);
nxsem_init(&dev->xmitsem, 0, 0);
nxsem_init(&dev->recvsem, 0, 0);
nxsem_init(&dev->pollsem, 0, 1);
/* The recvsem and xmitsem are used for signaling and, hence, should not have
* priority inheritance enabled.
*/
nxsem_set_protocol(&dev->xmitsem, SEM_PRIO_NONE);
nxsem_set_protocol(&dev->recvsem, SEM_PRIO_NONE);
/* Register the serial driver */
sinfo("Registering %s\n", path);
return register_driver(path, &g_serialops, 0666, dev);
}
/************************************************************************************
* Name: uart_datareceived
*
* Description:
* This function is called from uart_recvchars when new serial data is place in
* the driver's circular buffer. This function will wake-up any stalled read()
* operations that are waiting for incoming data.
*
************************************************************************************/
void uart_datareceived(FAR uart_dev_t *dev)
{
/* Notify all poll/select waiters that they can read from the recv buffer */
uart_pollnotify(dev, POLLIN);
/* Is there a thread waiting for read data? */
if (dev->recvwaiting)
{
/* Yes... wake it up */
dev->recvwaiting = false;
nxsem_post(&dev->recvsem);
}
#if defined(CONFIG_PM) && defined(CONFIG_SERIAL_CONSOLE)
/* Call pm_activity when characters are received on the console device */
if (dev->isconsole)
{
pm_activity(CONFIG_SERIAL_PM_ACTIVITY_DOMAIN,
CONFIG_SERIAL_PM_ACTIVITY_PRIORITY);
}
#endif
}
/************************************************************************************
* Name: uart_datasent
*
* Description:
* This function is called from uart_xmitchars after serial data has been sent,
* freeing up some space in the driver's circular buffer. This function will
* wake-up any stalled write() operations that was waiting for space to buffer
* outgoing data.
*
************************************************************************************/
void uart_datasent(FAR uart_dev_t *dev)
{
/* Notify all poll/select waiters that they can write to xmit buffer */
uart_pollnotify(dev, POLLOUT);
/* Is there a thread waiting for space in xmit.buffer? */
if (dev->xmitwaiting)
{
/* Yes... wake it up */
dev->xmitwaiting = false;
nxsem_post(&dev->xmitsem);
}
}
/************************************************************************************
* Name: uart_connected
*
* Description:
* Serial devices (like USB serial) can be removed. In that case, the "upper
* half" serial driver must be informed that there is no longer a valid serial
* channel associated with the driver.
*
* In this case, the driver will terminate all pending transfers wint ENOTCONN and
* will refuse all further transactions while the "lower half" is disconnected.
* The driver will continue to be registered, but will be in an unusable state.
*
* Conversely, the "upper half" serial driver needs to know when the serial
* device is reconnected so that it can resume normal operations.
*
* Assumptions/Limitations:
* This function may be called from an interrupt handler.
*
************************************************************************************/
#ifdef CONFIG_SERIAL_REMOVABLE
void uart_connected(FAR uart_dev_t *dev, bool connected)
{
irqstate_t flags;
/* Is the device disconnected? Interrupts are disabled because this
* function may be called from interrupt handling logic.
*/
flags = enter_critical_section();
dev->disconnected = !connected;
if (!connected)
{
/* Notify all poll/select waiters that a hangup occurred */
uart_pollnotify(dev, (POLLERR | POLLHUP));
/* Yes.. wake up all waiting threads. Each thread should detect the
* disconnection and return the ENOTCONN error.
*/
/* Is there a thread waiting for space in xmit.buffer? */
if (dev->xmitwaiting)
{
/* Yes... wake it up */
dev->xmitwaiting = false;
nxsem_post(&dev->xmitsem);
}
/* Is there a thread waiting for read data? */
if (dev->recvwaiting)
{
/* Yes... wake it up */
dev->recvwaiting = false;
nxsem_post(&dev->recvsem);
}
}
leave_critical_section(flags);
}
#endif
/************************************************************************************
* Name: uart_reset_sem
*
* Description:
* This function is called when need reset uart semaphore, this may used in kill
* one process, but this process was reading/writing with the semaphore.
*
************************************************************************************/
void uart_reset_sem(FAR uart_dev_t *dev)
{
nxsem_reset(&dev->xmitsem, 0);
nxsem_reset(&dev->recvsem, 0);
nxsem_reset(&dev->xmit.sem, 1);
nxsem_reset(&dev->recv.sem, 1);
nxsem_reset(&dev->pollsem, 1);
}
Reference in New Issue View Git Blame Copy Permalink