/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-11-13     Shell        init ver.
 */
#include "../bsd_porting.h"
#include "../tty_config.h"
#include "../terminal.h"
#include "../tty_internal.h"

#include <rtdef.h>
#include <sys/ioctl.h>

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2008 Ed Schouten <ed@FreeBSD.org>
 * All rights reserved.
 *
 * Portions of this software were developed under sponsorship from Snow
 * B.V., the Netherlands.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

static void tty_rel_free(struct lwp_tty *tp);

/* Character device of /dev/console. */
static struct rt_device *dev_console;
#ifdef USING_BSD_CONSOLE_NAME
static const char *dev_console_filename;
#endif

/*
 * Flags that are supported and stored by this implementation.
 */
#ifndef ALTWERASE
#define ALTWERASE 0
#endif
#ifndef NOKERNINFO
#define NOKERNINFO 0
#endif
#define TTYSUP_IFLAG                                                      \
    (IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP | INLCR | IGNCR | \
     ICRNL | IXON | IXOFF | IXANY | IMAXBEL | IUTF8)
#define TTYSUP_OFLAG (OPOST | ONLCR | TAB3 | ONOEOT | OCRNL | ONOCR | ONLRET)
#define TTYSUP_LFLAG                                                     \
    (ECHOKE | ECHOE | ECHOK | ECHO | ECHONL | ECHOPRT | ECHOCTL | ISIG | \
     ICANON | ALTWERASE | IEXTEN | TOSTOP | FLUSHO | NOKERNINFO | NOFLSH)
#define TTYSUP_CFLAG                                                       \
    (CIGNORE | CSIZE | CSTOPB | CREAD | PARENB | PARODD | HUPCL | CLOCAL | \
     CCTS_OFLOW | CRTS_IFLOW | CDTR_IFLOW | CDSR_OFLOW | CCAR_OFLOW |      \
     CNO_RTSDTR)

/*
 * Set TTY buffer sizes.
 */

#define TTYBUF_MAX 65536

#ifdef PRINTF_BUFR_SIZE
#define TTY_PRBUF_SIZE PRINTF_BUFR_SIZE
#else
#define TTY_PRBUF_SIZE 256
#endif

/* Note: access to struct cdev:si_drv0.
    Since pull-in, pull-out is not provided, this field
    is constant value 0 in smart system */
#define dev2unit(d)        (0)
#define TTY_CALLOUT(tp, d) (dev2unit(d) & TTYUNIT_CALLOUT)

/*
 * Allocate buffer space if necessary, and set low watermarks, based on speed.
 * Note that the ttyxxxq_setsize() functions may drop and then reacquire the tty
 * lock during memory allocation.  They will return ENXIO if the tty disappears
 * while unlocked.
 */
static int tty_watermarks(struct lwp_tty *tp)
{
    size_t bs = 0;
    int error;

    /* Provide an input buffer for 2 seconds of data. */
    if (tp->t_termios.c_cflag & CREAD)
        bs =
            MIN(bsd_speed_to_integer(tp->t_termios.__c_ispeed) / 5, TTYBUF_MAX);
    error = ttyinq_setsize(&tp->t_inq, tp, bs);
    if (error != 0)
        return error;

    /* Set low watermark at 10% (when 90% is available). */
    tp->t_inlow = (ttyinq_getallocatedsize(&tp->t_inq) * 9) / 10;

    /* Provide an output buffer for 2 seconds of data. */
    bs = MIN(bsd_speed_to_integer(tp->t_termios.__c_ospeed) / 5, TTYBUF_MAX);
    error = ttyoutq_setsize(&tp->t_outq, tp, bs);
    if (error != 0)
        return error;

    /* Set low watermark at 10% (when 90% is available). */
    tp->t_outlow = (ttyoutq_getallocatedsize(&tp->t_outq) * 9) / 10;

    return 0;
}

/**
 * Drain outq
 */
static int tty_drain(struct lwp_tty *tp, int leaving)
{
    rt_tick_t timeout_tick;
    size_t bytes;
    int error;

#ifdef USING_BSD_HOOK
    if (ttyhook_hashook(tp, getc_inject))
        /* buffer is inaccessible */
        return 0;
#endif /* USING_BSD_HOOK */

    /*
     * For close(), use the recent historic timeout of "1 second without
     * making progress".  For tcdrain(), use t_drainwait as the timeout,
     * with zero meaning "no timeout" which gives POSIX behavior.
     */
    if (leaving)
        timeout_tick = rt_tick_get() + RT_TICK_PER_SECOND;
    else if (tp->t_drainwait != 0)
        timeout_tick = rt_tick_get() + RT_TICK_PER_SECOND * tp->t_drainwait;
    else
        timeout_tick = 0;

    /*
     * Poll the output buffer and the hardware for completion, at 10 Hz.
     * Polling is required for devices which are not able to signal an
     * interrupt when the transmitter becomes idle (most USB serial devs).
     * The unusual structure of this loop ensures we check for busy one more
     * time after tty_timedwait() returns EWOULDBLOCK, so that success has
     * higher priority than timeout if the IO completed in the last 100mS.
     */
    error = 0;
    bytes = ttyoutq_bytesused(&tp->t_outq);
    for (;;)
    {
        if (ttyoutq_bytesused(&tp->t_outq) == 0 && !ttydevsw_busy(tp))
            return 0;
        if (error != 0)
            return error;
        ttydevsw_outwakeup(tp);
        error = tty_timedwait(tp, &tp->t_outwait, RT_TICK_PER_SECOND / 10);
        if (error != 0 && error != EWOULDBLOCK)
            return error;
        else if (timeout_tick == 0 || rt_tick_get() < timeout_tick)
            error = 0;
        else if (leaving && ttyoutq_bytesused(&tp->t_outq) < bytes)
        {
            /* In close, making progress, grant an extra second. */
            error = 0;
            timeout_tick += RT_TICK_PER_SECOND;
            bytes = ttyoutq_bytesused(&tp->t_outq);
        }
    }
}

