1bf21cd93STycho Nightingale /*-
2*32640292SAndy Fiddaman * SPDX-License-Identifier: BSD-2-Clause
34c87aefeSPatrick Mooney *
4bf21cd93STycho Nightingale * Copyright (c) 2012 NetApp, Inc.
5bf21cd93STycho Nightingale * Copyright (c) 2013 Neel Natu <neel@freebsd.org>
6bf21cd93STycho Nightingale * All rights reserved.
7bf21cd93STycho Nightingale *
8bf21cd93STycho Nightingale * Redistribution and use in source and binary forms, with or without
9bf21cd93STycho Nightingale * modification, are permitted provided that the following conditions
10bf21cd93STycho Nightingale * are met:
11bf21cd93STycho Nightingale * 1. Redistributions of source code must retain the above copyright
12bf21cd93STycho Nightingale * notice, this list of conditions and the following disclaimer.
13bf21cd93STycho Nightingale * 2. Redistributions in binary form must reproduce the above copyright
14bf21cd93STycho Nightingale * notice, this list of conditions and the following disclaimer in the
15bf21cd93STycho Nightingale * documentation and/or other materials provided with the distribution.
16bf21cd93STycho Nightingale *
17bf21cd93STycho Nightingale * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
18bf21cd93STycho Nightingale * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19bf21cd93STycho Nightingale * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20bf21cd93STycho Nightingale * ARE DISCLAIMED. IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
21bf21cd93STycho Nightingale * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22bf21cd93STycho Nightingale * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23bf21cd93STycho Nightingale * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24bf21cd93STycho Nightingale * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25bf21cd93STycho Nightingale * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26bf21cd93STycho Nightingale * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27bf21cd93STycho Nightingale * SUCH DAMAGE.
28bf21cd93STycho Nightingale *
29bf21cd93STycho Nightingale */
30bf21cd93STycho Nightingale /*
31bf21cd93STycho Nightingale * This file and its contents are supplied under the terms of the
32bf21cd93STycho Nightingale * Common Development and Distribution License ("CDDL"), version 1.0.
33bf21cd93STycho Nightingale * You may only use this file in accordance with the terms of version
34bf21cd93STycho Nightingale * 1.0 of the CDDL.
35bf21cd93STycho Nightingale *
36bf21cd93STycho Nightingale * A full copy of the text of the CDDL should have accompanied this
37bf21cd93STycho Nightingale * source. A copy of the CDDL is also available via the Internet at
38bf21cd93STycho Nightingale * http://www.illumos.org/license/CDDL.
39bf21cd93STycho Nightingale *
40bf21cd93STycho Nightingale * Copyright 2015 Pluribus Networks Inc.
414c87aefeSPatrick Mooney * Copyright 2018 Joyent, Inc.
42bf21cd93STycho Nightingale */
43bf21cd93STycho Nightingale
44bf21cd93STycho Nightingale #include <sys/cdefs.h>
45bf21cd93STycho Nightingale
46bf21cd93STycho Nightingale #include <sys/types.h>
47bf21cd93STycho Nightingale #include <dev/ic/ns16550.h>
484c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
494c87aefeSPatrick Mooney #include <sys/capsicum.h>
504c87aefeSPatrick Mooney #include <capsicum_helpers.h>
51bf21cd93STycho Nightingale #endif
524c87aefeSPatrick Mooney
53bf21cd93STycho Nightingale #include <stdio.h>
54bf21cd93STycho Nightingale #include <stdlib.h>
55bf21cd93STycho Nightingale #include <assert.h>
564c87aefeSPatrick Mooney #include <err.h>
574c87aefeSPatrick Mooney #include <errno.h>
584c87aefeSPatrick Mooney #include <fcntl.h>
59bf21cd93STycho Nightingale #include <termios.h>
60bf21cd93STycho Nightingale #include <unistd.h>
61bf21cd93STycho Nightingale #include <stdbool.h>
62bf21cd93STycho Nightingale #include <string.h>
63bf21cd93STycho Nightingale #include <pthread.h>
644c87aefeSPatrick Mooney #include <sysexits.h>
65bf21cd93STycho Nightingale #ifndef __FreeBSD__
664c87aefeSPatrick Mooney #include <sys/socket.h>
67bf21cd93STycho Nightingale #endif
68bf21cd93STycho Nightingale
69bf21cd93STycho Nightingale #include "mevent.h"
70bf21cd93STycho Nightingale #include "uart_emul.h"
71154972afSPatrick Mooney #include "debug.h"
72bf21cd93STycho Nightingale
73bf21cd93STycho Nightingale #define COM1_BASE 0x3F8
74bf21cd93STycho Nightingale #define COM1_IRQ 4
75bf21cd93STycho Nightingale #define COM2_BASE 0x2F8
76bf21cd93STycho Nightingale #define COM2_IRQ 3
772b948146SAndy Fiddaman #define COM3_BASE 0x3E8
782b948146SAndy Fiddaman #define COM3_IRQ 4
792b948146SAndy Fiddaman #define COM4_BASE 0x2E8
802b948146SAndy Fiddaman #define COM4_IRQ 3
81bf21cd93STycho Nightingale
82bf21cd93STycho Nightingale #define DEFAULT_RCLK 1843200
83*32640292SAndy Fiddaman #define DEFAULT_BAUD 115200
84bf21cd93STycho Nightingale
85bf21cd93STycho Nightingale #define FCR_RX_MASK 0xC0
86bf21cd93STycho Nightingale
87bf21cd93STycho Nightingale #define MCR_OUT1 0x04
88bf21cd93STycho Nightingale #define MCR_OUT2 0x08
89bf21cd93STycho Nightingale
90bf21cd93STycho Nightingale #define MSR_DELTA_MASK 0x0f
91bf21cd93STycho Nightingale
92bf21cd93STycho Nightingale #ifndef REG_SCR
93bf21cd93STycho Nightingale #define REG_SCR com_scr
94bf21cd93STycho Nightingale #endif
95bf21cd93STycho Nightingale
96bf21cd93STycho Nightingale #define FIFOSZ 16
97bf21cd93STycho Nightingale
98bf21cd93STycho Nightingale static bool uart_stdio; /* stdio in use for i/o */
994c87aefeSPatrick Mooney static struct termios tio_stdio_orig;
100bf21cd93STycho Nightingale
101bf21cd93STycho Nightingale static struct {
102bf21cd93STycho Nightingale int baseaddr;
103bf21cd93STycho Nightingale int irq;
104bf21cd93STycho Nightingale bool inuse;
105bf21cd93STycho Nightingale } uart_lres[] = {
106bf21cd93STycho Nightingale { COM1_BASE, COM1_IRQ, false},
107bf21cd93STycho Nightingale { COM2_BASE, COM2_IRQ, false},
1082b948146SAndy Fiddaman { COM3_BASE, COM3_IRQ, false},
1092b948146SAndy Fiddaman { COM4_BASE, COM4_IRQ, false},
110bf21cd93STycho Nightingale };
111bf21cd93STycho Nightingale
112bf21cd93STycho Nightingale #define UART_NLDEVS (sizeof(uart_lres) / sizeof(uart_lres[0]))
113bf21cd93STycho Nightingale
114bf21cd93STycho Nightingale struct fifo {
115bf21cd93STycho Nightingale uint8_t buf[FIFOSZ];
116bf21cd93STycho Nightingale int rindex; /* index to read from */
117bf21cd93STycho Nightingale int windex; /* index to write to */
118bf21cd93STycho Nightingale int num; /* number of characters in the fifo */
119bf21cd93STycho Nightingale int size; /* size of the fifo */
120bf21cd93STycho Nightingale };
121bf21cd93STycho Nightingale
1224c87aefeSPatrick Mooney struct ttyfd {
1234c87aefeSPatrick Mooney bool opened;
1244c87aefeSPatrick Mooney int rfd; /* fd for reading */
1254c87aefeSPatrick Mooney int wfd; /* fd for writing, may be == rfd */
1264c87aefeSPatrick Mooney };
1274c87aefeSPatrick Mooney
128bf21cd93STycho Nightingale struct uart_softc {
129bf21cd93STycho Nightingale pthread_mutex_t mtx; /* protects all softc elements */
130bf21cd93STycho Nightingale uint8_t data; /* Data register (R/W) */
131bf21cd93STycho Nightingale uint8_t ier; /* Interrupt enable register (R/W) */
132bf21cd93STycho Nightingale uint8_t lcr; /* Line control register (R/W) */
133bf21cd93STycho Nightingale uint8_t mcr; /* Modem control register (R/W) */
134bf21cd93STycho Nightingale uint8_t lsr; /* Line status register (R/W) */
135bf21cd93STycho Nightingale uint8_t msr; /* Modem status register (R/W) */
136bf21cd93STycho Nightingale uint8_t fcr; /* FIFO control register (W) */
137bf21cd93STycho Nightingale uint8_t scr; /* Scratch register (R/W) */
138bf21cd93STycho Nightingale
139bf21cd93STycho Nightingale uint8_t dll; /* Baudrate divisor latch LSB */
140bf21cd93STycho Nightingale uint8_t dlh; /* Baudrate divisor latch MSB */
141bf21cd93STycho Nightingale
142bf21cd93STycho Nightingale struct fifo rxfifo;
1434c87aefeSPatrick Mooney struct mevent *mev;
144bf21cd93STycho Nightingale
1454c87aefeSPatrick Mooney struct ttyfd tty;
146bf21cd93STycho Nightingale #ifndef __FreeBSD__
1474c87aefeSPatrick Mooney bool sock;
148bf21cd93STycho Nightingale struct {
149bf21cd93STycho Nightingale int clifd; /* console client unix domain socket */
150bf21cd93STycho Nightingale int servfd; /* console server unix domain socket */
1514c87aefeSPatrick Mooney struct mevent *servmev; /* mevent for server socket */
1524c87aefeSPatrick Mooney } usc_sock;
153bf21cd93STycho Nightingale #endif
154bf21cd93STycho Nightingale
155bf21cd93STycho Nightingale bool thre_int_pending; /* THRE interrupt pending */
156bf21cd93STycho Nightingale
157bf21cd93STycho Nightingale void *arg;
158bf21cd93STycho Nightingale uart_intr_func_t intr_assert;
159bf21cd93STycho Nightingale uart_intr_func_t intr_deassert;
160bf21cd93STycho Nightingale };
161bf21cd93STycho Nightingale
162bf21cd93STycho Nightingale static void uart_drain(int fd, enum ev_type ev, void *arg);
163bf21cd93STycho Nightingale
164bf21cd93STycho Nightingale static void
ttyclose(void)165bf21cd93STycho Nightingale ttyclose(void)
166bf21cd93STycho Nightingale {
167bf21cd93STycho Nightingale
1684c87aefeSPatrick Mooney tcsetattr(STDIN_FILENO, TCSANOW, &tio_stdio_orig);
169bf21cd93STycho Nightingale }
170bf21cd93STycho Nightingale
171bf21cd93STycho Nightingale static void
ttyopen(struct ttyfd * tf)1724c87aefeSPatrick Mooney ttyopen(struct ttyfd *tf)
173bf21cd93STycho Nightingale {
1744c87aefeSPatrick Mooney struct termios orig, new;
175bf21cd93STycho Nightingale
1764c87aefeSPatrick Mooney tcgetattr(tf->rfd, &orig);
1774c87aefeSPatrick Mooney new = orig;
1784c87aefeSPatrick Mooney cfmakeraw(&new);
1794c87aefeSPatrick Mooney new.c_cflag |= CLOCAL;
1804c87aefeSPatrick Mooney tcsetattr(tf->rfd, TCSANOW, &new);
1814c87aefeSPatrick Mooney if (uart_stdio) {
1824c87aefeSPatrick Mooney tio_stdio_orig = orig;
183bf21cd93STycho Nightingale atexit(ttyclose);
184bf21cd93STycho Nightingale }
185154972afSPatrick Mooney raw_stdio = 1;
186bf21cd93STycho Nightingale }
187bf21cd93STycho Nightingale
188bf21cd93STycho Nightingale static int
ttyread(struct ttyfd * tf)1894c87aefeSPatrick Mooney ttyread(struct ttyfd *tf)
190bf21cd93STycho Nightingale {
1914c87aefeSPatrick Mooney unsigned char rb;
192bf21cd93STycho Nightingale
1934c87aefeSPatrick Mooney if (read(tf->rfd, &rb, 1) == 1)
1944c87aefeSPatrick Mooney return (rb);
1954c87aefeSPatrick Mooney else
196bf21cd93STycho Nightingale return (-1);
197bf21cd93STycho Nightingale }
198bf21cd93STycho Nightingale
199bf21cd93STycho Nightingale static void
ttywrite(struct ttyfd * tf,unsigned char wb)2004c87aefeSPatrick Mooney ttywrite(struct ttyfd *tf, unsigned char wb)
201bf21cd93STycho Nightingale {
202bf21cd93STycho Nightingale
2034c87aefeSPatrick Mooney (void)write(tf->wfd, &wb, 1);
204bf21cd93STycho Nightingale }
205bf21cd93STycho Nightingale
206bf21cd93STycho Nightingale #ifndef __FreeBSD__
207bf21cd93STycho Nightingale static void
sockwrite(struct uart_softc * sc,unsigned char wb)2084c87aefeSPatrick Mooney sockwrite(struct uart_softc *sc, unsigned char wb)
209bf21cd93STycho Nightingale {
2104c87aefeSPatrick Mooney (void) write(sc->usc_sock.clifd, &wb, 1);
211bf21cd93STycho Nightingale }
212bf21cd93STycho Nightingale #endif
213bf21cd93STycho Nightingale
214bf21cd93STycho Nightingale static void
rxfifo_reset(struct uart_softc * sc,int size)2154c87aefeSPatrick Mooney rxfifo_reset(struct uart_softc *sc, int size)
216bf21cd93STycho Nightingale {
2174c87aefeSPatrick Mooney char flushbuf[32];
2184c87aefeSPatrick Mooney struct fifo *fifo;
2194c87aefeSPatrick Mooney ssize_t nread;
2204c87aefeSPatrick Mooney int error;
2214c87aefeSPatrick Mooney
2224c87aefeSPatrick Mooney fifo = &sc->rxfifo;
223bf21cd93STycho Nightingale bzero(fifo, sizeof(struct fifo));
224bf21cd93STycho Nightingale fifo->size = size;
2254c87aefeSPatrick Mooney
2264c87aefeSPatrick Mooney if (sc->tty.opened) {
2274c87aefeSPatrick Mooney /*
2284c87aefeSPatrick Mooney * Flush any unread input from the tty buffer.
2294c87aefeSPatrick Mooney */
2304c87aefeSPatrick Mooney while (1) {
2314c87aefeSPatrick Mooney nread = read(sc->tty.rfd, flushbuf, sizeof(flushbuf));
2324c87aefeSPatrick Mooney if (nread != sizeof(flushbuf))
2334c87aefeSPatrick Mooney break;
2344c87aefeSPatrick Mooney }
2354c87aefeSPatrick Mooney
2364c87aefeSPatrick Mooney /*
2374c87aefeSPatrick Mooney * Enable mevent to trigger when new characters are available
2384c87aefeSPatrick Mooney * on the tty fd.
2394c87aefeSPatrick Mooney */
2404c87aefeSPatrick Mooney error = mevent_enable(sc->mev);
2414c87aefeSPatrick Mooney assert(error == 0);
2424c87aefeSPatrick Mooney }
2434c87aefeSPatrick Mooney #ifndef __FreeBSD__
2444c87aefeSPatrick Mooney if (sc->sock && sc->usc_sock.clifd != -1) {
2454c87aefeSPatrick Mooney /* Flush any unread input from the socket buffer. */
2464c87aefeSPatrick Mooney do {
2474c87aefeSPatrick Mooney nread = read(sc->usc_sock.clifd, flushbuf,
2484c87aefeSPatrick Mooney sizeof (flushbuf));
2494c87aefeSPatrick Mooney } while (nread == sizeof (flushbuf));
2504c87aefeSPatrick Mooney
2514c87aefeSPatrick Mooney /* Enable mevent to trigger when new data available on sock */
2524c87aefeSPatrick Mooney error = mevent_enable(sc->mev);
2534c87aefeSPatrick Mooney assert(error == 0);
2544c87aefeSPatrick Mooney }
2554c87aefeSPatrick Mooney #endif /* __FreeBSD__ */
256bf21cd93STycho Nightingale }
257bf21cd93STycho Nightingale
258bf21cd93STycho Nightingale static int
rxfifo_available(struct uart_softc * sc)2594c87aefeSPatrick Mooney rxfifo_available(struct uart_softc *sc)
260bf21cd93STycho Nightingale {
2614c87aefeSPatrick Mooney struct fifo *fifo;
2624c87aefeSPatrick Mooney
2634c87aefeSPatrick Mooney fifo = &sc->rxfifo;
2644c87aefeSPatrick Mooney return (fifo->num < fifo->size);
2654c87aefeSPatrick Mooney }
2664c87aefeSPatrick Mooney
2674c87aefeSPatrick Mooney static int
rxfifo_putchar(struct uart_softc * sc,uint8_t ch)2684c87aefeSPatrick Mooney rxfifo_putchar(struct uart_softc *sc, uint8_t ch)
2694c87aefeSPatrick Mooney {
2704c87aefeSPatrick Mooney struct fifo *fifo;
2714c87aefeSPatrick Mooney int error;
2724c87aefeSPatrick Mooney
2734c87aefeSPatrick Mooney fifo = &sc->rxfifo;
274bf21cd93STycho Nightingale
275bf21cd93STycho Nightingale if (fifo->num < fifo->size) {
276bf21cd93STycho Nightingale fifo->buf[fifo->windex] = ch;
277bf21cd93STycho Nightingale fifo->windex = (fifo->windex + 1) % fifo->size;
278bf21cd93STycho Nightingale fifo->num++;
2794c87aefeSPatrick Mooney if (!rxfifo_available(sc)) {
2804c87aefeSPatrick Mooney if (sc->tty.opened) {
2814c87aefeSPatrick Mooney /*
2824c87aefeSPatrick Mooney * Disable mevent callback if the FIFO is full.
2834c87aefeSPatrick Mooney */
2844c87aefeSPatrick Mooney error = mevent_disable(sc->mev);
2854c87aefeSPatrick Mooney assert(error == 0);
2864c87aefeSPatrick Mooney }
2874c87aefeSPatrick Mooney #ifndef __FreeBSD__
2884c87aefeSPatrick Mooney if (sc->sock && sc->usc_sock.clifd != -1) {
2894c87aefeSPatrick Mooney /*
2904c87aefeSPatrick Mooney * Disable mevent callback if the FIFO is full.
2914c87aefeSPatrick Mooney */
2924c87aefeSPatrick Mooney error = mevent_disable(sc->mev);
2934c87aefeSPatrick Mooney assert(error == 0);
2944c87aefeSPatrick Mooney }
2954c87aefeSPatrick Mooney #endif /* __FreeBSD__ */
2964c87aefeSPatrick Mooney }
297bf21cd93STycho Nightingale return (0);
298bf21cd93STycho Nightingale } else
299bf21cd93STycho Nightingale return (-1);
300bf21cd93STycho Nightingale }
301bf21cd93STycho Nightingale
302bf21cd93STycho Nightingale static int
rxfifo_getchar(struct uart_softc * sc)3034c87aefeSPatrick Mooney rxfifo_getchar(struct uart_softc *sc)
304bf21cd93STycho Nightingale {
3054c87aefeSPatrick Mooney struct fifo *fifo;
3064c87aefeSPatrick Mooney int c, error, wasfull;
307bf21cd93STycho Nightingale
3084c87aefeSPatrick Mooney wasfull = 0;
3094c87aefeSPatrick Mooney fifo = &sc->rxfifo;
310bf21cd93STycho Nightingale if (fifo->num > 0) {
3114c87aefeSPatrick Mooney if (!rxfifo_available(sc))
3124c87aefeSPatrick Mooney wasfull = 1;
313bf21cd93STycho Nightingale c = fifo->buf[fifo->rindex];
314bf21cd93STycho Nightingale fifo->rindex = (fifo->rindex + 1) % fifo->size;
315bf21cd93STycho Nightingale fifo->num--;
3164c87aefeSPatrick Mooney if (wasfull) {
3174c87aefeSPatrick Mooney if (sc->tty.opened) {
3184c87aefeSPatrick Mooney error = mevent_enable(sc->mev);
3194c87aefeSPatrick Mooney assert(error == 0);
3204c87aefeSPatrick Mooney }
3214c87aefeSPatrick Mooney #ifndef __FreeBSD__
3224c87aefeSPatrick Mooney if (sc->sock && sc->usc_sock.clifd != -1) {
3234c87aefeSPatrick Mooney error = mevent_enable(sc->mev);
3244c87aefeSPatrick Mooney assert(error == 0);
3254c87aefeSPatrick Mooney }
3264c87aefeSPatrick Mooney #endif /* __FreeBSD__ */
3274c87aefeSPatrick Mooney }
328bf21cd93STycho Nightingale return (c);
329bf21cd93STycho Nightingale } else
330bf21cd93STycho Nightingale return (-1);
331bf21cd93STycho Nightingale }
332bf21cd93STycho Nightingale
333bf21cd93STycho Nightingale static int
rxfifo_numchars(struct uart_softc * sc)3344c87aefeSPatrick Mooney rxfifo_numchars(struct uart_softc *sc)
335bf21cd93STycho Nightingale {
3364c87aefeSPatrick Mooney struct fifo *fifo = &sc->rxfifo;
337bf21cd93STycho Nightingale
338bf21cd93STycho Nightingale return (fifo->num);
339bf21cd93STycho Nightingale }
340bf21cd93STycho Nightingale
341bf21cd93STycho Nightingale static void
uart_opentty(struct uart_softc * sc)342bf21cd93STycho Nightingale uart_opentty(struct uart_softc *sc)
343bf21cd93STycho Nightingale {
344bf21cd93STycho Nightingale
3454c87aefeSPatrick Mooney ttyopen(&sc->tty);
3464c87aefeSPatrick Mooney sc->mev = mevent_add(sc->tty.rfd, EVF_READ, uart_drain, sc);
3474c87aefeSPatrick Mooney assert(sc->mev != NULL);
3484c87aefeSPatrick Mooney }
349bf21cd93STycho Nightingale
3504c87aefeSPatrick Mooney static uint8_t
modem_status(uint8_t mcr)3514c87aefeSPatrick Mooney modem_status(uint8_t mcr)
3524c87aefeSPatrick Mooney {
3534c87aefeSPatrick Mooney uint8_t msr;
3544c87aefeSPatrick Mooney
3554c87aefeSPatrick Mooney if (mcr & MCR_LOOPBACK) {
3564c87aefeSPatrick Mooney /*
3574c87aefeSPatrick Mooney * In the loopback mode certain bits from the MCR are
3584c87aefeSPatrick Mooney * reflected back into MSR.
3594c87aefeSPatrick Mooney */
3604c87aefeSPatrick Mooney msr = 0;
3614c87aefeSPatrick Mooney if (mcr & MCR_RTS)
3624c87aefeSPatrick Mooney msr |= MSR_CTS;
3634c87aefeSPatrick Mooney if (mcr & MCR_DTR)
3644c87aefeSPatrick Mooney msr |= MSR_DSR;
3654c87aefeSPatrick Mooney if (mcr & MCR_OUT1)
3664c87aefeSPatrick Mooney msr |= MSR_RI;
3674c87aefeSPatrick Mooney if (mcr & MCR_OUT2)
3684c87aefeSPatrick Mooney msr |= MSR_DCD;
3694c87aefeSPatrick Mooney } else {
3704c87aefeSPatrick Mooney /*
3714c87aefeSPatrick Mooney * Always assert DCD and DSR so tty open doesn't block
3724c87aefeSPatrick Mooney * even if CLOCAL is turned off.
3734c87aefeSPatrick Mooney */
3744c87aefeSPatrick Mooney msr = MSR_DCD | MSR_DSR;
3754c87aefeSPatrick Mooney }
3764c87aefeSPatrick Mooney assert((msr & MSR_DELTA_MASK) == 0);
3774c87aefeSPatrick Mooney
3784c87aefeSPatrick Mooney return (msr);
379bf21cd93STycho Nightingale }
380bf21cd93STycho Nightingale
381bf21cd93STycho Nightingale /*
382bf21cd93STycho Nightingale * The IIR returns a prioritized interrupt reason:
383bf21cd93STycho Nightingale * - receive data available
384bf21cd93STycho Nightingale * - transmit holding register empty
385bf21cd93STycho Nightingale * - modem status change
386bf21cd93STycho Nightingale *
387bf21cd93STycho Nightingale * Return an interrupt reason if one is available.
388bf21cd93STycho Nightingale */
389bf21cd93STycho Nightingale static int
uart_intr_reason(struct uart_softc * sc)390bf21cd93STycho Nightingale uart_intr_reason(struct uart_softc *sc)
391bf21cd93STycho Nightingale {
392bf21cd93STycho Nightingale
393bf21cd93STycho Nightingale if ((sc->lsr & LSR_OE) != 0 && (sc->ier & IER_ERLS) != 0)
394bf21cd93STycho Nightingale return (IIR_RLS);
3954c87aefeSPatrick Mooney else if (rxfifo_numchars(sc) > 0 && (sc->ier & IER_ERXRDY) != 0)
396bf21cd93STycho Nightingale return (IIR_RXTOUT);
397bf21cd93STycho Nightingale else if (sc->thre_int_pending && (sc->ier & IER_ETXRDY) != 0)
398bf21cd93STycho Nightingale return (IIR_TXRDY);
399bf21cd93STycho Nightingale else if ((sc->msr & MSR_DELTA_MASK) != 0 && (sc->ier & IER_EMSC) != 0)
400bf21cd93STycho Nightingale return (IIR_MLSC);
401bf21cd93STycho Nightingale else
402bf21cd93STycho Nightingale return (IIR_NOPEND);
403bf21cd93STycho Nightingale }
404bf21cd93STycho Nightingale
405bf21cd93STycho Nightingale static void
uart_reset(struct uart_softc * sc)406bf21cd93STycho Nightingale uart_reset(struct uart_softc *sc)
407bf21cd93STycho Nightingale {
408bf21cd93STycho Nightingale uint16_t divisor;
409bf21cd93STycho Nightingale
410bf21cd93STycho Nightingale divisor = DEFAULT_RCLK / DEFAULT_BAUD / 16;
411bf21cd93STycho Nightingale sc->dll = divisor;
4124c87aefeSPatrick Mooney #ifndef __FreeBSD__
4134c87aefeSPatrick Mooney sc->dlh = 0;
4144c87aefeSPatrick Mooney #else
415bf21cd93STycho Nightingale sc->dlh = divisor >> 16;
4164c87aefeSPatrick Mooney #endif
4174c87aefeSPatrick Mooney sc->msr = modem_status(sc->mcr);
418bf21cd93STycho Nightingale
4194c87aefeSPatrick Mooney rxfifo_reset(sc, 1); /* no fifo until enabled by software */
420bf21cd93STycho Nightingale }
421bf21cd93STycho Nightingale
422bf21cd93STycho Nightingale /*
423bf21cd93STycho Nightingale * Toggle the COM port's intr pin depending on whether or not we have an
424bf21cd93STycho Nightingale * interrupt condition to report to the processor.
425bf21cd93STycho Nightingale */
426bf21cd93STycho Nightingale static void
uart_toggle_intr(struct uart_softc * sc)427bf21cd93STycho Nightingale uart_toggle_intr(struct uart_softc *sc)
428bf21cd93STycho Nightingale {
429bf21cd93STycho Nightingale uint8_t intr_reason;
430bf21cd93STycho Nightingale
431bf21cd93STycho Nightingale intr_reason = uart_intr_reason(sc);
432bf21cd93STycho Nightingale
433bf21cd93STycho Nightingale if (intr_reason == IIR_NOPEND)
434bf21cd93STycho Nightingale (*sc->intr_deassert)(sc->arg);
435bf21cd93STycho Nightingale else
436bf21cd93STycho Nightingale (*sc->intr_assert)(sc->arg);
437bf21cd93STycho Nightingale }
438bf21cd93STycho Nightingale
439bf21cd93STycho Nightingale static void
uart_drain(int fd,enum ev_type ev,void * arg)440bf21cd93STycho Nightingale uart_drain(int fd, enum ev_type ev, void *arg)
441bf21cd93STycho Nightingale {
442bf21cd93STycho Nightingale struct uart_softc *sc;
443bf21cd93STycho Nightingale int ch;
444bf21cd93STycho Nightingale
445bf21cd93STycho Nightingale sc = arg;
446bf21cd93STycho Nightingale
4474c87aefeSPatrick Mooney assert(fd == sc->tty.rfd);
448bf21cd93STycho Nightingale assert(ev == EVF_READ);
449bf21cd93STycho Nightingale
450bf21cd93STycho Nightingale /*
451bf21cd93STycho Nightingale * This routine is called in the context of the mevent thread
452bf21cd93STycho Nightingale * to take out the softc lock to protect against concurrent
453bf21cd93STycho Nightingale * access from a vCPU i/o exit
454bf21cd93STycho Nightingale */
455bf21cd93STycho Nightingale pthread_mutex_lock(&sc->mtx);
456bf21cd93STycho Nightingale
457bf21cd93STycho Nightingale if ((sc->mcr & MCR_LOOPBACK) != 0) {
4584c87aefeSPatrick Mooney (void) ttyread(&sc->tty);
459bf21cd93STycho Nightingale } else {
4604c87aefeSPatrick Mooney while (rxfifo_available(sc) &&
4614c87aefeSPatrick Mooney ((ch = ttyread(&sc->tty)) != -1)) {
4624c87aefeSPatrick Mooney rxfifo_putchar(sc, ch);
463bf21cd93STycho Nightingale }
464bf21cd93STycho Nightingale uart_toggle_intr(sc);
465bf21cd93STycho Nightingale }
466bf21cd93STycho Nightingale
467bf21cd93STycho Nightingale pthread_mutex_unlock(&sc->mtx);
468bf21cd93STycho Nightingale }
469bf21cd93STycho Nightingale
470bf21cd93STycho Nightingale void
uart_write(struct uart_softc * sc,int offset,uint8_t value)471bf21cd93STycho Nightingale uart_write(struct uart_softc *sc, int offset, uint8_t value)
472bf21cd93STycho Nightingale {
473bf21cd93STycho Nightingale int fifosz;
474bf21cd93STycho Nightingale uint8_t msr;
475bf21cd93STycho Nightingale
476bf21cd93STycho Nightingale pthread_mutex_lock(&sc->mtx);
477bf21cd93STycho Nightingale
478bf21cd93STycho Nightingale /*
479bf21cd93STycho Nightingale * Take care of the special case DLAB accesses first
480bf21cd93STycho Nightingale */
481bf21cd93STycho Nightingale if ((sc->lcr & LCR_DLAB) != 0) {
482bf21cd93STycho Nightingale if (offset == REG_DLL) {
483bf21cd93STycho Nightingale sc->dll = value;
484bf21cd93STycho Nightingale goto done;
485bf21cd93STycho Nightingale }
486bf21cd93STycho Nightingale
487bf21cd93STycho Nightingale if (offset == REG_DLH) {
488bf21cd93STycho Nightingale sc->dlh = value;
489bf21cd93STycho Nightingale goto done;
490bf21cd93STycho Nightingale }
491bf21cd93STycho Nightingale }
492bf21cd93STycho Nightingale
493bf21cd93STycho Nightingale switch (offset) {
494bf21cd93STycho Nightingale case REG_DATA:
495bf21cd93STycho Nightingale if (sc->mcr & MCR_LOOPBACK) {
4964c87aefeSPatrick Mooney if (rxfifo_putchar(sc, value) != 0)
497bf21cd93STycho Nightingale sc->lsr |= LSR_OE;
4984c87aefeSPatrick Mooney } else if (sc->tty.opened) {
4994c87aefeSPatrick Mooney ttywrite(&sc->tty, value);
500bf21cd93STycho Nightingale #ifndef __FreeBSD__
5014c87aefeSPatrick Mooney } else if (sc->sock) {
5024c87aefeSPatrick Mooney sockwrite(sc, value);
503bf21cd93STycho Nightingale #endif
504bf21cd93STycho Nightingale } /* else drop on floor */
505bf21cd93STycho Nightingale sc->thre_int_pending = true;
506bf21cd93STycho Nightingale break;
507bf21cd93STycho Nightingale case REG_IER:
5084c87aefeSPatrick Mooney /* Set pending when IER_ETXRDY is raised (edge-triggered). */
5094c87aefeSPatrick Mooney if ((sc->ier & IER_ETXRDY) == 0 && (value & IER_ETXRDY) != 0)
5104c87aefeSPatrick Mooney sc->thre_int_pending = true;
511bf21cd93STycho Nightingale /*
512bf21cd93STycho Nightingale * Apply mask so that bits 4-7 are 0
513bf21cd93STycho Nightingale * Also enables bits 0-3 only if they're 1
514bf21cd93STycho Nightingale */
515bf21cd93STycho Nightingale sc->ier = value & 0x0F;
516bf21cd93STycho Nightingale break;
517bf21cd93STycho Nightingale case REG_FCR:
518bf21cd93STycho Nightingale /*
519bf21cd93STycho Nightingale * When moving from FIFO and 16450 mode and vice versa,
520bf21cd93STycho Nightingale * the FIFO contents are reset.
521bf21cd93STycho Nightingale */
522bf21cd93STycho Nightingale if ((sc->fcr & FCR_ENABLE) ^ (value & FCR_ENABLE)) {
523bf21cd93STycho Nightingale fifosz = (value & FCR_ENABLE) ? FIFOSZ : 1;
5244c87aefeSPatrick Mooney rxfifo_reset(sc, fifosz);
525bf21cd93STycho Nightingale }
526bf21cd93STycho Nightingale
527bf21cd93STycho Nightingale /*
528bf21cd93STycho Nightingale * The FCR_ENABLE bit must be '1' for the programming
529bf21cd93STycho Nightingale * of other FCR bits to be effective.
530bf21cd93STycho Nightingale */
531bf21cd93STycho Nightingale if ((value & FCR_ENABLE) == 0) {
532bf21cd93STycho Nightingale sc->fcr = 0;
533bf21cd93STycho Nightingale } else {
534bf21cd93STycho Nightingale if ((value & FCR_RCV_RST) != 0)
5354c87aefeSPatrick Mooney rxfifo_reset(sc, FIFOSZ);
536bf21cd93STycho Nightingale
537bf21cd93STycho Nightingale sc->fcr = value &
538bf21cd93STycho Nightingale (FCR_ENABLE | FCR_DMA | FCR_RX_MASK);
539bf21cd93STycho Nightingale }
540bf21cd93STycho Nightingale break;
541bf21cd93STycho Nightingale case REG_LCR:
542bf21cd93STycho Nightingale sc->lcr = value;
543bf21cd93STycho Nightingale break;
544bf21cd93STycho Nightingale case REG_MCR:
545bf21cd93STycho Nightingale /* Apply mask so that bits 5-7 are 0 */
546bf21cd93STycho Nightingale sc->mcr = value & 0x1F;
5474c87aefeSPatrick Mooney msr = modem_status(sc->mcr);
548bf21cd93STycho Nightingale
549bf21cd93STycho Nightingale /*
550bf21cd93STycho Nightingale * Detect if there has been any change between the
551bf21cd93STycho Nightingale * previous and the new value of MSR. If there is
552bf21cd93STycho Nightingale * then assert the appropriate MSR delta bit.
553bf21cd93STycho Nightingale */
554bf21cd93STycho Nightingale if ((msr & MSR_CTS) ^ (sc->msr & MSR_CTS))
555bf21cd93STycho Nightingale sc->msr |= MSR_DCTS;
556bf21cd93STycho Nightingale if ((msr & MSR_DSR) ^ (sc->msr & MSR_DSR))
557bf21cd93STycho Nightingale sc->msr |= MSR_DDSR;
558bf21cd93STycho Nightingale if ((msr & MSR_DCD) ^ (sc->msr & MSR_DCD))
559bf21cd93STycho Nightingale sc->msr |= MSR_DDCD;
560bf21cd93STycho Nightingale if ((sc->msr & MSR_RI) != 0 && (msr & MSR_RI) == 0)
561bf21cd93STycho Nightingale sc->msr |= MSR_TERI;
562bf21cd93STycho Nightingale
563bf21cd93STycho Nightingale /*
564bf21cd93STycho Nightingale * Update the value of MSR while retaining the delta
565bf21cd93STycho Nightingale * bits.
566bf21cd93STycho Nightingale */
567bf21cd93STycho Nightingale sc->msr &= MSR_DELTA_MASK;
568bf21cd93STycho Nightingale sc->msr |= msr;
569bf21cd93STycho Nightingale break;
570bf21cd93STycho Nightingale case REG_LSR:
571bf21cd93STycho Nightingale /*
572bf21cd93STycho Nightingale * Line status register is not meant to be written to
573bf21cd93STycho Nightingale * during normal operation.
574bf21cd93STycho Nightingale */
575bf21cd93STycho Nightingale break;
576bf21cd93STycho Nightingale case REG_MSR:
577bf21cd93STycho Nightingale /*
578bf21cd93STycho Nightingale * As far as I can tell MSR is a read-only register.
579bf21cd93STycho Nightingale */
580bf21cd93STycho Nightingale break;
581bf21cd93STycho Nightingale case REG_SCR:
582bf21cd93STycho Nightingale sc->scr = value;
583bf21cd93STycho Nightingale break;
584bf21cd93STycho Nightingale default:
585bf21cd93STycho Nightingale break;
586bf21cd93STycho Nightingale }
587bf21cd93STycho Nightingale
588bf21cd93STycho Nightingale done:
589bf21cd93STycho Nightingale uart_toggle_intr(sc);
590bf21cd93STycho Nightingale pthread_mutex_unlock(&sc->mtx);
591bf21cd93STycho Nightingale }
592bf21cd93STycho Nightingale
593bf21cd93STycho Nightingale uint8_t
uart_read(struct uart_softc * sc,int offset)594bf21cd93STycho Nightingale uart_read(struct uart_softc *sc, int offset)
595bf21cd93STycho Nightingale {
596bf21cd93STycho Nightingale uint8_t iir, intr_reason, reg;
597bf21cd93STycho Nightingale
598bf21cd93STycho Nightingale pthread_mutex_lock(&sc->mtx);
599bf21cd93STycho Nightingale
600bf21cd93STycho Nightingale /*
601bf21cd93STycho Nightingale * Take care of the special case DLAB accesses first
602bf21cd93STycho Nightingale */
603bf21cd93STycho Nightingale if ((sc->lcr & LCR_DLAB) != 0) {
604bf21cd93STycho Nightingale if (offset == REG_DLL) {
605bf21cd93STycho Nightingale reg = sc->dll;
606bf21cd93STycho Nightingale goto done;
607bf21cd93STycho Nightingale }
608bf21cd93STycho Nightingale
609bf21cd93STycho Nightingale if (offset == REG_DLH) {
610bf21cd93STycho Nightingale reg = sc->dlh;
611bf21cd93STycho Nightingale goto done;
612bf21cd93STycho Nightingale }
613bf21cd93STycho Nightingale }
614bf21cd93STycho Nightingale
615bf21cd93STycho Nightingale switch (offset) {
616bf21cd93STycho Nightingale case REG_DATA:
6174c87aefeSPatrick Mooney reg = rxfifo_getchar(sc);
618bf21cd93STycho Nightingale break;
619bf21cd93STycho Nightingale case REG_IER:
620bf21cd93STycho Nightingale reg = sc->ier;
621bf21cd93STycho Nightingale break;
622bf21cd93STycho Nightingale case REG_IIR:
623bf21cd93STycho Nightingale iir = (sc->fcr & FCR_ENABLE) ? IIR_FIFO_MASK : 0;
624bf21cd93STycho Nightingale
625bf21cd93STycho Nightingale intr_reason = uart_intr_reason(sc);
626bf21cd93STycho Nightingale
627bf21cd93STycho Nightingale /*
628bf21cd93STycho Nightingale * Deal with side effects of reading the IIR register
629bf21cd93STycho Nightingale */
630bf21cd93STycho Nightingale if (intr_reason == IIR_TXRDY)
631bf21cd93STycho Nightingale sc->thre_int_pending = false;
632bf21cd93STycho Nightingale
633bf21cd93STycho Nightingale iir |= intr_reason;
634bf21cd93STycho Nightingale
635bf21cd93STycho Nightingale reg = iir;
636bf21cd93STycho Nightingale break;
637bf21cd93STycho Nightingale case REG_LCR:
638bf21cd93STycho Nightingale reg = sc->lcr;
639bf21cd93STycho Nightingale break;
640bf21cd93STycho Nightingale case REG_MCR:
641bf21cd93STycho Nightingale reg = sc->mcr;
642bf21cd93STycho Nightingale break;
643bf21cd93STycho Nightingale case REG_LSR:
644bf21cd93STycho Nightingale /* Transmitter is always ready for more data */
645bf21cd93STycho Nightingale sc->lsr |= LSR_TEMT | LSR_THRE;
646bf21cd93STycho Nightingale
647bf21cd93STycho Nightingale /* Check for new receive data */
6484c87aefeSPatrick Mooney if (rxfifo_numchars(sc) > 0)
649bf21cd93STycho Nightingale sc->lsr |= LSR_RXRDY;
650bf21cd93STycho Nightingale else
651bf21cd93STycho Nightingale sc->lsr &= ~LSR_RXRDY;
652bf21cd93STycho Nightingale
653bf21cd93STycho Nightingale reg = sc->lsr;
654bf21cd93STycho Nightingale
655bf21cd93STycho Nightingale /* The LSR_OE bit is cleared on LSR read */
656bf21cd93STycho Nightingale sc->lsr &= ~LSR_OE;
657bf21cd93STycho Nightingale break;
658bf21cd93STycho Nightingale case REG_MSR:
659bf21cd93STycho Nightingale /*
660bf21cd93STycho Nightingale * MSR delta bits are cleared on read
661bf21cd93STycho Nightingale */
662bf21cd93STycho Nightingale reg = sc->msr;
663bf21cd93STycho Nightingale sc->msr &= ~MSR_DELTA_MASK;
664bf21cd93STycho Nightingale break;
665bf21cd93STycho Nightingale case REG_SCR:
666bf21cd93STycho Nightingale reg = sc->scr;
667bf21cd93STycho Nightingale break;
668bf21cd93STycho Nightingale default:
669bf21cd93STycho Nightingale reg = 0xFF;
670bf21cd93STycho Nightingale break;
671bf21cd93STycho Nightingale }
672bf21cd93STycho Nightingale
673bf21cd93STycho Nightingale done:
674bf21cd93STycho Nightingale uart_toggle_intr(sc);
675bf21cd93STycho Nightingale pthread_mutex_unlock(&sc->mtx);
676bf21cd93STycho Nightingale
677bf21cd93STycho Nightingale return (reg);
678bf21cd93STycho Nightingale }
679bf21cd93STycho Nightingale
680bf21cd93STycho Nightingale #ifndef __FreeBSD__
681bf21cd93STycho Nightingale static void
uart_sock_drain(int fd,enum ev_type ev,void * arg)6824c87aefeSPatrick Mooney uart_sock_drain(int fd, enum ev_type ev, void *arg)
683bf21cd93STycho Nightingale {
6844c87aefeSPatrick Mooney struct uart_softc *sc = arg;
6854c87aefeSPatrick Mooney char ch;
686bf21cd93STycho Nightingale
687bf21cd93STycho Nightingale /*
6884c87aefeSPatrick Mooney * Take the softc lock to protect against concurrent
6894c87aefeSPatrick Mooney * access from a vCPU i/o exit
690bf21cd93STycho Nightingale */
6914c87aefeSPatrick Mooney pthread_mutex_lock(&sc->mtx);
692bf21cd93STycho Nightingale
6934c87aefeSPatrick Mooney if ((sc->mcr & MCR_LOOPBACK) != 0) {
6944c87aefeSPatrick Mooney (void) read(sc->usc_sock.clifd, &ch, 1);
6954c87aefeSPatrick Mooney } else {
6964c87aefeSPatrick Mooney bool err_close = false;
6974c87aefeSPatrick Mooney
6984c87aefeSPatrick Mooney while (rxfifo_available(sc)) {
699bf21cd93STycho Nightingale int res;
700bf21cd93STycho Nightingale
7014c87aefeSPatrick Mooney res = read(sc->usc_sock.clifd, &ch, 1);
7024c87aefeSPatrick Mooney if (res == 0) {
7034c87aefeSPatrick Mooney err_close = true;
7044c87aefeSPatrick Mooney break;
7054c87aefeSPatrick Mooney } else if (res == -1) {
7064c87aefeSPatrick Mooney if (errno != EAGAIN && errno != EINTR) {
7074c87aefeSPatrick Mooney err_close = true;
7084c87aefeSPatrick Mooney }
7094c87aefeSPatrick Mooney break;
710bf21cd93STycho Nightingale }
711bf21cd93STycho Nightingale
7124c87aefeSPatrick Mooney rxfifo_putchar(sc, ch);
7134c87aefeSPatrick Mooney }
7144c87aefeSPatrick Mooney uart_toggle_intr(sc);
7154c87aefeSPatrick Mooney
7164c87aefeSPatrick Mooney if (err_close) {
7174c87aefeSPatrick Mooney (void) fprintf(stderr, "uart: closing client conn\n");
7184c87aefeSPatrick Mooney (void) shutdown(sc->usc_sock.clifd, SHUT_RDWR);
7194c87aefeSPatrick Mooney mevent_delete_close(sc->mev);
7204c87aefeSPatrick Mooney sc->mev = NULL;
7214c87aefeSPatrick Mooney sc->usc_sock.clifd = -1;
7224c87aefeSPatrick Mooney }
7234c87aefeSPatrick Mooney }
7244c87aefeSPatrick Mooney
7254c87aefeSPatrick Mooney pthread_mutex_unlock(&sc->mtx);
726bf21cd93STycho Nightingale }
727bf21cd93STycho Nightingale
728bf21cd93STycho Nightingale static void
uart_sock_accept(int fd,enum ev_type ev,void * arg)7294c87aefeSPatrick Mooney uart_sock_accept(int fd, enum ev_type ev, void *arg)
730bf21cd93STycho Nightingale {
7314c87aefeSPatrick Mooney struct uart_softc *sc = arg;
7324c87aefeSPatrick Mooney int connfd;
733bf21cd93STycho Nightingale
7344c87aefeSPatrick Mooney connfd = accept(sc->usc_sock.servfd, NULL, NULL);
7354c87aefeSPatrick Mooney if (connfd == -1) {
736bf21cd93STycho Nightingale return;
737bf21cd93STycho Nightingale }
738bf21cd93STycho Nightingale
7394c87aefeSPatrick Mooney /*
7404c87aefeSPatrick Mooney * Do client connection management under protection of the softc lock
7414c87aefeSPatrick Mooney * to avoid racing with concurrent UART events.
7424c87aefeSPatrick Mooney */
7434c87aefeSPatrick Mooney pthread_mutex_lock(&sc->mtx);
744bf21cd93STycho Nightingale
7454c87aefeSPatrick Mooney if (sc->usc_sock.clifd != -1) {
7464c87aefeSPatrick Mooney /* we're already handling a client */
7474c87aefeSPatrick Mooney (void) fprintf(stderr, "uart: unexpected client conn\n");
7484c87aefeSPatrick Mooney (void) shutdown(connfd, SHUT_RDWR);
7494c87aefeSPatrick Mooney (void) close(connfd);
750bf21cd93STycho Nightingale } else {
7514c87aefeSPatrick Mooney if (fcntl(connfd, F_SETFL, O_NONBLOCK) < 0) {
7524c87aefeSPatrick Mooney perror("uart: fcntl(O_NONBLOCK)");
7534c87aefeSPatrick Mooney (void) shutdown(connfd, SHUT_RDWR);
7544c87aefeSPatrick Mooney (void) close(connfd);
755bf21cd93STycho Nightingale } else {
7564c87aefeSPatrick Mooney sc->usc_sock.clifd = connfd;
7574c87aefeSPatrick Mooney sc->mev = mevent_add(sc->usc_sock.clifd, EVF_READ,
7584c87aefeSPatrick Mooney uart_sock_drain, sc);
759bf21cd93STycho Nightingale }
760bf21cd93STycho Nightingale }
761bf21cd93STycho Nightingale
7624c87aefeSPatrick Mooney pthread_mutex_unlock(&sc->mtx);
763bf21cd93STycho Nightingale }
764bf21cd93STycho Nightingale
765bf21cd93STycho Nightingale static int
init_sock(const char * path)7664c87aefeSPatrick Mooney init_sock(const char *path)
767bf21cd93STycho Nightingale {
768bf21cd93STycho Nightingale int servfd;
769bf21cd93STycho Nightingale struct sockaddr_un servaddr;
770bf21cd93STycho Nightingale
7714c87aefeSPatrick Mooney bzero(&servaddr, sizeof (servaddr));
7724c87aefeSPatrick Mooney servaddr.sun_family = AF_UNIX;
7734c87aefeSPatrick Mooney
7744c87aefeSPatrick Mooney if (strlcpy(servaddr.sun_path, path, sizeof (servaddr.sun_path)) >=
7754c87aefeSPatrick Mooney sizeof (servaddr.sun_path)) {
7764c87aefeSPatrick Mooney (void) fprintf(stderr, "uart: path '%s' too long\n",
7774c87aefeSPatrick Mooney path);
778bf21cd93STycho Nightingale return (-1);
779bf21cd93STycho Nightingale }
780bf21cd93STycho Nightingale
781bf21cd93STycho Nightingale if ((servfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
7824c87aefeSPatrick Mooney (void) fprintf(stderr, "uart: socket() error - %s\n",
7834c87aefeSPatrick Mooney strerror(errno));
784bf21cd93STycho Nightingale return (-1);
785bf21cd93STycho Nightingale }
786bf21cd93STycho Nightingale (void) unlink(servaddr.sun_path);
787bf21cd93STycho Nightingale
788bf21cd93STycho Nightingale if (bind(servfd, (struct sockaddr *)&servaddr,
789bf21cd93STycho Nightingale sizeof (servaddr)) == -1) {
7904c87aefeSPatrick Mooney (void) fprintf(stderr, "uart: bind() error - %s\n",
7914c87aefeSPatrick Mooney strerror(errno));
792bf21cd93STycho Nightingale goto out;
793bf21cd93STycho Nightingale }
794bf21cd93STycho Nightingale
7954c87aefeSPatrick Mooney if (listen(servfd, 1) == -1) {
7964c87aefeSPatrick Mooney (void) fprintf(stderr, "uart: listen() error - %s\n",
7974c87aefeSPatrick Mooney strerror(errno));
798bf21cd93STycho Nightingale goto out;
799bf21cd93STycho Nightingale }
800bf21cd93STycho Nightingale return (servfd);
801bf21cd93STycho Nightingale
802bf21cd93STycho Nightingale out:
803bf21cd93STycho Nightingale (void) unlink(servaddr.sun_path);
804bf21cd93STycho Nightingale (void) close(servfd);
805bf21cd93STycho Nightingale return (-1);
806bf21cd93STycho Nightingale }
8074c87aefeSPatrick Mooney #endif /* not __FreeBSD__ */
808bf21cd93STycho Nightingale
809bf21cd93STycho Nightingale int
uart_legacy_alloc(int which,int * baseaddr,int * irq)810bf21cd93STycho Nightingale uart_legacy_alloc(int which, int *baseaddr, int *irq)
811bf21cd93STycho Nightingale {
812bf21cd93STycho Nightingale
81359d65d31SAndy Fiddaman if (which < 0 || which >= (int)UART_NLDEVS || uart_lres[which].inuse)
814bf21cd93STycho Nightingale return (-1);
815bf21cd93STycho Nightingale
816bf21cd93STycho Nightingale uart_lres[which].inuse = true;
817bf21cd93STycho Nightingale *baseaddr = uart_lres[which].baseaddr;
818bf21cd93STycho Nightingale *irq = uart_lres[which].irq;
819bf21cd93STycho Nightingale
820bf21cd93STycho Nightingale return (0);
821bf21cd93STycho Nightingale }
822bf21cd93STycho Nightingale
823bf21cd93STycho Nightingale struct uart_softc *
uart_init(uart_intr_func_t intr_assert,uart_intr_func_t intr_deassert,void * arg)824bf21cd93STycho Nightingale uart_init(uart_intr_func_t intr_assert, uart_intr_func_t intr_deassert,
825bf21cd93STycho Nightingale void *arg)
826bf21cd93STycho Nightingale {
827bf21cd93STycho Nightingale struct uart_softc *sc;
828bf21cd93STycho Nightingale
8294c87aefeSPatrick Mooney sc = calloc(1, sizeof(struct uart_softc));
830bf21cd93STycho Nightingale
831bf21cd93STycho Nightingale sc->arg = arg;
832bf21cd93STycho Nightingale sc->intr_assert = intr_assert;
833bf21cd93STycho Nightingale sc->intr_deassert = intr_deassert;
834bf21cd93STycho Nightingale
835bf21cd93STycho Nightingale pthread_mutex_init(&sc->mtx, NULL);
836bf21cd93STycho Nightingale
837bf21cd93STycho Nightingale uart_reset(sc);
838bf21cd93STycho Nightingale
839bf21cd93STycho Nightingale return (sc);
840bf21cd93STycho Nightingale }
841bf21cd93STycho Nightingale
8424c87aefeSPatrick Mooney #ifndef __FreeBSD__
8434c87aefeSPatrick Mooney static int
uart_sock_backend(struct uart_softc * sc,const char * inopts)8444c87aefeSPatrick Mooney uart_sock_backend(struct uart_softc *sc, const char *inopts)
8454c87aefeSPatrick Mooney {
846d7b72f7bSAndy Fiddaman char *opts, *tofree;
8474c87aefeSPatrick Mooney char *opt;
8484c87aefeSPatrick Mooney char *nextopt;
8494c87aefeSPatrick Mooney char *path = NULL;
8504c87aefeSPatrick Mooney
8514c87aefeSPatrick Mooney if (strncmp(inopts, "socket,", 7) != 0) {
8524c87aefeSPatrick Mooney return (-1);
8534c87aefeSPatrick Mooney }
8544c87aefeSPatrick Mooney if ((opts = strdup(inopts + 7)) == NULL) {
8554c87aefeSPatrick Mooney return (-1);
8564c87aefeSPatrick Mooney }
8574c87aefeSPatrick Mooney
858d7b72f7bSAndy Fiddaman tofree = nextopt = opts;
8594c87aefeSPatrick Mooney for (opt = strsep(&nextopt, ","); opt != NULL;
8604c87aefeSPatrick Mooney opt = strsep(&nextopt, ",")) {
8614c87aefeSPatrick Mooney if (path == NULL && *opt == '/') {
8624c87aefeSPatrick Mooney path = opt;
8634c87aefeSPatrick Mooney continue;
8644c87aefeSPatrick Mooney }
8654c87aefeSPatrick Mooney /*
8664c87aefeSPatrick Mooney * XXX check for server and client options here. For now,
8674c87aefeSPatrick Mooney * everything is a server
8684c87aefeSPatrick Mooney */
869d7b72f7bSAndy Fiddaman free(tofree);
8704c87aefeSPatrick Mooney return (-1);
8714c87aefeSPatrick Mooney }
8724c87aefeSPatrick Mooney
8734c87aefeSPatrick Mooney sc->usc_sock.clifd = -1;
8744c87aefeSPatrick Mooney if ((sc->usc_sock.servfd = init_sock(path)) == -1) {
875d7b72f7bSAndy Fiddaman free(tofree);
8764c87aefeSPatrick Mooney return (-1);
8774c87aefeSPatrick Mooney }
8784c87aefeSPatrick Mooney sc->sock = true;
8794c87aefeSPatrick Mooney sc->tty.rfd = sc->tty.wfd = -1;
8804c87aefeSPatrick Mooney sc->usc_sock.servmev = mevent_add(sc->usc_sock.servfd, EVF_READ,
8814c87aefeSPatrick Mooney uart_sock_accept, sc);
8824c87aefeSPatrick Mooney assert(sc->usc_sock.servmev != NULL);
8834c87aefeSPatrick Mooney
884d7b72f7bSAndy Fiddaman free(tofree);
8854c87aefeSPatrick Mooney return (0);
8864c87aefeSPatrick Mooney }
8874c87aefeSPatrick Mooney #endif /* not __FreeBSD__ */
8884c87aefeSPatrick Mooney
8894c87aefeSPatrick Mooney static int
uart_stdio_backend(struct uart_softc * sc)8904c87aefeSPatrick Mooney uart_stdio_backend(struct uart_softc *sc)
8914c87aefeSPatrick Mooney {
8924c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
8934c87aefeSPatrick Mooney cap_rights_t rights;
8944c87aefeSPatrick Mooney cap_ioctl_t cmds[] = { TIOCGETA, TIOCSETA, TIOCGWINSZ };
8954c87aefeSPatrick Mooney #endif
8964c87aefeSPatrick Mooney
8974c87aefeSPatrick Mooney if (uart_stdio)
8984c87aefeSPatrick Mooney return (-1);
8994c87aefeSPatrick Mooney
9004c87aefeSPatrick Mooney sc->tty.rfd = STDIN_FILENO;
9014c87aefeSPatrick Mooney sc->tty.wfd = STDOUT_FILENO;
9024c87aefeSPatrick Mooney sc->tty.opened = true;
9034c87aefeSPatrick Mooney
9044c87aefeSPatrick Mooney if (fcntl(sc->tty.rfd, F_SETFL, O_NONBLOCK) != 0)
9054c87aefeSPatrick Mooney return (-1);
9064c87aefeSPatrick Mooney if (fcntl(sc->tty.wfd, F_SETFL, O_NONBLOCK) != 0)
9074c87aefeSPatrick Mooney return (-1);
9084c87aefeSPatrick Mooney
9094c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
9104c87aefeSPatrick Mooney cap_rights_init(&rights, CAP_EVENT, CAP_IOCTL, CAP_READ);
9114c87aefeSPatrick Mooney if (caph_rights_limit(sc->tty.rfd, &rights) == -1)
9124c87aefeSPatrick Mooney errx(EX_OSERR, "Unable to apply rights for sandbox");
9134c87aefeSPatrick Mooney if (caph_ioctls_limit(sc->tty.rfd, cmds, nitems(cmds)) == -1)
9144c87aefeSPatrick Mooney errx(EX_OSERR, "Unable to apply rights for sandbox");
9154c87aefeSPatrick Mooney #endif
9164c87aefeSPatrick Mooney
9174c87aefeSPatrick Mooney uart_stdio = true;
9184c87aefeSPatrick Mooney
9194c87aefeSPatrick Mooney return (0);
9204c87aefeSPatrick Mooney }
9214c87aefeSPatrick Mooney
9224c87aefeSPatrick Mooney static int
uart_tty_backend(struct uart_softc * sc,const char * path)9232b948146SAndy Fiddaman uart_tty_backend(struct uart_softc *sc, const char *path)
9244c87aefeSPatrick Mooney {
9254c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
9264c87aefeSPatrick Mooney cap_rights_t rights;
9274c87aefeSPatrick Mooney cap_ioctl_t cmds[] = { TIOCGETA, TIOCSETA, TIOCGWINSZ };
9284c87aefeSPatrick Mooney #endif
9294c87aefeSPatrick Mooney int fd;
9304c87aefeSPatrick Mooney
9312b948146SAndy Fiddaman fd = open(path, O_RDWR | O_NONBLOCK);
93284659b24SMichael Zeller if (fd < 0)
9334c87aefeSPatrick Mooney return (-1);
9344c87aefeSPatrick Mooney
93584659b24SMichael Zeller if (!isatty(fd)) {
93684659b24SMichael Zeller close(fd);
93784659b24SMichael Zeller return (-1);
93884659b24SMichael Zeller }
93984659b24SMichael Zeller
9404c87aefeSPatrick Mooney sc->tty.rfd = sc->tty.wfd = fd;
9414c87aefeSPatrick Mooney sc->tty.opened = true;
9424c87aefeSPatrick Mooney
9434c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
9444c87aefeSPatrick Mooney cap_rights_init(&rights, CAP_EVENT, CAP_IOCTL, CAP_READ, CAP_WRITE);
9454c87aefeSPatrick Mooney if (caph_rights_limit(fd, &rights) == -1)
9464c87aefeSPatrick Mooney errx(EX_OSERR, "Unable to apply rights for sandbox");
9474c87aefeSPatrick Mooney if (caph_ioctls_limit(fd, cmds, nitems(cmds)) == -1)
9484c87aefeSPatrick Mooney errx(EX_OSERR, "Unable to apply rights for sandbox");
9494c87aefeSPatrick Mooney #endif
9504c87aefeSPatrick Mooney
9514c87aefeSPatrick Mooney return (0);
9524c87aefeSPatrick Mooney }
9534c87aefeSPatrick Mooney
954bf21cd93STycho Nightingale int
uart_set_backend(struct uart_softc * sc,const char * device)9552b948146SAndy Fiddaman uart_set_backend(struct uart_softc *sc, const char *device)
956bf21cd93STycho Nightingale {
9574c87aefeSPatrick Mooney int retval;
9584c87aefeSPatrick Mooney
9592b948146SAndy Fiddaman if (device == NULL)
960bf21cd93STycho Nightingale return (0);
961bf21cd93STycho Nightingale
9624c87aefeSPatrick Mooney #ifndef __FreeBSD__
9632b948146SAndy Fiddaman if (strncmp("socket,", device, 7) == 0)
9642b948146SAndy Fiddaman return (uart_sock_backend(sc, device));
965bf21cd93STycho Nightingale #endif
9662b948146SAndy Fiddaman if (strcmp("stdio", device) == 0)
9674c87aefeSPatrick Mooney retval = uart_stdio_backend(sc);
9684c87aefeSPatrick Mooney else
9692b948146SAndy Fiddaman retval = uart_tty_backend(sc, device);
9704c87aefeSPatrick Mooney if (retval == 0)
9714c87aefeSPatrick Mooney uart_opentty(sc);
9724c87aefeSPatrick Mooney
9734c87aefeSPatrick Mooney return (retval);
974bf21cd93STycho Nightingale }
975