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