/*
 * Though ttydev_enter() and ttydev_leave() seem to be related, they
 * don't have to be used together. ttydev_enter() is used by the cdev
 * operations to prevent an actual operation from being processed when
 * the TTY has been abandoned. ttydev_leave() is used by ttydev_open()
 * and ttydev_close() to determine whether per-TTY data should be
 * deallocated.
 */

rt_inline int ttydev_enter(struct lwp_tty *tp)
{
    rt_err_t error = tty_lock(tp);
    if (error)
        RT_ASSERT(0);

    if (tty_gone(tp) || !tty_opened(tp))
    {
        /* Device is already gone. */
        tty_unlock(tp);
        return -ENXIO;
    }

    return 0;
}

static void ttydev_leave(struct lwp_tty *tp)
{
    tty_assert_locked(tp);

    if (tty_opened(tp) || tp->t_flags & TF_OPENCLOSE)
    {
        /* Device is still opened somewhere. */
        tty_unlock(tp);
        return;
    }

    tp->t_flags |= TF_OPENCLOSE;

    /* Remove console TTY. */
    constty_clear(tp);

    /* Drain any output. */
    if (!tty_gone(tp))
        tty_drain(tp, 1);

    ttydisc_close(tp);

    /* Free i/o queues now since they might be large. */
    ttyinq_free(&tp->t_inq);
    tp->t_inlow = 0;
    ttyoutq_free(&tp->t_outq);
    tp->t_outlow = 0;

#ifdef USING_BSD_KNOTE
    knlist_clear(&tp->t_inpoll.si_note, 1);
    knlist_clear(&tp->t_outpoll.si_note, 1);
#endif

    if (!tty_gone(tp))
        ttydevsw_close(tp);

    tp->t_flags &= ~TF_OPENCLOSE;
    cv_broadcast(&tp->t_dcdwait);
    tty_rel_free(tp);
}

/*
 * Operations that are exposed through the character device in /dev.
 */
static int ttydev_open(struct lwp_tty *tp, int oflags, int devtype,
                       struct rt_thread *td)
{
    rt_device_t dev = &tp->parent;
    int error;

    error = 0;
    tty_lock(tp);
    if (tty_gone(tp))
    {
        /* Device is already gone. */
        tty_unlock(tp);
        return -ENXIO;
    }

    /*
     * Block when other processes are currently opening or closing
     * the TTY.
     */
    while (tp->t_flags & TF_OPENCLOSE)
    {
        error = tty_wait(tp, &tp->t_dcdwait);
        if (error != 0)
        {
            tty_unlock(tp);
            return error;
        }
    }
    tp->t_flags |= TF_OPENCLOSE;

    /*
     * Make sure the "tty" and "cua" device cannot be opened at the
     * same time.  The console is a "tty" device.
     */
    if (TTY_CALLOUT(tp, dev))
    {
        if (tp->t_flags & (TF_OPENED_CONS | TF_OPENED_IN))
        {
            error = EBUSY;
            goto done;
        }
    }
    else
    {
        if (tp->t_flags & TF_OPENED_OUT)
        {
            error = EBUSY;
            goto done;
        }
    }

    if (tp->t_flags & TF_EXCLUDE && priv_check(td, PRIV_TTY_EXCLUSIVE))
    {
        error = EBUSY;
        goto done;
    }

    if (!tty_opened(tp))
    {
        /* Set proper termios flags. */
        if (TTY_CALLOUT(tp, dev))
#ifdef USING_BSD_INIT_LOCK_DEVICE
            tp->t_termios = tp->t_termios_init_out;
#else
            ;
#endif /* USING_BSD_INIT_LOCK_DEVICE */
        else
            tp->t_termios = tp->t_termios_init_in;

        ttydevsw_param(tp, &tp->t_termios);
        /* Prevent modem control on callout devices and /dev/console. */
        if (TTY_CALLOUT(tp, dev) || dev == dev_console)
            tp->t_termios.c_cflag |= CLOCAL;

        if ((tp->t_termios.c_cflag & CNO_RTSDTR) == 0)
            ttydevsw_modem(tp, SER_DTR | SER_RTS, 0);

        error = ttydevsw_open(tp);
        if (error != 0)
            goto done;

        ttydisc_open(tp);
        error = tty_watermarks(tp);
        if (error != 0)
            goto done;
    }

    /* Wait for Carrier Detect. */
    if ((oflags & O_NONBLOCK) == 0 && (tp->t_termios.c_cflag & CLOCAL) == 0)
    {
        while ((ttydevsw_modem(tp, 0, 0) & SER_DCD) == 0)
        {
            error = tty_wait(tp, &tp->t_dcdwait);
            if (error != 0)
                goto done;
        }
    }

    if (dev == dev_console)
        tp->t_flags |= TF_OPENED_CONS;
    else if (TTY_CALLOUT(tp, dev))
        tp->t_flags |= TF_OPENED_OUT;
    else
        tp->t_flags |= TF_OPENED_IN;
    MPASS((tp->t_flags & (TF_OPENED_CONS | TF_OPENED_IN)) == 0 ||
          (tp->t_flags & TF_OPENED_OUT) == 0);

done:
    tp->t_flags &= ~TF_OPENCLOSE;
    cv_broadcast(&tp->t_dcdwait);
    ttydev_leave(tp);

