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
56 static MALLOC_DEFINE(M_NMDM, "nullmodem", "nullmodem data structures");
57
58 static tsw_inwakeup_t nmdm_outwakeup;
59 static tsw_outwakeup_t nmdm_inwakeup;
60 static tsw_param_t nmdm_param;
61 static tsw_modem_t nmdm_modem;
62 static tsw_close_t nmdm_close;
63 static tsw_free_t nmdm_free;
64
65 static 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
75 static void nmdm_task_tty(void *, int);
76
77 struct nmdmsoftc;
78
79 struct 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
94 struct nmdmsoftc {
95 struct nmdmpart ns_part1;
96 struct nmdmpart ns_part2;
97 struct mtx ns_mtx;
98 };
99
100 static int nmdm_count = 0;
101
102 static void
nmdm_close(struct tty * tp)103 nmdm_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
130 static void
nmdm_free(void * softc)131 nmdm_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
155 static void
nmdm_clone(void * arg,struct ucred * cred,char * name,int nameen,struct cdev ** dev)156 nmdm_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
229 static void
nmdm_timeout(void * arg)230 nmdm_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
249 static void
nmdm_task_tty(void * arg,int pending __unused)250 nmdm_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
298 static int
bits_per_char(struct termios * t)299 bits_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
318 static int
nmdm_param(struct tty * tp,struct termios * t)319 nmdm_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
376 static int
nmdm_modem(struct tty * tp,int sigon,int sigoff)377 nmdm_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
401 static void
nmdm_inwakeup(struct tty * tp)402 nmdm_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
410 static void
nmdm_outwakeup(struct tty * tp)411 nmdm_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 */
422 static int
nmdm_modevent(module_t mod,int type,void * data)423 nmdm_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
450 DEV_MODULE(nmdm, nmdm_modevent, NULL);
451