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; uart_takesem(&dev->closesem); 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); /* Now we wait for the transmit buffer to clear */ while (dev->xmit.head != dev->xmit.tail) { #ifndef CONFIG_DISABLE_SIGNALS usleep(HALF_SECOND_USEC); #else up_mdelay(HALF_SECOND_MSEC); #endif } /* And wait for the TX fifo to drain */ while (!uart_txempty(dev)) { #ifndef CONFIG_DISABLE_SIGNALS usleep(HALF_SECOND_USEC); #else up_mdelay(HALF_SECOND_MSEC); #endif } /* Free the IRQ and disable the UART */ flags = irqsave(); /* Disable interrupts */ uart_detach(dev); /* Detach interrupts */ if (!dev->isconsole) /* Check for the serial console UART */ { uart_shutdown(dev); /* Disable the UART */ } irqrestore(flags); uart_givesem(&dev->closesem); return OK; }
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; irqstate_t flags; ssize_t recvd = 0; int16_t tail; /* Only one user can be accessing dev->recv.tail at once */ uart_takesem(&dev->recv.sem); /* 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 (recvd < buflen) { /* Check if there is more data to return in the circular buffer. * NOTE: Rx interrupt handling logic may aynchronously 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 = dev->recv.tail; if (dev->recv.head != tail) { /* Take the next character from the tail of the buffer */ *buffer++ = dev->recv.buffer[tail]; recvd++; /* Increment the tail index. Most operations are done using the * local variable 'tail' so that the final dev->recv.tail update * is atomic. */ if (++tail >= dev->recv.size) { tail = 0; } dev->recv.tail = tail; } #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) { /* 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; } /* 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) { /* Break out of the loop returning -EAGAIN */ recvd = -EAGAIN; break; } #endif /* Otherwise we are going to have to wait for data to arrive */ else { /* Disable Rx interrupts and test again... */ uart_disablerxint(dev); /* If the Rx ring buffer still empty? Bytes may have been addded * between the last time that we checked and when we disabled Rx * interrupts. */ if (dev->recv.head == dev->recv.tail) { /* Yes.. the buffer is still empty. Wait for some characters * to be received into the buffer with the RX interrupt re- * enabled. All interrupts are disabled briefly to assure * that the following operations are atomic. */ flags = irqsave(); dev->recvwaiting = true; uart_enablerxint(dev); /* Now wait with the Rx interrupt re-enabled. NuttX will * automatically re-enable global interrupts when this * thread goes to sleep. */ uart_takesem(&dev->recvsem); irqrestore(flags); } 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. */ uart_enablerxint(dev); } } } uart_givesem(&dev->recv.sem); return recvd; }
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; irqstate_t flags; ssize_t recvd = 0; int16_t tail; int ret; char ch; /* Only one user can access dev->recv.tail at a time */ ret = uart_takesem(&dev->recv.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 (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 aynchronously 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 = dev->recv.tail; if (dev->recv.head != tail) { /* Take the next character from the tail of the buffer */ ch = dev->recv.buffer[tail]; /* Increment the tail index. Most operations are done using the * local variable 'tail' so that the final dev->recv.tail update * is atomic. */ if (++tail >= dev->recv.size) { tail = 0; } dev->recv.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; } /* 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 { /* Disable Rx interrupts and test again... */ uart_disablerxint(dev); /* If the Rx ring buffer still empty? Bytes may have been addded * between the last time that we checked and when we disabled Rx * interrupts. */ if (dev->recv.head == dev->recv.tail) { /* Yes.. the buffer is still empty. Wait for some characters * to be received into the buffer with the RX interrupt re- * enabled. All interrupts are disabled briefly to assure * that the following operations are atomic. */ flags = irqsave(); uart_enablerxint(dev); #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 re-enabled. NuttX will * automatically re-enable global interrupts when this * thread goes to sleep. */ dev->recvwaiting = true; ret = uart_takesem(&dev->recvsem, true); } irqrestore(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. */ uart_enablerxint(dev); } } } #ifdef CONFIG_SERIAL_IFLOWCONTROL if (dev->recv.head == dev->recv.tail) { /* We might leave Rx interrupt disabled if full recv buffer was read * empty. Enable Rx interrupt to make sure that more input is received. */ uart_enablerxint(dev); } #endif uart_givesem(&dev->recv.sem); return recvd; }
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. */ (void)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); /* Now we wait for the transmit buffer to clear */ while (dev->xmit.head != dev->xmit.tail) { #ifndef CONFIG_DISABLE_SIGNALS usleep(HALF_SECOND_USEC); #else up_mdelay(HALF_SECOND_MSEC); #endif } /* And wait for the TX fifo to drain */ while (!uart_txempty(dev)) { #ifndef CONFIG_DISABLE_SIGNALS usleep(HALF_SECOND_USEC); #else up_mdelay(HALF_SECOND_MSEC); #endif } /* Free the IRQ and disable the UART */ flags = irqsave(); /* Disable interrupts */ uart_detach(dev); /* Detach interrupts */ if (!dev->isconsole) /* Check for the serial console UART */ { uart_shutdown(dev); /* Disable the UART */ } irqrestore(flags); uart_givesem(&dev->closesem); return OK; }
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. */ (void)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); /* Now we wait for the transmit buffer to clear */ while (dev->xmit.head != dev->xmit.tail) { #ifndef CONFIG_DISABLE_SIGNALS usleep(HALF_SECOND_USEC); #else up_mdelay(HALF_SECOND_MSEC); #endif } /* And wait for the TX fifo to drain */ while (!uart_txempty(dev)) { #ifndef CONFIG_DISABLE_SIGNALS usleep(HALF_SECOND_USEC); #else up_mdelay(HALF_SECOND_MSEC); #endif } /* Free the IRQ and disable the UART */ flags = irqsave(); /* Disable interrupts */ uart_detach(dev); /* Detach interrupts */ if (!dev->isconsole) /* Check for the serial console UART */ { uart_shutdown(dev); /* Disable the UART */ } irqrestore(flags); /* 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. * * REVISIT: This logic *only* works in the case where the cancelled * thread had the only reference to the serial driver. If there other * references, then the this logic will not be executed and the * semaphore count will still be incorrect. */ sem_reinit(&dev->xmitsem, 0, 0); sem_reinit(&dev->recvsem, 0, 0); sem_reinit(&dev->xmit.sem, 0, 1); sem_reinit(&dev->recv.sem, 0, 1); #ifndef CONFIG_DISABLE_POLL sem_reinit(&dev->pollsem, 0, 1); #endif uart_givesem(&dev->closesem); return OK; }