    return error;
}

static int ttydev_close(struct lwp_tty *tp, int fflag, int devtype __unused,
                        struct rt_thread *td __unused)
{
    rt_device_t dev = &tp->parent;

    tty_lock(tp);

    /*
     * Don't actually close the device if it is being used as the
     * console.
     */
    MPASS((tp->t_flags & (TF_OPENED_CONS | TF_OPENED_IN)) == 0 ||
          (tp->t_flags & TF_OPENED_OUT) == 0);
    if (dev == dev_console)
        tp->t_flags &= ~TF_OPENED_CONS;
    else
        tp->t_flags &= ~(TF_OPENED_IN | TF_OPENED_OUT);

    if (tp->t_flags & TF_OPENED)
    {
        tty_unlock(tp);
        return 0;
    }

    /* If revoking, flush output now to avoid draining it later. */
    if (fflag & FREVOKE)
        tty_flush(tp, FWRITE);

    tp->t_flags &= ~TF_EXCLUDE;

    /* Properly wake up threads that are stuck - revoke(). */
    tp->t_revokecnt++;
    tty_wakeup(tp, FREAD | FWRITE);
    cv_broadcast(&tp->t_bgwait);
    cv_broadcast(&tp->t_dcdwait);

    ttydev_leave(tp);

    return 0;
}

int tty_wait_background(struct lwp_tty *tp, struct rt_thread *td, int sig)
{
    struct rt_lwp *p;
    struct rt_processgroup *pg;
    int error;

    MPASS(sig == SIGTTIN || sig == SIGTTOU);
    tty_assert_locked(tp);

    p = td->lwp;
    for (;;)
    {
        pg = p->pgrp;
        PGRP_LOCK(pg);
        LWP_LOCK(p);

        /*
         * pg may no longer be our process group.
         * Re-check after locking.
         */
        if (p->pgrp != pg)
        {
            LWP_UNLOCK(p);
            PGRP_UNLOCK(pg);
            continue;
        }

        /*
         * The process should only sleep, when:
         * - This terminal is the controlling terminal
         * - Its process group is not the foreground process
         *   group
         * - The parent process isn't waiting for the child to
         *   exit
         * - the signal to send to the process isn't masked
         */
        if (!tty_is_ctty(tp, p) || pg == tp->t_pgrp)
        {
            /* Allow the action to happen. */
            LWP_UNLOCK(p);
            PGRP_UNLOCK(pg);
            return 0;
        }

        /* Note: process itself don't have a sigmask in smart */
        if (lwp_sigisign(p, sig) ||
            lwp_sigismember(&td->signal.sigset_mask, sig))
        {
            /* Only allow them in write()/ioctl(). */
            LWP_UNLOCK(p);
            PGRP_UNLOCK(pg);
            return (sig == SIGTTOU ? 0 : -EIO);
        }

#ifdef USING_VFORK_FLAG
        if ((p->p_flag & P_PPWAIT) != 0 || pg->is_orphaned)
#else
        if (pg->is_orphaned)
#endif
        {
            /* Don't allow the action to happen. */
            LWP_UNLOCK(p);
            PGRP_UNLOCK(pg);
            return -EIO;
        }
        LWP_UNLOCK(p);

        /*
         * Send the signal and sleep until we're the new
         * foreground process group.
         */
        if (sig != 0)
        {
            lwp_pgrp_signal_kill(pg, sig, SI_KERNEL, 0);
        }

        PGRP_UNLOCK(pg);

        error = tty_wait(tp, &tp->t_bgwait);
        if (error)
            return error;
    }
}

static int ttydev_read(struct lwp_tty *tp, struct uio *uio, int ioflag)
{
    int error;

    error = ttydev_enter(tp);
    if (error)
        goto done;
    error = ttydisc_read(tp, uio, ioflag);
    tty_unlock(tp);

    /*
     * The read() call should not throw an error when the device is
     * being destroyed. Silently convert it to an EOF.
     */
done:
    if (error == -ENXIO)
        error = 0;
    return error;
}

static int ttydev_write(struct lwp_tty *tp, struct uio *uio, int ioflag)
{
#ifdef USING_BSD_DEFER_STOP
    int defer;
#endif
    int error;

    error = ttydev_enter(tp);
    if (error)
        return error;

    if (tp->t_termios.c_lflag & TOSTOP)
    {
        error = tty_wait_background(tp, curthread, SIGTTOU);
        if (error)
            goto done;
    }

    if (ioflag & IO_NDELAY && tp->t_flags & TF_BUSY_OUT)
    {
        /* Allow non-blocking writes to bypass serialization. */
        error = ttydisc_write(tp, uio, ioflag);
    }
    else
    {
        /* Serialize write() calls. */
        while (tp->t_flags & TF_BUSY_OUT)
        {
            error = tty_wait(tp, &tp->t_outserwait);
            if (error)
                goto done;
        }

        tp->t_flags |= TF_BUSY_OUT;
#ifdef USING_BSD_DEFER_STOP
        defer = sigdeferstop(SIGDEFERSTOP_ERESTART);
#endif
        error = ttydisc_write(tp, uio, ioflag);
#ifdef USING_BSD_DEFER_STOP
        sigallowstop(defer);
#endif
        tp->t_flags &= ~TF_BUSY_OUT;
        cv_signal(&tp->t_outserwait);
    }

done:
    tty_unlock(tp);
    return error;
}

static int ttydev_ioctl(struct lwp_tty *tp, rt_ubase_t cmd, rt_caddr_t data, int fflag,
                        struct rt_thread *td)
{
    int error;

    error = ttydev_enter(tp);
    if (error)
        return (error);

