1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1982, 1986, 1989, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 */
32
33#include <sys/cdefs.h>
34/*
35 * Pseudo-nulmodem driver
36 * Mighty handy for use with serial console in Vmware
37 */
38
39#include <sys/param.h>
40#include <sys/systm.h>
41#include <sys/priv.h>
42#include <sys/proc.h>
43#include <sys/tty.h>
44#include <sys/conf.h>
45#include <sys/eventhandler.h>
46#include <sys/fcntl.h>
47#include <sys/poll.h>
48#include <sys/kernel.h>
49#include <sys/limits.h>
50#include <sys/module.h>
51#include <sys/serial.h>
52#include <sys/signalvar.h>
53#include <sys/malloc.h>
54#include <sys/taskqueue.h>
55
56static MALLOC_DEFINE(M_NMDM, "nullmodem", "nullmodem data structures");
57
58static tsw_inwakeup_t	nmdm_outwakeup;
59static tsw_outwakeup_t	nmdm_inwakeup;
60static tsw_param_t	nmdm_param;
61static tsw_modem_t	nmdm_modem;
62static tsw_close_t	nmdm_close;
63static tsw_free_t	nmdm_free;
64
65static struct ttydevsw nmdm_class = {
66	.tsw_flags	= TF_NOPREFIX,
67	.tsw_inwakeup	= nmdm_inwakeup,
68	.tsw_outwakeup	= nmdm_outwakeup,
69	.tsw_param	= nmdm_param,
70	.tsw_modem	= nmdm_modem,
71	.tsw_close	= nmdm_close,
72	.tsw_free	= nmdm_free,
73};
74
75static void nmdm_task_tty(void *, int);
76
77struct nmdmsoftc;
78
79struct nmdmpart {
80	struct tty		*np_tty;
81	int			 np_dcd;
82	struct task		 np_task;
83	struct nmdmpart		*np_other;
84	struct nmdmsoftc	*np_pair;
85	struct callout		 np_callout;
86	u_long			 np_quota;
87	u_long			 np_accumulator;
88	int			 np_rate;
89	int			 np_credits;
90
91#define QS 8	/* Quota shift */
92};
93
94struct nmdmsoftc {
95	struct nmdmpart	ns_part1;
96	struct nmdmpart	ns_part2;
97	struct mtx	ns_mtx;
98};
99
100static int nmdm_count = 0;
101
102static void
103nmdm_close(struct tty *tp)
104{
105	struct nmdmpart *np;
106	struct nmdmpart *onp;
107	struct tty *otp;
108
109	np = tty_softc(tp);
110	onp = np->np_other;
111	otp = onp->np_tty;
112
113	/* If second part is opened, do not destroy ourselves. */
114	if (tty_opened(otp))
115		return;
116
117	/* Shut down self. */
118	tty_rel_gone(tp);
119
120	/* Shut down second part. */
121	tty_lock(tp);
122	onp = np->np_other;
123	if (onp == NULL)
124		return;
125	otp = onp->np_tty;
126	tty_rel_gone(otp);
127	tty_lock(tp);
128}
129
130static void
131nmdm_free(void *softc)
132{
133	struct nmdmpart *np = (struct nmdmpart *)softc;
134	struct nmdmsoftc *ns = np->np_pair;
135
136	callout_drain(&np->np_callout);
137	taskqueue_drain(taskqueue_swi, &np->np_task);
138
139	/*
140	 * The function is called on both parts simultaneously.  We serialize
141	 * with help of ns_mtx.  The first invocation should return and
142	 * delegate freeing of resources to the second.
143	 */
144	mtx_lock(&ns->ns_mtx);
145	if (np->np_other != NULL) {
146		np->np_other->np_other = NULL;
147		mtx_unlock(&ns->ns_mtx);
148		return;
149	}
150	mtx_destroy(&ns->ns_mtx);
151	free(ns, M_NMDM);
152	atomic_subtract_int(&nmdm_count, 1);
153}
154
155static void
156nmdm_clone(void *arg, struct ucred *cred, char *name, int nameen,
157    struct cdev **dev)
158{
159	struct nmdmsoftc *ns;
160	struct tty *tp;
161	char *end;
162	int error;
163	char endc;
164
165	if (*dev != NULL)
166		return;
167	if (strncmp(name, "nmdm", 4) != 0)
168		return;
169	if (strlen(name) <= strlen("nmdmX"))
170		return;
171
172	/* Device name must be "nmdm%s%c", where %c is 'A' or 'B'. */
173	end = name + strlen(name) - 1;
174	endc = *end;
175	if (endc != 'A' && endc != 'B')
176		return;
177
178	ns = malloc(sizeof(*ns), M_NMDM, M_WAITOK | M_ZERO);
179	mtx_init(&ns->ns_mtx, "nmdm", NULL, MTX_DEF);
180
181	/* Hook the pairs together. */
182	ns->ns_part1.np_pair = ns;
183	ns->ns_part1.np_other = &ns->ns_part2;
184	TASK_INIT(&ns->ns_part1.np_task, 0, nmdm_task_tty, &ns->ns_part1);
185	callout_init_mtx(&ns->ns_part1.np_callout, &ns->ns_mtx, 0);
186
187	ns->ns_part2.np_pair = ns;
188	ns->ns_part2.np_other = &ns->ns_part1;
189	TASK_INIT(&ns->ns_part2.np_task, 0, nmdm_task_tty, &ns->ns_part2);
190	callout_init_mtx(&ns->ns_part2.np_callout, &ns->ns_mtx, 0);
191
192	/* Create device nodes. */
193	tp = ns->ns_part1.np_tty = tty_alloc_mutex(&nmdm_class, &ns->ns_part1,
194	    &ns->ns_mtx);
195	*end = 'A';
196	error = tty_makedevf(tp, cred, endc == 'A' ? TTYMK_CLONING : 0,
197	    "%s", name);
198	if (error) {
199		*end = endc;
200		mtx_destroy(&ns->ns_mtx);
201		free(ns, M_NMDM);
202		return;
203	}
204
205	tp = ns->ns_part2.np_tty = tty_alloc_mutex(&nmdm_class, &ns->ns_part2,
206	    &ns->ns_mtx);
207	*end = 'B';
208	error = tty_makedevf(tp, cred, endc == 'B' ? TTYMK_CLONING : 0,
209	    "%s", name);
210	if (error) {
211		*end = endc;
212		mtx_lock(&ns->ns_mtx);
213		/* see nmdm_free() */
214		ns->ns_part1.np_other = NULL;
215		atomic_add_int(&nmdm_count, 1);
216		tty_rel_gone(ns->ns_part1.np_tty);
217		return;
218	}
219
220	if (endc == 'A')
221		*dev = ns->ns_part1.np_tty->t_dev;
222	else
223		*dev = ns->ns_part2.np_tty->t_dev;
224
225	*end = endc;
226	atomic_add_int(&nmdm_count, 1);
227}
228
229static void
230nmdm_timeout(void *arg)
231{
232	struct nmdmpart *np = arg;
233
234	if (np->np_rate == 0)
235		return;
236
237	/*
238	 * Do a simple Floyd-Steinberg dither here to avoid FP math.
239	 * Wipe out unused quota from last tick.
240	 */
241	np->np_accumulator += np->np_credits;
242	np->np_quota = np->np_accumulator >> QS;
243	np->np_accumulator &= ((1 << QS) - 1);
244
245	taskqueue_enqueue(taskqueue_swi, &np->np_task);
246	callout_reset(&np->np_callout, np->np_rate, nmdm_timeout, np);
247}
248
249static void
250nmdm_task_tty(void *arg, int pending __unused)
251{
252	struct tty *tp, *otp;
253	struct nmdmpart *np = arg;
254	char c;
255
256	tp = np->np_tty;
257	tty_lock(tp);
258	if (tty_gone(tp)) {
259		tty_unlock(tp);
260		return;
261	}
262
263	otp = np->np_other->np_tty;
264	KASSERT(otp != NULL, ("NULL otp in nmdmstart"));
265	KASSERT(otp != tp, ("NULL otp == tp nmdmstart"));
266	if (np->np_other->np_dcd) {
267		if (!tty_opened(tp)) {
268			np->np_other->np_dcd = 0;
269			ttydisc_modem(otp, 0);
270		}
271	} else {
272		if (tty_opened(tp)) {
273			np->np_other->np_dcd = 1;
274			ttydisc_modem(otp, 1);
275		}
276	}
277
278	/* This may happen when we are in detach process. */
279	if (tty_gone(otp)) {
280		tty_unlock(otp);
281		return;
282	}
283
284	while (ttydisc_rint_poll(otp) > 0) {
285		if (np->np_rate && !np->np_quota)
286			break;
287		if (ttydisc_getc(tp, &c, 1) != 1)
288			break;
289		np->np_quota--;
290		ttydisc_rint(otp, c, 0);
291	}
292
293	ttydisc_rint_done(otp);
294
295	tty_unlock(tp);
296}
297
298static int
299bits_per_char(struct termios *t)
300{
301	int bits;
302
303	bits = 1;		/* start bit */
304	switch (t->c_cflag & CSIZE) {
305	case CS5:	bits += 5;	break;
306	case CS6:	bits += 6;	break;
307	case CS7:	bits += 7;	break;
308	case CS8:	bits += 8;	break;
309	}
310	bits++;			/* stop bit */
311	if (t->c_cflag & PARENB)
312		bits++;
313	if (t->c_cflag & CSTOPB)
314		bits++;
315	return (bits);
316}
317
318static int
319nmdm_param(struct tty *tp, struct termios *t)
320{
321	struct nmdmpart *np = tty_softc(tp);
322	struct tty *tp2;
323	int bpc, rate, speed, i;
324
325	tp2 = np->np_other->np_tty;
326
327	if (!((t->c_cflag | tp2->t_termios.c_cflag) & CDSR_OFLOW)) {
328		np->np_rate = 0;
329		np->np_other->np_rate = 0;
330		return (0);
331	}
332
333	/*
334	 * DSRFLOW one either side enables rate-simulation for both
335	 * directions.
336	 * NB: the two directions may run at different rates.
337	 */
338
339	/* Find the larger of the number of bits transmitted */
340	bpc = imax(bits_per_char(t), bits_per_char(&tp2->t_termios));
341
342	for (i = 0; i < 2; i++) {
343		/* Use the slower of our receive and their transmit rate */
344		speed = imin(tp2->t_termios.c_ospeed, t->c_ispeed);
345		if (speed == 0) {
346			np->np_rate = 0;
347			np->np_other->np_rate = 0;
348			return (0);
349		}
350
351		speed <<= QS;			/* [bit/sec, scaled] */
352		speed /= bpc;			/* [char/sec, scaled] */
353		rate = (hz << QS) / speed;	/* [hz per callout] */
354		if (rate == 0)
355			rate = 1;
356
357		speed *= rate;
358		speed /= hz;			/* [(char/sec)/tick, scaled */
359
360		np->np_credits = speed;
361		np->np_rate = rate;
362		callout_reset(&np->np_callout, rate, nmdm_timeout, np);
363
364		/*
365		 * swap pointers for second pass so the other end gets
366		 * updated as well.
367		 */
368		np = np->np_other;
369		t = &tp2->t_termios;
370		tp2 = tp;
371	}
372
373	return (0);
374}
375
376static int
377nmdm_modem(struct tty *tp, int sigon, int sigoff)
378{
379	struct nmdmpart *np = tty_softc(tp);
380	int i = 0;
381
382	if (sigon || sigoff) {
383		if (sigon & SER_DTR)
384			np->np_other->np_dcd = 1;
385		if (sigoff & SER_DTR)
386			np->np_other->np_dcd = 0;
387
388		ttydisc_modem(np->np_other->np_tty, np->np_other->np_dcd);
389
390		return (0);
391	} else {
392		if (np->np_dcd)
393			i |= SER_DCD;
394		if (np->np_other->np_dcd)
395			i |= SER_DTR;
396
397		return (i);
398	}
399}
400
401static void
402nmdm_inwakeup(struct tty *tp)
403{
404	struct nmdmpart *np = tty_softc(tp);
405
406	/* We can receive again, so wake up the other side. */
407	taskqueue_enqueue(taskqueue_swi, &np->np_other->np_task);
408}
409
410static void
411nmdm_outwakeup(struct tty *tp)
412{
413	struct nmdmpart *np = tty_softc(tp);
414
415	/* We can transmit again, so wake up our side. */
416	taskqueue_enqueue(taskqueue_swi, &np->np_task);
417}
418
419/*
420 * Module handling
421 */
422static int
423nmdm_modevent(module_t mod, int type, void *data)
424{
425	static eventhandler_tag tag;
426
427        switch(type) {
428        case MOD_LOAD:
429		tag = EVENTHANDLER_REGISTER(dev_clone, nmdm_clone, 0, 1000);
430		if (tag == NULL)
431			return (ENOMEM);
432		break;
433
434	case MOD_SHUTDOWN:
435		break;
436
437	case MOD_UNLOAD:
438		if (nmdm_count != 0)
439			return (EBUSY);
440		EVENTHANDLER_DEREGISTER(dev_clone, tag);
441		break;
442
443	default:
444		return (EOPNOTSUPP);
445	}
446
447	return (0);
448}
449
450DEV_MODULE(nmdm, nmdm_modevent, NULL);
451