| /**************************************************************************** |
| * drivers/serial/pty.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 <ctype.h> |
| #include <sys/types.h> |
| #include <sys/ioctl.h> |
| #include <stdbool.h> |
| #include <unistd.h> |
| #include <sched.h> |
| #include <termios.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <poll.h> |
| #include <fcntl.h> |
| #include <assert.h> |
| #include <errno.h> |
| |
| #include <nuttx/ascii.h> |
| #include <nuttx/kmalloc.h> |
| #include <nuttx/mutex.h> |
| #include <nuttx/semaphore.h> |
| #include <nuttx/fs/fs.h> |
| #include <nuttx/serial/pty.h> |
| |
| #include "pty.h" |
| |
| /**************************************************************************** |
| * Pre-processor Definitions |
| ****************************************************************************/ |
| |
| /* Maximum number of threads than can be waiting for POLL events */ |
| |
| #ifndef CONFIG_DEV_PTY_NPOLLWAITERS |
| # define CONFIG_DEV_PTY_NPOLLWAITERS 2 |
| #endif |
| |
| /**************************************************************************** |
| * Private Types |
| ****************************************************************************/ |
| |
| struct pty_poll_s |
| { |
| FAR void *src; |
| FAR void *sink; |
| }; |
| |
| /* This device structure describes on memory of the PTY device pair */ |
| |
| struct pty_devpair_s; |
| struct pty_dev_s |
| { |
| FAR struct pty_devpair_s *pd_devpair; |
| struct file pd_src; /* Provides data to read() method (pipe output) */ |
| struct file pd_sink; /* Accepts data from write() method (pipe input) */ |
| bool pd_master; /* True: this is the master */ |
| uint8_t pd_escape; /* Number of the character to be escaped */ |
| tcflag_t pd_iflag; /* Terminal input modes */ |
| tcflag_t pd_lflag; /* Terminal local modes */ |
| tcflag_t pd_oflag; /* Terminal output modes */ |
| struct pty_poll_s pd_poll[CONFIG_DEV_PTY_NPOLLWAITERS]; |
| }; |
| |
| /* This structure describes the pipe pair */ |
| |
| struct pty_devpair_s |
| { |
| struct pty_dev_s pp_master; /* Maseter device */ |
| struct pty_dev_s pp_slave; /* Slave device */ |
| |
| bool pp_susv1; /* SUSv1 or BSD style */ |
| bool pp_locked; /* Slave is locked */ |
| bool pp_unlinked; /* File has been unlinked */ |
| uint8_t pp_minor; /* Minor device number */ |
| uint16_t pp_nopen; /* Open file count */ |
| sem_t pp_slavesem; /* Slave lock semaphore */ |
| mutex_t pp_lock; /* Mutual exclusion */ |
| }; |
| |
| /**************************************************************************** |
| * Private Function Prototypes |
| ****************************************************************************/ |
| |
| static void pty_destroy(FAR struct pty_devpair_s *devpair); |
| static int pty_pipe(FAR struct pty_devpair_s *devpair); |
| static int pty_open(FAR struct file *filep); |
| static int pty_close(FAR struct file *filep); |
| static ssize_t pty_read(FAR struct file *filep, FAR char *buffer, |
| size_t buflen); |
| static ssize_t pty_write(FAR struct file *filep, FAR const char *buffer, |
| size_t buflen); |
| static int pty_ioctl(FAR struct file *filep, int cmd, unsigned long arg); |
| static int pty_poll(FAR struct file *filep, FAR struct pollfd *fds, |
| bool setup); |
| #ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS |
| static int pty_unlink(FAR struct inode *inode); |
| #endif |
| |
| /**************************************************************************** |
| * Private Data |
| ****************************************************************************/ |
| |
| static const struct file_operations g_pty_fops = |
| { |
| pty_open, /* open */ |
| pty_close, /* close */ |
| pty_read, /* read */ |
| pty_write, /* write */ |
| NULL, /* seek */ |
| pty_ioctl, /* ioctl */ |
| NULL, /* mmap */ |
| NULL, /* truncate */ |
| pty_poll /* poll */ |
| #ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS |
| , pty_unlink /* unlink */ |
| #endif |
| }; |
| |
| /**************************************************************************** |
| * Private Functions |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Name: pty_destroy |
| ****************************************************************************/ |
| |
| static void pty_destroy(FAR struct pty_devpair_s *devpair) |
| { |
| char devname[16]; |
| |
| if (devpair->pp_susv1) |
| { |
| /* Free this minor number so that it can be reused */ |
| |
| ptmx_minor_free(devpair->pp_minor); |
| |
| /* Un-register the slave device */ |
| |
| snprintf(devname, 16, "/dev/pts/%d", devpair->pp_minor); |
| } |
| else |
| { |
| /* Un-register the master device (/dev/ptyN may have already been |
| * unlinked). |
| */ |
| |
| snprintf(devname, 16, "/dev/pty%d", (int)devpair->pp_minor); |
| unregister_driver(devname); |
| |
| /* Un-register the slave device */ |
| |
| snprintf(devname, 16, "/dev/ttyp%d", devpair->pp_minor); |
| } |
| |
| unregister_driver(devname); |
| |
| /* And free the device structure */ |
| |
| nxmutex_destroy(&devpair->pp_lock); |
| nxsem_destroy(&devpair->pp_slavesem); |
| kmm_free(devpair); |
| } |
| |
| /**************************************************************************** |
| * Name: pty_pipe |
| ****************************************************************************/ |
| |
| static int pty_pipe(FAR struct pty_devpair_s *devpair) |
| { |
| FAR struct file *pipe_a[2]; |
| FAR struct file *pipe_b[2]; |
| int ret; |
| |
| /* Create two pipes: |
| * |
| * pipe_a: Master source, slave sink (TX, slave-to-master) |
| * pipe_b: Master sink, slave source (RX, master-to-slave) |
| */ |
| |
| pipe_a[0] = &devpair->pp_master.pd_src; |
| pipe_a[1] = &devpair->pp_slave.pd_sink; |
| |
| ret = file_pipe(pipe_a, CONFIG_PSEUDOTERM_TXBUFSIZE, O_CLOEXEC); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| pipe_b[0] = &devpair->pp_slave.pd_src; |
| pipe_b[1] = &devpair->pp_master.pd_sink; |
| |
| ret = file_pipe(pipe_b, CONFIG_PSEUDOTERM_RXBUFSIZE, O_CLOEXEC); |
| if (ret < 0) |
| { |
| file_close(pipe_a[0]); |
| file_close(pipe_a[1]); |
| } |
| |
| return ret; |
| } |
| |
| /**************************************************************************** |
| * Name: pty_open |
| ****************************************************************************/ |
| |
| static int pty_open(FAR struct file *filep) |
| { |
| FAR struct inode *inode; |
| FAR struct pty_dev_s *dev; |
| FAR struct pty_devpair_s *devpair; |
| int ret = OK; |
| |
| inode = filep->f_inode; |
| dev = inode->i_private; |
| DEBUGASSERT(dev != NULL && dev->pd_devpair != NULL); |
| devpair = dev->pd_devpair; |
| |
| /* Get exclusive access to the device structure */ |
| |
| ret = nxmutex_lock(&devpair->pp_lock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| /* Wait if this is an attempt to open the slave device and the slave |
| * device is locked. |
| */ |
| |
| if (!dev->pd_master) |
| { |
| /* Slave... Check if the slave driver is locked. */ |
| |
| while (devpair->pp_locked) |
| { |
| /* Release the exclusive access before wait */ |
| |
| nxmutex_unlock(&devpair->pp_lock); |
| |
| /* Wait until unlocked. |
| * We will also most certainly suspend here. |
| */ |
| |
| ret = nxsem_wait(&devpair->pp_slavesem); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| /* Restore the semaphore count */ |
| |
| DEBUGVERIFY(nxsem_post(&devpair->pp_slavesem)); |
| |
| /* Get exclusive access to the device structure. This might also |
| * cause suspension. |
| */ |
| |
| ret = nxmutex_lock(&devpair->pp_lock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| } |
| } |
| |
| /* First open? */ |
| |
| if (devpair->pp_nopen == 0) |
| { |
| /* Yes, create the internal pipe */ |
| |
| ret = pty_pipe(devpair); |
| } |
| |
| /* Increment the count of open references on the driver */ |
| |
| if (ret >= 0) |
| { |
| devpair->pp_nopen++; |
| DEBUGASSERT(devpair->pp_nopen > 0); |
| } |
| |
| nxmutex_unlock(&devpair->pp_lock); |
| return ret; |
| } |
| |
| /**************************************************************************** |
| * Name: pty_close |
| ****************************************************************************/ |
| |
| static int pty_close(FAR struct file *filep) |
| { |
| FAR struct inode *inode; |
| FAR struct pty_dev_s *dev; |
| FAR struct pty_devpair_s *devpair; |
| int ret; |
| |
| inode = filep->f_inode; |
| dev = inode->i_private; |
| DEBUGASSERT(dev != NULL && dev->pd_devpair != NULL); |
| devpair = dev->pd_devpair; |
| |
| /* Get exclusive access */ |
| |
| ret = nxmutex_lock(&devpair->pp_lock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| /* Check if the decremented inode reference count would go to zero */ |
| |
| if (inode->i_crefs == 1) |
| { |
| /* Did the (single) master just close its reference? */ |
| |
| if (dev->pd_master && devpair->pp_susv1) |
| { |
| /* Yes, then we are essentially unlinked and when all of the |
| * slaves close there references, then the PTY should be |
| * destroyed. |
| */ |
| |
| devpair->pp_unlinked = true; |
| } |
| |
| /* Close the contained file structures */ |
| |
| file_close(&dev->pd_src); |
| file_close(&dev->pd_sink); |
| } |
| |
| /* Is this the last open reference? If so, was the driver previously |
| * unlinked? |
| */ |
| |
| DEBUGASSERT(devpair->pp_nopen > 0); |
| if (devpair->pp_nopen <= 1 && devpair->pp_unlinked) |
| { |
| /* Yes.. Free the device pair now (without freeing the semaphore) */ |
| |
| nxmutex_unlock(&devpair->pp_lock); |
| pty_destroy(devpair); |
| return OK; |
| } |
| else |
| { |
| /* Otherwise just decrement the open count */ |
| |
| devpair->pp_nopen--; |
| } |
| |
| nxmutex_unlock(&devpair->pp_lock); |
| return OK; |
| } |
| |
| /**************************************************************************** |
| * Name: pty_read |
| ****************************************************************************/ |
| |
| static ssize_t pty_read(FAR struct file *filep, FAR char *buffer, size_t len) |
| { |
| FAR struct inode *inode; |
| FAR struct pty_dev_s *dev; |
| ssize_t ntotal; |
| ssize_t i; |
| ssize_t j; |
| char ch; |
| |
| inode = filep->f_inode; |
| dev = inode->i_private; |
| DEBUGASSERT(dev != NULL); |
| |
| /* Do input processing if any is enabled |
| * |
| * 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. |
| */ |
| |
| if (dev->pd_iflag & (INLCR | IGNCR | ICRNL)) |
| { |
| while ((ntotal = file_read(&dev->pd_src, buffer, len)) > 0) |
| { |
| for (i = j = 0; i < ntotal; i++) |
| { |
| /* Perform input processing */ |
| |
| ch = buffer[i]; |
| |
| /* \n -> \r or \r -> \n translation? */ |
| |
| if (ch == '\n' && (dev->pd_iflag & INLCR) != 0) |
| { |
| ch = '\r'; |
| } |
| else if (ch == '\r' && (dev->pd_iflag & ICRNL) != 0) |
| { |
| ch = '\n'; |
| } |
| |
| /* Discarding \r ? Print character if (1) character is not \r |
| * or if (2) we were not asked to ignore \r. |
| */ |
| |
| if (ch != '\r' || (dev->pd_iflag & IGNCR) == 0) |
| { |
| buffer[j++] = ch; |
| } |
| } |
| |
| /* Is the buffer not empty after process? */ |
| |
| if (j != 0) |
| { |
| /* Yes, we are done. */ |
| |
| ntotal = j; |
| break; |
| } |
| } |
| } |
| else |
| { |
| /* NOTE: the source pipe will block if no data is available in |
| * the pipe. Otherwise, it will return data from the pipe. If |
| * there are fewer than 'len' bytes in the, it will return with |
| * ntotal < len. |
| * |
| * REVISIT: Should not block if the oflags include O_NONBLOCK. |
| * How would we ripple the O_NONBLOCK characteristic to the |
| * contained source pipe? file_fcntl()? Or FIONREAD? See the |
| * TODO comment at the top of this file. |
| */ |
| |
| ntotal = file_read(&dev->pd_src, buffer, len); |
| } |
| |
| if ((dev->pd_lflag & ECHO) && (ntotal > 0)) |
| { |
| size_t n = 0; |
| |
| for (i = j = 0; i < ntotal; i++) |
| { |
| ch = buffer[i]; |
| |
| /* Check for the beginning of a VT100 escape sequence, 3 byte */ |
| |
| if (ch == ASCII_ESC) |
| { |
| /* Mark that we should skip 2 more bytes */ |
| |
| dev->pd_escape = 2; |
| continue; |
| } |
| else if (dev->pd_escape == 2 && ch != ASCII_LBRACKET) |
| { |
| /* It's not an <esc>[x 3 byte sequence, show it */ |
| |
| dev->pd_escape = 0; |
| } |
| else if (dev->pd_escape > 0) |
| { |
| /* Skipping character count down */ |
| |
| if (--dev->pd_escape > 0) |
| { |
| continue; |
| } |
| } |
| |
| /* Echo if the character in batch */ |
| |
| if (ch == '\n' || (n != 0 && j + n != i)) |
| { |
| if (n != 0) |
| { |
| pty_write(filep, buffer + j, n); |
| n = 0; |
| } |
| |
| if (ch == '\n') |
| { |
| pty_write(filep, "\r\n", 2); |
| continue; |
| } |
| } |
| |
| /* Record the character can be echo */ |
| |
| if (!iscntrl(ch & 0xff) && n++ == 0) |
| { |
| j = i; |
| } |
| } |
| |
| if (n != 0) |
| { |
| pty_write(filep, buffer + j, n); |
| } |
| } |
| |
| return ntotal; |
| } |
| |
| /**************************************************************************** |
| * Name: pty_write |
| ****************************************************************************/ |
| |
| static ssize_t pty_write(FAR struct file *filep, |
| FAR const char *buffer, size_t len) |
| { |
| FAR struct inode *inode; |
| FAR struct pty_dev_s *dev; |
| ssize_t ntotal; |
| ssize_t nwritten; |
| size_t i; |
| char ch; |
| |
| inode = filep->f_inode; |
| dev = inode->i_private; |
| DEBUGASSERT(dev != NULL); |
| |
| /* Do output post-processing */ |
| |
| if ((dev->pd_oflag & OPOST) != 0) |
| { |
| /* We will transfer one byte at a time, making the appropriae |
| * translations. Specifically not handled: |
| * |
| * OXTABS - primarily a full-screen terminal optimisation |
| * ONOEOT - Unix interoperability hack |
| * OLCUC - Not specified by POSIX |
| * ONOCR - low-speed interactive optimisation |
| */ |
| |
| ntotal = 0; |
| for (i = 0; i < len; i++) |
| { |
| ch = *buffer++; |
| |
| /* Mapping CR to NL? */ |
| |
| if (ch == '\r' && (dev->pd_oflag & OCRNL) != 0) |
| { |
| ch = '\n'; |
| } |
| |
| /* Are we interested in newline processing? */ |
| |
| if ((ch == '\n') && (dev->pd_oflag & (ONLCR | ONLRET)) != 0) |
| { |
| char cr = '\r'; |
| |
| /* Transfer the carriage return. This will block if the |
| * sink pipe is full. |
| * |
| * REVISIT: Should not block if the oflags include O_NONBLOCK. |
| * How would we ripple the O_NONBLOCK characteristic to the |
| * contained sink pipe? file_fcntl()? Or FIONSPACE? See the |
| * TODO comment at the top of this file. |
| * |
| * NOTE: The newline is not included in total number of bytes |
| * written. Otherwise, we would return more than the |
| * requested number of bytes. |
| */ |
| |
| nwritten = file_write(&dev->pd_sink, &cr, 1); |
| if (nwritten < 0) |
| { |
| ntotal = nwritten; |
| break; |
| } |
| } |
| |
| /* Transfer the (possibly translated) character.. This will block |
| * if the sink pipe is full |
| * |
| * REVISIT: Should not block if the oflags include O_NONBLOCK. |
| * How would we ripple the O_NONBLOCK characteristic to the |
| * contained sink pipe? file_fcntl()? Or FIONSPACe? See the |
| * TODO comment at the top of this file. |
| */ |
| |
| nwritten = file_write(&dev->pd_sink, &ch, 1); |
| if (nwritten < 0) |
| { |
| ntotal = nwritten; |
| break; |
| } |
| |
| /* Update the count of bytes transferred */ |
| |
| ntotal++; |
| } |
| } |
| else |
| { |
| /* Write the 'len' bytes to the sink pipe. This will block until all |
| * 'len' bytes have been written to the pipe. |
| * |
| * REVISIT: Should not block if the oflags include O_NONBLOCK. |
| * How would we ripple the O_NONBLOCK characteristic to the |
| * contained sink pipe? file_fcntl()? Or FIONSPACE? See the |
| * TODO comment at the top of this file. |
| */ |
| |
| ntotal = file_write(&dev->pd_sink, buffer, len); |
| } |
| |
| return ntotal; |
| } |
| |
| /**************************************************************************** |
| * Name: pty_ioctl |
| * |
| * Description: |
| * The standard ioctl method. This is where ALL of the PWM work is done. |
| * |
| ****************************************************************************/ |
| |
| static int pty_ioctl(FAR struct file *filep, int cmd, unsigned long arg) |
| { |
| FAR struct inode *inode; |
| FAR struct pty_dev_s *dev; |
| FAR struct pty_devpair_s *devpair; |
| int ret; |
| |
| inode = filep->f_inode; |
| dev = inode->i_private; |
| DEBUGASSERT(dev != NULL && dev->pd_devpair != NULL); |
| devpair = dev->pd_devpair; |
| |
| /* Get exclusive access */ |
| |
| ret = nxmutex_lock(&devpair->pp_lock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| /* Handle IOCTL commands */ |
| |
| switch (cmd) |
| { |
| /* PTY IOCTL commands would be handled here */ |
| |
| case TIOCGPTN: /* Get Pty Number (of pty-mux device): FAR int* */ |
| { |
| FAR int *ptyno = (FAR int *)((uintptr_t)arg); |
| if (ptyno == NULL) |
| { |
| ret = -EINVAL; |
| } |
| else |
| { |
| *ptyno = devpair->pp_minor; |
| ret = OK; |
| } |
| } |
| break; |
| |
| case TIOCSPTLCK: /* Lock/unlock Pty: int */ |
| { |
| if (arg == 0) |
| { |
| if (devpair->pp_locked) |
| { |
| /* Release any waiting threads */ |
| |
| ret = nxsem_post(&devpair->pp_slavesem); |
| if (ret >= 0) |
| { |
| devpair->pp_locked = false; |
| } |
| } |
| } |
| else if (!devpair->pp_locked) |
| { |
| /* Locking */ |
| |
| ret = nxsem_wait(&devpair->pp_slavesem); |
| if (ret >= 0) |
| { |
| devpair->pp_locked = true; |
| } |
| } |
| } |
| break; |
| |
| case TIOCGPTLCK: /* Get Pty lock state: FAR int* */ |
| { |
| FAR int *ptr = (FAR int *)((uintptr_t)arg); |
| if (ptr == NULL) |
| { |
| ret = -EINVAL; |
| } |
| else |
| { |
| *ptr = devpair->pp_locked; |
| ret = OK; |
| } |
| } |
| break; |
| |
| 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->pd_iflag; |
| termiosp->c_oflag = dev->pd_oflag; |
| termiosp->c_lflag = dev->pd_lflag; |
| ret = OK; |
| } |
| 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->pd_iflag = termiosp->c_iflag; |
| dev->pd_oflag = termiosp->c_oflag; |
| dev->pd_lflag = termiosp->c_lflag; |
| ret = OK; |
| } |
| break; |
| |
| /* Get the number of bytes that are immediately available for reading |
| * from the source pipe. |
| */ |
| |
| case FIONREAD: |
| { |
| ret = file_ioctl(&dev->pd_src, cmd, arg); |
| } |
| break; |
| |
| /* Get the number of bytes waiting in the sink pipe (FIONWRITE) or the |
| * number of unused bytes in the sink pipe (FIONSPACE). |
| */ |
| |
| case FIONWRITE: |
| case FIONSPACE: |
| { |
| ret = file_ioctl(&dev->pd_sink, cmd, arg); |
| } |
| break; |
| |
| case FIONBIO: |
| { |
| ret = file_ioctl(&dev->pd_src, cmd, arg); |
| if (ret >= 0) |
| { |
| ret = file_ioctl(&dev->pd_sink, cmd, arg); |
| } |
| } |
| break; |
| |
| /* Any unrecognized IOCTL commands will be passed to the contained |
| * pipe driver. |
| * |
| * REVISIT: We know for a fact that the pipe driver only supports |
| * FIONREAD, FIONWRITE, FIONSPACE and PIPEIOC_POLICY. The first two |
| * are handled above and PIPEIOC_POLICY should not be managed by |
| * applications -- it can break the PTY! |
| */ |
| |
| default: |
| { |
| #if 0 |
| ret = file_ioctl(&dev->pd_src, cmd, arg); |
| if (ret >= 0 || ret == -ENOTTY) |
| { |
| ret = file_ioctl(&dev->pd_sink, cmd, arg); |
| } |
| #else |
| ret = -ENOTTY; |
| #endif |
| } |
| break; |
| } |
| |
| nxmutex_unlock(&devpair->pp_lock); |
| return ret; |
| } |
| |
| /**************************************************************************** |
| * Name: pty_poll |
| ****************************************************************************/ |
| |
| static int pty_poll(FAR struct file *filep, FAR struct pollfd *fds, |
| bool setup) |
| { |
| FAR struct inode *inode; |
| FAR struct pty_dev_s *dev; |
| FAR struct pty_devpair_s *devpair; |
| FAR struct pty_poll_s *pollp = NULL; |
| int ret; |
| int i; |
| |
| inode = filep->f_inode; |
| dev = inode->i_private; |
| devpair = dev->pd_devpair; |
| |
| ret = nxmutex_lock(&devpair->pp_lock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| if (setup) |
| { |
| for (i = 0; i < CONFIG_DEV_PTY_NPOLLWAITERS; i++) |
| { |
| if (dev->pd_poll[i].src == NULL && dev->pd_poll[i].sink == NULL) |
| { |
| pollp = &dev->pd_poll[i]; |
| break; |
| } |
| } |
| |
| if (i >= CONFIG_DEV_PTY_NPOLLWAITERS) |
| { |
| ret = -EBUSY; |
| goto errout; |
| } |
| } |
| else |
| { |
| pollp = (FAR struct pty_poll_s *)fds->priv; |
| } |
| |
| /* POLLIN: Data may be read without blocking. */ |
| |
| if ((fds->events & POLLIN) != 0) |
| { |
| fds->priv = pollp->src; |
| ret = file_poll(&dev->pd_src, fds, setup); |
| if (ret < 0) |
| { |
| goto errout; |
| } |
| |
| pollp->src = fds->priv; |
| } |
| |
| /* POLLOUT: Normal data may be written without blocking. */ |
| |
| if ((fds->events & POLLOUT) != 0) |
| { |
| fds->priv = pollp->sink; |
| ret = file_poll(&dev->pd_sink, fds, setup); |
| if (ret < 0) |
| { |
| if (pollp->src) |
| { |
| fds->priv = pollp->src; |
| file_poll(&dev->pd_src, fds, false); |
| pollp->src = NULL; |
| } |
| |
| goto errout; |
| } |
| |
| pollp->sink = fds->priv; |
| } |
| |
| if (setup) |
| { |
| fds->priv = pollp; |
| } |
| |
| errout: |
| nxmutex_unlock(&devpair->pp_lock); |
| return ret; |
| } |
| |
| /**************************************************************************** |
| * Name: pty_unlink |
| ****************************************************************************/ |
| |
| #ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS |
| static int pty_unlink(FAR struct inode *inode) |
| { |
| FAR struct pty_dev_s *dev; |
| FAR struct pty_devpair_s *devpair; |
| int ret; |
| |
| DEBUGASSERT(inode->i_private != NULL); |
| dev = inode->i_private; |
| devpair = dev->pd_devpair; |
| DEBUGASSERT(dev->pd_devpair != NULL); |
| |
| /* Get exclusive access */ |
| |
| ret = nxmutex_lock(&devpair->pp_lock); |
| if (ret < 0) |
| { |
| return ret; |
| } |
| |
| /* Indicate that the driver has been unlinked */ |
| |
| devpair->pp_unlinked = true; |
| |
| /* If there are no further open references to the driver, then commit |
| * Hara-Kiri now. |
| */ |
| |
| if (devpair->pp_nopen == 0) |
| { |
| nxmutex_unlock(&devpair->pp_lock); |
| pty_destroy(devpair); |
| return OK; |
| } |
| |
| nxmutex_unlock(&devpair->pp_lock); |
| return OK; |
| } |
| #endif |
| |
| /**************************************************************************** |
| * Public Functions |
| ****************************************************************************/ |
| |
| /**************************************************************************** |
| * Name: pty_register2 |
| * |
| * Description: |
| * Create and register PTY master and slave devices. The slave side of |
| * the interface is always locked initially. The master must call |
| * unlockpt() before the slave device can be opened. |
| * |
| * Input Parameters: |
| * minor - The number that qualifies the naming of the created devices. |
| * susv1 - select SUSv1 or BSD behaviour |
| * |
| * Returned Value: |
| * 0 is returned on success; otherwise, the negative error code return |
| * appropriately. |
| * |
| ****************************************************************************/ |
| |
| int pty_register2(int minor, bool susv1) |
| { |
| FAR struct pty_devpair_s *devpair; |
| char devname[16]; |
| int ret; |
| |
| /* Allocate a device instance */ |
| |
| devpair = kmm_zalloc(sizeof(struct pty_devpair_s)); |
| if (devpair == NULL) |
| { |
| return -ENOMEM; |
| } |
| |
| /* Initialize semaphores & mutex */ |
| |
| nxsem_init(&devpair->pp_slavesem, 0, 0); |
| nxmutex_init(&devpair->pp_lock); |
| |
| /* Map CR -> NL from terminal input (master) |
| * For some usage like adb shell: |
| * adb shell write \r -> nsh read \n and echo input |
| * nsh write \n -> adb shell read \r\n |
| */ |
| |
| devpair->pp_susv1 = susv1; |
| devpair->pp_minor = minor; |
| devpair->pp_locked = true; |
| devpair->pp_master.pd_devpair = devpair; |
| devpair->pp_master.pd_master = true; |
| devpair->pp_master.pd_oflag = OPOST | OCRNL; |
| devpair->pp_slave.pd_devpair = devpair; |
| devpair->pp_slave.pd_oflag = OPOST | ONLCR; |
| devpair->pp_slave.pd_lflag = ECHO; |
| |
| /* Register the master device |
| * |
| * BSD style (deprecated): /dev/ptyN |
| * SUSv1 style: Master: /dev/ptmx (multiplexor, see ptmx.c) |
| * |
| * Where N is the minor number |
| */ |
| |
| snprintf(devname, 16, "/dev/pty%d", minor); |
| |
| ret = register_driver(devname, &g_pty_fops, 0666, &devpair->pp_master); |
| if (ret < 0) |
| { |
| goto errout_with_devpair; |
| } |
| |
| /* Register the slave device |
| * |
| * BSD style (deprecated): /dev/ttypN |
| * SUSv1 style: /dev/pts/N |
| * |
| * Where N is the minor number |
| */ |
| |
| if (susv1) |
| { |
| snprintf(devname, 16, "/dev/pts/%d", minor); |
| } |
| else |
| { |
| snprintf(devname, 16, "/dev/ttyp%d", minor); |
| } |
| |
| ret = register_driver(devname, &g_pty_fops, 0666, &devpair->pp_slave); |
| if (ret < 0) |
| { |
| goto errout_with_master; |
| } |
| |
| return OK; |
| |
| errout_with_master: |
| snprintf(devname, 16, "/dev/pty%d", minor); |
| unregister_driver(devname); |
| |
| errout_with_devpair: |
| nxmutex_destroy(&devpair->pp_lock); |
| nxsem_destroy(&devpair->pp_slavesem); |
| kmm_free(devpair); |
| return ret; |
| } |
| |
| /**************************************************************************** |
| * Name: pty_register |
| * |
| * Description: |
| * Create and register PTY master and slave devices. The master device |
| * will be registered at /dev/ptyN and slave at /dev/ttypN where N is |
| * the provided minor number. |
| * |
| * The slave side of the interface is always locked initially. The |
| * master must call unlockpt() before the slave device can be opened. |
| * |
| * Input Parameters: |
| * minor - The number that qualifies the naming of the created devices. |
| * |
| * Returned Value: |
| * Zero (OK) is returned on success; a negated errno value is returned on |
| * any failure. |
| * |
| ****************************************************************************/ |
| |
| int pty_register(int minor) |
| { |
| return pty_register2(minor, false); |
| } |