    switch (cmd)
    {
        case TIOCCBRK:
        case TIOCCONS:
        case TIOCDRAIN:
        case TIOCEXCL:
        case TIOCFLUSH:
        case TIOCNXCL:
        case TIOCSBRK:
        case TIOCSCTTY:
        case TIOCSETA:
        case TIOCSETAF:
        case TIOCSETAW:
        case TIOCSPGRP:
        case TIOCSTART:
        case TIOCSTAT:
        case TIOCSTI:
        case TIOCSTOP:
        case TIOCSWINSZ:
#if USING_BSD_TIOCSDRAINWAIT
    case TIOCSDRAINWAIT:
    case TIOCSETD:
#endif /* USING_BSD_TIOCSDRAINWAIT */
#ifdef COMPAT_43TTY
        case TIOCLBIC:
        case TIOCLBIS:
        case TIOCLSET:
        case TIOCSETC:
        case OTIOCSETD:
        case TIOCSETN:
        case TIOCSETP:
        case TIOCSLTC:
#endif /* COMPAT_43TTY */
            /*
             * If the ioctl() causes the TTY to be modified, let it
             * wait in the background.
             */
            error = tty_wait_background(tp, curthread, SIGTTOU);
            if (error)
                goto done;
    }

#ifdef USING_BSD_INIT_LOCK_DEVICE
    if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF)
    {
        struct termios *old = &tp->t_termios;
        struct termios *new = (struct termios *)data;
        struct termios *lock = TTY_CALLOUT(tp, dev) ? &tp->t_termios_lock_out
                                                    : &tp->t_termios_lock_in;
        int cc;

        /*
         * Lock state devices.  Just overwrite the values of the
         * commands that are currently in use.
         */
        new->c_iflag =
            (old->c_iflag & lock->c_iflag) | (new->c_iflag & ~lock->c_iflag);
        new->c_oflag =
            (old->c_oflag & lock->c_oflag) | (new->c_oflag & ~lock->c_oflag);
        new->c_cflag =
            (old->c_cflag & lock->c_cflag) | (new->c_cflag & ~lock->c_cflag);
        new->c_lflag =
            (old->c_lflag & lock->c_lflag) | (new->c_lflag & ~lock->c_lflag);
        for (cc = 0; cc < NCCS; ++cc)
            if (lock->c_cc[cc])
                new->c_cc[cc] = old->c_cc[cc];
        if (lock->__c_ispeed)
            new->__c_ispeed = old->__c_ispeed;
        if (lock->__c_ospeed)
            new->__c_ospeed = old->__c_ospeed;
    }
#endif /* USING_BSD_INIT_LOCK_DEVICE */

    error = tty_ioctl(tp, cmd, data, fflag, td);
done:
    tty_unlock(tp);

    return (error);
}

static int ttydev_poll(struct lwp_tty *tp, rt_pollreq_t *req, struct rt_thread *td)
{
    int events = req->_key;
    int error, revents = 0;

    error = ttydev_enter(tp);
    if (error)
        return ((events & (POLLIN | POLLRDNORM)) | POLLHUP);

    if (events & (POLLIN | POLLRDNORM))
    {
        /* See if we can read something. */
        if (ttydisc_read_poll(tp) > 0)
            revents |= events & (POLLIN | POLLRDNORM);
    }

    if (tp->t_flags & TF_ZOMBIE)
    {
        /* Hangup flag on zombie state. */
        revents |= POLLHUP;
    }
    else if (events & (POLLOUT | POLLWRNORM))
    {
        /* See if we can write something. */
        if (ttydisc_write_poll(tp) > 0)
            revents |= events & (POLLOUT | POLLWRNORM);
    }

    if (revents == 0)
    {
        if (events & (POLLIN | POLLRDNORM))
            rt_poll_add(&tp->t_inpoll, req);
        if (events & (POLLOUT | POLLWRNORM))
            rt_poll_add(&tp->t_outpoll, req);
    }

    tty_unlock(tp);

    return revents;
}

static struct cdevsw ttydev_cdevsw = {
    .d_open = ttydev_open,
    .d_close = ttydev_close,
    .d_read = ttydev_read,
    .d_write = ttydev_write,
    .d_ioctl = ttydev_ioctl,
#if 0
    .d_kqfilter = ttydev_kqfilter,
#endif
    .d_poll = ttydev_poll,
#if 0
    .d_mmap = ttydev_mmap,
#endif

#ifdef USING_BSD_RAW_CDEVSW
    .d_version = D_VERSION.d_name = "ttydev",
    .d_flags = D_TTY,
#endif /* USING_BSD_RAW_CDEVSW */
};

extern struct cdevsw bsd_ttydev_methods __attribute__((alias("ttydev_cdevsw")));

/*
 * Standard device routine implementations, mostly meant for
 * pseudo-terminal device drivers. When a driver creates a new terminal
 * device class, missing routines are patched.
 */
#define panic(msg) RT_ASSERT(0 && msg)

static int ttydevsw_defopen(struct lwp_tty *tp __unused)
{
    return 0;
}

static void ttydevsw_defclose(struct lwp_tty *tp __unused)
{
}

static void ttydevsw_defoutwakeup(struct lwp_tty *tp __unused)
{
    panic("Terminal device has output, while not implemented");
}

static void ttydevsw_definwakeup(struct lwp_tty *tp __unused)
{
}

static int ttydevsw_defioctl(struct lwp_tty *tp __unused, rt_ubase_t cmd __unused,
                             rt_caddr_t data __unused,
                             struct rt_thread *td __unused)
{
    return -ENOSYS;
}

static int ttydevsw_defcioctl(struct lwp_tty *tp __unused, int unit __unused,
                              rt_ubase_t cmd __unused, rt_caddr_t data __unused,
                              struct rt_thread *td __unused)
{
    return -ENOSYS;
}

static int ttydevsw_defparam(struct lwp_tty *tp __unused, struct termios *t)
{
    /*
     * Allow the baud rate to be adjusted for pseudo-devices, but at
     * least restrict it to 115200 to prevent excessive buffer
     * usage.  Also disallow 0, to prevent foot shooting.
     */
    if (t->__c_ispeed < B50)
        t->__c_ispeed = B50;
    else if (t->__c_ispeed > B115200)
        t->__c_ispeed = B115200;
    if (t->__c_ospeed < B50)
        t->__c_ospeed = B50;
    else if (t->__c_ospeed > B115200)
        t->__c_ospeed = B115200;
    t->c_cflag |= CREAD;

    return 0;
}

static int ttydevsw_defmodem(struct lwp_tty *tp __unused, int sigon __unused,
                             int sigoff __unused)
{
    /* Simulate a carrier to make the TTY layer happy. */
    return (SER_DCD);
}

static int ttydevsw_defmmap(struct lwp_tty *tp __unused,
                            vm_ooffset_t offset __unused,
                            vm_paddr_t *paddr __unused, int nprot __unused,
                            vm_memattr_t *memattr __unused)
{
    return (-1);
}

static void ttydevsw_defpktnotify(struct lwp_tty *tp __unused,
                                  char event __unused)
{
}

static void ttydevsw_deffree(void *softc __unused)
{
    panic("Terminal device freed without a free-handler");
}

static rt_bool_t ttydevsw_defbusy(struct lwp_tty *tp __unused)
{
    return (RT_FALSE);
}

void bsd_devsw_init(struct lwp_ttydevsw *tsw)
{
    /* Make sure the driver defines all routines. */
#define PATCH_FUNC(x)                       \
    do                                      \
    {                                       \
        if (tsw->tsw_##x == NULL)           \
            tsw->tsw_##x = ttydevsw_def##x; \
    } while (0)

    PATCH_FUNC(open);
    PATCH_FUNC(close);
    PATCH_FUNC(outwakeup);
    PATCH_FUNC(inwakeup);
    PATCH_FUNC(ioctl);
    PATCH_FUNC(cioctl);
    PATCH_FUNC(param);
    PATCH_FUNC(modem);
    PATCH_FUNC(mmap);
    PATCH_FUNC(pktnotify);
    PATCH_FUNC(free);
    PATCH_FUNC(busy);
#undef PATCH_FUNC
}

/* release tty, and free the cdev resource */
static void tty_rel_free(struct lwp_tty *tp)
{
#ifdef USING_BSD_CHAR_DEVICE
    struct cdev *dev;
#endif

    tty_assert_locked(tp);

#define TF_ACTIVITY (TF_GONE | TF_OPENED | TF_HOOK | TF_OPENCLOSE)
    if (tp->t_sessioncnt != 0 || (tp->t_flags & TF_ACTIVITY) != TF_GONE)
    {
        /* TTY is still in use. */
        tty_unlock(tp);
        return;
    }

#ifdef USING_BSD_AIO
    /* Stop asynchronous I/O. */
    funsetown(&tp->t_sigio);
#endif /* USING_BSD_AIO */

#ifdef USING_BSD_CHAR_DEVICE
    /* TTY can be deallocated. */
    dev = tp->t_dev;
    tp->t_dev = NULL;
#endif /* USING_BSD_CHAR_DEVICE */

    tty_unlock(tp);

#ifdef USING_BSD_CHAR_DEVICE
    if (dev != NULL)
    {
        sx_xlock(&tty_list_sx);
        TAILQ_REMOVE(&tty_list, tp, t_list);
        tty_list_count--;
        sx_xunlock(&tty_list_sx);
        destroy_dev_sched_cb(dev, tty_dealloc, tp);
    }
#else
    lwp_tty_delete(tp);
#endif
}

void tty_rel_pgrp(struct lwp_tty *tp, struct rt_processgroup *pg)
{
    MPASS(tp->t_sessioncnt > 0);
    tty_assert_locked(tp);

    if (tp->t_pgrp == pg)
        tp->t_pgrp = NULL;

    tty_unlock(tp);
}

void tty_rel_sess(struct lwp_tty *tp, struct rt_session *sess)
{
    MPASS(tp->t_sessioncnt > 0);

    /* Current session has left. */
    if (tp->t_session == sess)
    {
        tp->t_session = NULL;
        MPASS(tp->t_pgrp == NULL);
    }
    tp->t_sessioncnt--;
    tty_rel_free(tp);
}

/* deallocate the tty */
void tty_rel_gone(struct lwp_tty *tp)
{
    tty_assert_locked(tp);
    MPASS(!tty_gone(tp));

    /* Simulate carrier removal. */
    ttydisc_modem(tp, 0);

    /* Wake up all blocked threads. */
    tty_wakeup(tp, FREAD | FWRITE);
    cv_broadcast(&tp->t_bgwait);
    cv_broadcast(&tp->t_dcdwait);

    tp->t_flags |= TF_GONE;
    tty_rel_free(tp);
}

static int tty_drop_ctty(struct lwp_tty *tp, struct rt_lwp *p)
{
    struct rt_session *session;
#ifdef USING_BSD_VNODE
    struct vnode *vp;
#endif

    /*
     * This looks terrible, but it's generally safe as long as the tty
     * hasn't gone away while we had the lock dropped.  All of our sanity
     * checking that this operation is OK happens after we've picked it back
     * up, so other state changes are generally not fatal and the potential
     * for this particular operation to happen out-of-order in a
     * multithreaded scenario is likely a non-issue.
     */
    tty_unlock(tp);
    LWP_LOCK(p);
    tty_lock(tp);
    if (tty_gone(tp))
    {
        LWP_UNLOCK(p);
        return -ENODEV;
    }

    /*
     * If the session doesn't have a controlling TTY, or if we weren't
     * invoked on the controlling TTY, we'll return ENOIOCTL as we've
     * historically done.
     */
    session = p->pgrp->session;
    if (session->ctty == NULL || session->ctty != tp)
    {
        LWP_UNLOCK(p);
        return -ENOTTY;
    }

    if (!is_sess_leader(p))
    {
        LWP_UNLOCK(p);
        return -EPERM;
    }

    SESS_LOCK(session);
#ifdef USING_BSD_VNODE
    vp = session->s_ttyvp;
#endif
    session->ctty = NULL;
#ifdef USING_BSD_VNODE
    session->s_ttyvp = NULL;
    session->s_ttydp = NULL;
#endif
    SESS_UNLOCK(session);

    tp->t_sessioncnt--;
    p->term_ctrlterm = RT_FALSE;
    LWP_UNLOCK(p);

#ifdef USING_BSD_VNODE
    /*
     * If we did have a vnode, release our reference.  Ordinarily we manage
     * these at the devfs layer, but we can't necessarily know that we were
     * invoked on the vnode referenced in the session (i.e. the vnode we
     * hold a reference to).  We explicitly don't check VBAD/VIRF_DOOMED here
     * to avoid a vnode leak -- in circumstances elsewhere where we'd hit a
     * VIRF_DOOMED vnode, release has been deferred until the controlling TTY
     * is either changed or released.
     */
    if (vp != NULL)
        devfs_ctty_unref(vp);
#endif

    return 0;
}

void tty_wakeup(struct lwp_tty *tp, int flags)
{
#ifdef USING_BSD_AIO
    if (tp->t_flags & TF_ASYNC && tp->t_sigio != NULL)
        pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
#endif

    if (flags & FWRITE)
    {
        cv_broadcast(&tp->t_outwait);
#ifdef USING_BSD_POLL
        selwakeup(&tp->t_outpoll);
        KNOTE_LOCKED(&tp->t_outpoll.si_note, 0);
#else
        rt_wqueue_wakeup_all(&tp->t_outpoll, (void *)POLLOUT);
#endif
    }
    if (flags & FREAD)
    {
        cv_broadcast(&tp->t_inwait);
#ifdef USING_BSD_POLL
        selwakeup(&tp->t_inpoll);
        KNOTE_LOCKED(&tp->t_inpoll.si_note, 0);
#else
        rt_wqueue_wakeup_all(&tp->t_inpoll, (void *)POLLIN);
#endif
    }
}

int tty_wait(struct lwp_tty *tp, struct rt_condvar *cv)
{
    int error;
    int revokecnt = tp->t_revokecnt;

    tty_lock_assert(tp, MA_OWNED | MA_NOTRECURSED);
    MPASS(!tty_gone(tp));

    error = cv_wait_sig(cv, tp->t_mtx);

    /* Bail out when the device slipped away. */
    if (tty_gone(tp))
        return -ENXIO;

    /* Restart the system call when we may have been revoked. */
    if (tp->t_revokecnt != revokecnt)
        return -ERESTART;

    return error;
}

int tty_timedwait(struct lwp_tty *tp, struct rt_condvar *cv, rt_tick_t timeout)
{
    int error;
    int revokecnt = tp->t_revokecnt;

    tty_lock_assert(tp, MA_OWNED | MA_NOTRECURSED);
    MPASS(!tty_gone(tp));

    error = cv_timedwait_sig(cv, tp->t_mtx, timeout);

    /* Bail out when the device slipped away. */
    if (tty_gone(tp))
        return -ENXIO;

    /* Restart the system call when we may have been revoked. */
    if (tp->t_revokecnt != revokecnt)
        return -ERESTART;

    return error;
}

/* discard data in I/O buffers */
void tty_flush(struct lwp_tty *tp, int flags)
{
    if (flags & FWRITE)
    {
        tp->t_flags &= ~TF_HIWAT_OUT;
        ttyoutq_flush(&tp->t_outq);
        tty_wakeup(tp, FWRITE);
        if (!tty_gone(tp))
        {
            ttydevsw_outwakeup(tp);
            ttydevsw_pktnotify(tp, TIOCPKT_FLUSHWRITE);
        }
    }
    if (flags & FREAD)
    {
        tty_hiwat_in_unblock(tp);
        ttyinq_flush(&tp->t_inq);
        tty_wakeup(tp, FREAD);
        if (!tty_gone(tp))
        {
            ttydevsw_inwakeup(tp);
            ttydevsw_pktnotify(tp, TIOCPKT_FLUSHREAD);
        }
    }
}

void tty_set_winsize(struct lwp_tty *tp, const struct winsize *wsz)
{
    if (memcmp(&tp->t_winsize, wsz, sizeof(*wsz)) == 0)
        return;
    tp->t_winsize = *wsz;
    lwp_tty_signal_pgrp(tp, SIGWINCH);
}

static int tty_generic_ioctl(struct lwp_tty *tp, rt_ubase_t cmd, void *data,
                             int fflag, struct rt_thread *td)
{
    int error;

    switch (cmd)
    {
        /*
         * Modem commands.
         * The SER_* and TIOCM_* flags are the same, but one bit
         * shifted. I don't know why.
         */
        case TIOCSDTR:
            ttydevsw_modem(tp, SER_DTR, 0);
            return 0;
        case TIOCCDTR:
            ttydevsw_modem(tp, 0, SER_DTR);
            return 0;
        case TIOCMSET: {
            int bits = *(int *)data;
            ttydevsw_modem(tp, (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1,
                           ((~bits) & (TIOCM_DTR | TIOCM_RTS)) >> 1);
            return 0;
        }
        case TIOCMBIS: {
            int bits = *(int *)data;
            ttydevsw_modem(tp, (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1, 0);
            return 0;
        }
        case TIOCMBIC: {
            int bits = *(int *)data;
            ttydevsw_modem(tp, 0, (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1);
            return 0;
        }
        case TIOCMGET:
            *(int *)data = TIOCM_LE + (ttydevsw_modem(tp, 0, 0) << 1);
            return 0;

        case FIOASYNC:
            if (*(int *)data)
                tp->t_flags |= TF_ASYNC;
            else
                tp->t_flags &= ~TF_ASYNC;
            return 0;
        case FIONBIO:
            /* This device supports non-blocking operation. */
            return 0;
        case FIONREAD:
            *(int *)data = ttyinq_bytescanonicalized(&tp->t_inq);
            return 0;
        case FIONWRITE:
        case TIOCOUTQ:
            *(int *)data = ttyoutq_bytesused(&tp->t_outq);
            return 0;
#if BSD_USING_FIO_OWNERSHIP
        case FIOSETOWN:
            if (tp->t_session != NULL && !tty_is_ctty(tp, td->lwp))
                /* Not allowed to set ownership. */
                return -ENOTTY;

            /* Temporarily unlock the TTY to set ownership. */
            tty_unlock(tp);
            error = fsetown(*(int *)data, &tp->t_sigio);
            tty_lock(tp);
            return (error);
        case FIOGETOWN:
            if (tp->t_session != NULL && !tty_is_ctty(tp, td->lwp))
                /* Not allowed to set ownership. */
                return -ENOTTY;

            /* Get ownership. */
            *(int *)data = fgetown(&tp->t_sigio);
            return 0;
#endif
        case TIOCGETA:
            /* Obtain terminal flags through tcgetattr(). */
            *(struct termios *)data = tp->t_termios;
            return 0;
        case TIOCSETA:
        case TIOCSETAW:
        case TIOCSETAF: {
            struct termios *t = data;

            /*
             * Who makes up these funny rules? According to POSIX,
             * input baud rate is set equal to the output baud rate
             * when zero.
             */
            if (t->__c_ispeed == 0)
                t->__c_ispeed = t->__c_ospeed;

            /* Discard any unsupported bits. */
            t->c_iflag &= TTYSUP_IFLAG;
            t->c_oflag &= TTYSUP_OFLAG;
            t->c_lflag &= TTYSUP_LFLAG;
            t->c_cflag &= TTYSUP_CFLAG;

            /* Set terminal flags through tcsetattr(). */
            if (cmd == TIOCSETAW || cmd == TIOCSETAF)
            {
                error = tty_drain(tp, 0);
                if (error)
                    return (error);
                if (cmd == TIOCSETAF)
                    tty_flush(tp, FREAD);
            }

            /*
             * Only call param() when the flags really change.
             */
            if ((t->c_cflag & CIGNORE) == 0 &&
                (tp->t_termios.c_cflag != t->c_cflag ||
                 ((tp->t_termios.c_iflag ^ t->c_iflag) &
                  (IXON | IXOFF | IXANY)) ||
                 tp->t_termios.__c_ispeed != t->__c_ispeed ||
                 tp->t_termios.__c_ospeed != t->__c_ospeed))
            {
                error = ttydevsw_param(tp, t);
                if (error)
                    return (error);

                /* XXX: CLOCAL? */

                tp->t_termios.c_cflag = t->c_cflag & ~CIGNORE;
                tp->t_termios.__c_ispeed = t->__c_ispeed;
                tp->t_termios.__c_ospeed = t->__c_ospeed;

                /* Baud rate has changed - update watermarks. */
                error = tty_watermarks(tp);
                if (error)
                    return (error);
            }

            /* Copy new non-device driver parameters. */
            tp->t_termios.c_iflag = t->c_iflag;
            tp->t_termios.c_oflag = t->c_oflag;
            tp->t_termios.c_lflag = t->c_lflag;
            memcpy(&tp->t_termios.c_cc, t->c_cc, sizeof t->c_cc);

            ttydisc_optimize(tp);

            if ((t->c_lflag & ICANON) == 0)
            {
                /*
                 * When in non-canonical mode, wake up all
                 * readers. Canonicalize any partial input. VMIN
                 * and VTIME could also be adjusted.
                 */
                ttyinq_canonicalize(&tp->t_inq);
                tty_wakeup(tp, FREAD);
            }

            /**
             * For packet mode: notify the PTY consumer that VSTOP
             * and VSTART may have been changed.
             *
             * TODO: change the _CONTROL('S') to a CSTOP?
             */
            if (tp->t_termios.c_iflag & IXON &&
                tp->t_termios.c_cc[VSTOP] == _CONTROL('S') &&
                tp->t_termios.c_cc[VSTART] == _CONTROL('Q'))
                ttydevsw_pktnotify(tp, TIOCPKT_DOSTOP);
            else
                ttydevsw_pktnotify(tp, TIOCPKT_NOSTOP);
            return 0;
        }
        case TIOCGETD:
            /* For compatibility - we only support TTYDISC. */
            *(int *)data = TTYDISC;
            return 0;
        case TIOCGPGRP:
            if (!tty_is_ctty(tp, td->lwp))
                return -ENOTTY;

            if (tp->t_pgrp != NULL)
                *(int *)data = tp->t_pgrp->pgid;
            else
                *(int *)data = NO_PID;
            return 0;
        case TIOCGSID:
            if (!tty_is_ctty(tp, td->lwp))
                return -ENOTTY;

            MPASS(tp->t_session);
            *(int *)data = tp->t_session->sid;
            return 0;
        case TIOCNOTTY:
            return tty_drop_ctty(tp, td->lwp);
        case TIOCSCTTY:
            return lwp_tty_set_ctrl_proc(tp, td);
        case TIOCSPGRP: {
            int pgid;
            if (lwp_in_user_space((void *)data))
            {
                if (lwp_get_from_user(&pgid, data, sizeof(int)) != sizeof(int))
                    return -EFAULT;
            }
            else
            {
                pgid = *(int *)data;
            }
            return lwp_tty_assign_foreground(tp, td, pgid);
        }
        case TIOCFLUSH: {
            int flags = *(int *)data;

            if (flags == 0)
                flags = (FREAD | FWRITE);
            else
                flags &= (FREAD | FWRITE);
            tty_flush(tp, flags);
            return 0;
        }
        case TIOCDRAIN:
            /* Drain TTY output. */
            return tty_drain(tp, 0);
        case TIOCGDRAINWAIT:
            *(int *)data = tp->t_drainwait;
            return 0;
        case TIOCSDRAINWAIT:
            error = priv_check(td, PRIV_TTY_DRAINWAIT);
            if (error == 0)
                tp->t_drainwait = *(int *)data;
            return (error);
        case TIOCCONS:
            /* Set terminal as console TTY. */
            if (*(int *)data)
            {
                error = priv_check(td, PRIV_TTY_CONSOLE);
                if (error)
                    return (error);
                error = constty_set(tp);
            }
            else
            {
                error = constty_clear(tp);
            }
            return (error);
        case TIOCGWINSZ:
            /* Obtain window size. */
            *(struct winsize *)data = tp->t_winsize;
            return 0;
        case TIOCSWINSZ:
            /* Set window size. */
            tty_set_winsize(tp, data);
            return 0;
        case TIOCEXCL:
            tp->t_flags |= TF_EXCLUDE;
            return 0;
        case TIOCNXCL:
            tp->t_flags &= ~TF_EXCLUDE;
            return 0;
        case TIOCSTOP:
            tp->t_flags |= TF_STOPPED;
            ttydevsw_pktnotify(tp, TIOCPKT_STOP);
            return 0;
        case TIOCSTART:
            tp->t_flags &= ~TF_STOPPED;
            tp->t_termios.c_lflag &= ~FLUSHO;
            ttydevsw_outwakeup(tp);
            ttydevsw_pktnotify(tp, TIOCPKT_START);
            return 0;
        case TIOCSTAT:
            tty_info(tp);
            return 0;
        case TIOCSTI:
            if ((fflag & FREAD) == 0 && priv_check(td, PRIV_TTY_STI))
                return -EPERM;
            if (!tty_is_ctty(tp, td->lwp) && priv_check(td, PRIV_TTY_STI))
                return -EACCES;
            ttydisc_rint(tp, *(char *)data, 0);
            ttydisc_rint_done(tp);
            return 0;
    }

#ifdef COMPAT_43TTY
    return tty_ioctl_compat(tp, cmd, data, fflag, td);
#else  /* !COMPAT_43TTY */
    return -ENOIOCTL;
#endif /* COMPAT_43TTY */
}

int tty_ioctl(struct lwp_tty *tp, rt_ubase_t cmd, void *data, int fflag,
              struct rt_thread *td)
{
    int error;

    tty_assert_locked(tp);

    if (tty_gone(tp))
        return -ENXIO;

    error = ttydevsw_ioctl(tp, cmd, data, td);
    if (error == -ENOIOCTL)
        error = tty_generic_ioctl(tp, cmd, data, fflag, td);

    return error;
}

int tty_checkoutq(struct lwp_tty *tp)
{
    /* 256 bytes should be enough to print a log message. */
    return (ttyoutq_bytesleft(&tp->t_outq) >= 256);
}

void tty_hiwat_in_block(struct lwp_tty *tp)
{
    if ((tp->t_flags & TF_HIWAT_IN) == 0 && tp->t_termios.c_iflag & IXOFF &&
        tp->t_termios.c_cc[VSTOP] != _POSIX_VDISABLE)
    {
        /*
         * Input flow control. Only enter the high watermark when we
         * can successfully store the VSTOP character.
         */
        if (ttyoutq_write_nofrag(&tp->t_outq, &tp->t_termios.c_cc[VSTOP], 1) ==
            0)
            tp->t_flags |= TF_HIWAT_IN;
    }
    else
    {
        /* No input flow control. */
        tp->t_flags |= TF_HIWAT_IN;
    }
}

void tty_hiwat_in_unblock(struct lwp_tty *tp)
{
    if (tp->t_flags & TF_HIWAT_IN && tp->t_termios.c_iflag & IXOFF &&
        tp->t_termios.c_cc[VSTART] != _POSIX_VDISABLE)
    {
        /*
         * Input flow control. Only leave the high watermark when we
         * can successfully store the VSTART character.
         */
        if (ttyoutq_write_nofrag(&tp->t_outq, &tp->t_termios.c_cc[VSTART], 1) ==
            0)
            tp->t_flags &= ~TF_HIWAT_IN;
    }
    else
    {
        /* No input flow control. */
        tp->t_flags &= ~TF_HIWAT_IN;
    }

    if (!tty_gone(tp))
        ttydevsw_inwakeup(tp);
}
