nmdm.c revision 148868 
1/*-
2 * Copyright (c) 1982, 1986, 1989, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 */
30
31#include <sys/cdefs.h>
32__FBSDID("$FreeBSD: head/sys/dev/nmdm/nmdm.c 148868 2005-08-08 19:55:32Z rwatson $");
33
34/*
35 * Pseudo-nulmodem driver
36 * Mighty handy for use with serial console in Vmware
37 */
38
39#include "opt_compat.h"
40#include "opt_tty.h"
41
42#include <sys/param.h>
43#include <sys/systm.h>
44#include <sys/proc.h>
45#include <sys/tty.h>
46#include <sys/conf.h>
47#include <sys/fcntl.h>
48#include <sys/poll.h>
49#include <sys/kernel.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
56MALLOC_DEFINE(M_NLMDM, "nullmodem", "nullmodem data structures");
57
58static d_close_t	nmdmclose;
59static t_modem_t	nmdmmodem;
60static d_open_t		nmdmopen;
61static t_oproc_t	nmdmoproc;
62static t_param_t	nmdmparam;
63static t_stop_t		nmdmstop;
64
65static void 	nmdminit(struct cdev *dev);
66
67
68static struct cdevsw nmdm_cdevsw = {
69	.d_version =	D_VERSION,
70	.d_open =	nmdmopen,
71	.d_close =	nmdmclose,
72	.d_name =	"nmdn",
73	.d_flags =	D_TTY | D_PSEUDO | D_NEEDGIANT,
74};
75
76#define BUFSIZ 		100		/* Chunk size iomoved to/from user */
77#define NMDM_MAX_NUM	128		/* Artificially limit # devices. */
78#define	PF_STOPPED	0x10		/* user told stopped */
79#define BFLAG		CLONE_FLAG0
80
81struct softpart {
82	struct tty		*nm_tty;
83	struct cdev 		*dev;
84	int			nm_dcd;
85	struct task		pt_task;
86	struct softpart		*other;
87	struct callout		co;
88	u_long			quota;
89	u_long			accumulator;
90	int			rate;
91	int			credits;
92
93#define QS 8	/* Quota shift */
94};
95
96struct	nm_softc {
97	TAILQ_ENTRY(nm_softc)	pt_list;
98	int			pt_flags;
99	struct softpart 	part1, part2;
100	struct	prison 		*pt_prison;
101};
102
103static struct clonedevs *nmdmclones;
104static TAILQ_HEAD(,nm_softc) nmdmhead = TAILQ_HEAD_INITIALIZER(nmdmhead);
105
106static void
107nmdm_clone(void *arg, struct ucred *cred, char *name, int nameen,
108    struct cdev **dev)
109{
110	int i, unit;
111	char *p;
112	struct cdev *d1, *d2;
113
114	if (*dev != NULL)
115		return;
116	if (strcmp(name, "nmdm") == 0) {
117		p = NULL;
118		unit = -1;
119	} else {
120		i = dev_stdclone(name, &p, "nmdm", &unit);
121		if (i == 0)
122			return;
123		if (p[0] != '\0' && p[0] != 'A' && p[0] != 'B')
124			return;
125		else if (p[0] != '\0' && p[1] != '\0')
126			return;
127	}
128	i = clone_create(&nmdmclones, &nmdm_cdevsw, &unit, &d1, 0);
129	if (i) {
130		d1 = make_dev(&nmdm_cdevsw, unit2minor(unit),
131		     0, 0, 0666, "nmdm%dA", unit);
132		if (d1 == NULL)
133			return;
134		d2 = make_dev(&nmdm_cdevsw, unit2minor(unit) | BFLAG,
135		     0, 0, 0666, "nmdm%dB", unit);
136		if (d2 == NULL) {
137			destroy_dev(d1);
138			return;
139		}
140		d2->si_drv2 = d1;
141		d1->si_drv2 = d2;
142		dev_depends(d1, d2);
143		dev_depends(d2, d1);
144		d1->si_flags |= SI_CHEAPCLONE;
145		d2->si_flags |= SI_CHEAPCLONE;
146	}
147	if (p != NULL && p[0] == 'B')
148		*dev = d1->si_drv2;
149	else
150		*dev = d1;
151	dev_ref(*dev);
152}
153
154static void
155nmdm_timeout(void *arg)
156{
157	struct softpart *sp;
158
159	sp = arg;
160
161	if (sp->rate == 0)
162		return;
163
164	/*
165	 * Do a simple Floyd-Steinberg dither here to avoid FP math.
166	 * Wipe out unused quota from last tick.
167	 */
168	sp->accumulator += sp->credits;
169	sp->quota = sp->accumulator >> QS;
170	sp->accumulator &= ((1 << QS) - 1);
171
172	taskqueue_enqueue(taskqueue_swi_giant, &sp->pt_task);
173	callout_reset(&sp->co, sp->rate, nmdm_timeout, arg);
174}
175
176static void
177nmdm_task_tty(void *arg, int pending __unused)
178{
179	struct tty *tp, *otp;
180	struct softpart *sp;
181	int c;
182
183	tp = arg;
184	sp = tp->t_sc;
185	otp = sp->other->nm_tty;
186	KASSERT(otp != NULL, ("NULL otp in nmdmstart"));
187	KASSERT(otp != tp, ("NULL otp == tp nmdmstart"));
188	if (sp->other->nm_dcd) {
189		if (!(tp->t_state & TS_ISOPEN)) {
190			sp->other->nm_dcd = 0;
191			(void)ttyld_modem(otp, 0);
192		}
193	} else {
194		if (tp->t_state & TS_ISOPEN) {
195			sp->other->nm_dcd = 1;
196			(void)ttyld_modem(otp, 1);
197		}
198	}
199	if (tp->t_state & TS_TTSTOP)
200		return;
201	while (tp->t_outq.c_cc != 0) {
202		if (sp->rate && !sp->quota)
203			return;
204		if (otp->t_state & TS_TBLOCK)
205			return;
206		sp->quota--;
207		c = getc(&tp->t_outq);
208		if (otp->t_state & TS_ISOPEN)
209			ttyld_rint(otp, c);
210	}
211	if (tp->t_outq.c_cc == 0)
212		ttwwakeup(tp);
213
214}
215
216/*
217 * This function creates and initializes a pair of ttys.
218 */
219static void
220nmdminit(struct cdev *dev1)
221{
222	struct cdev *dev2;
223	struct nm_softc *pt;
224
225	dev2 = dev1->si_drv2;
226
227	dev1->si_flags &= ~SI_CHEAPCLONE;
228	dev2->si_flags &= ~SI_CHEAPCLONE;
229
230	pt = malloc(sizeof(*pt), M_NLMDM, M_WAITOK | M_ZERO);
231	TAILQ_INSERT_TAIL(&nmdmhead, pt, pt_list);
232
233	dev1->si_drv1 = dev2->si_drv1 = pt;
234
235	pt->part1.dev = dev1;
236	pt->part2.dev = dev2;
237
238	pt->part1.nm_tty = ttymalloc(pt->part1.nm_tty);
239	pt->part1.nm_tty->t_oproc = nmdmoproc;
240	pt->part1.nm_tty->t_stop = nmdmstop;
241	pt->part1.nm_tty->t_modem = nmdmmodem;
242	pt->part1.nm_tty->t_param = nmdmparam;
243	pt->part1.nm_tty->t_dev = dev1;
244	pt->part1.nm_tty->t_sc = &pt->part1;
245	TASK_INIT(&pt->part1.pt_task, 0, nmdm_task_tty, pt->part1.nm_tty);
246	callout_init(&pt->part1.co, 0);
247
248	pt->part2.nm_tty = ttymalloc(pt->part2.nm_tty);
249	pt->part2.nm_tty->t_oproc = nmdmoproc;
250	pt->part2.nm_tty->t_stop = nmdmstop;
251	pt->part2.nm_tty->t_modem = nmdmmodem;
252	pt->part2.nm_tty->t_param = nmdmparam;
253	pt->part2.nm_tty->t_dev = dev2;
254	pt->part2.nm_tty->t_sc = &pt->part2;
255	TASK_INIT(&pt->part2.pt_task, 0, nmdm_task_tty, pt->part2.nm_tty);
256	callout_init(&pt->part2.co, 0);
257
258	pt->part1.other = &pt->part2;
259	pt->part2.other = &pt->part1;
260
261	dev1->si_tty = pt->part1.nm_tty;
262	dev1->si_drv1 = pt;
263
264	dev2->si_tty = pt->part2.nm_tty;
265	dev2->si_drv1 = pt;
266}
267
268/*
269 * Device opened from userland
270 */
271static	int
272nmdmopen(struct cdev *dev, int flag, int devtype, struct thread *td)
273{
274	struct tty *tp, *tp2;
275	int error;
276	struct nm_softc *pti;
277	struct softpart *sp;
278
279	if (dev->si_drv1 == NULL)
280		nmdminit(dev);
281	pti = dev->si_drv1;
282	if (pti->pt_prison != td->td_ucred->cr_prison)
283		return (EBUSY);
284
285	tp = dev->si_tty;
286	sp = tp->t_sc;
287	tp2 = sp->other->nm_tty;
288
289	if ((tp->t_state & TS_ISOPEN) == 0) {
290		ttyinitmode(tp, 0, 0);
291		ttsetwater(tp); /* XXX ? */
292	} else if (tp->t_state & TS_XCLUDE && suser(td)) {
293		return (EBUSY);
294	}
295
296	error = ttyld_open(tp, dev);
297	return (error);
298}
299
300static int
301bits_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
320static int
321nmdmparam(struct tty *tp, struct termios *t)
322{
323	struct softpart *sp;
324	struct tty *tp2;
325	int bpc, rate, speed, i;
326
327	sp = tp->t_sc;
328	tp2 = sp->other->nm_tty;
329
330	if (!((t->c_cflag | tp2->t_cflag) & CDSR_OFLOW)) {
331		sp->rate = 0;
332		sp->other->rate = 0;
333		return (0);
334	}
335
336	/*
337	 * DSRFLOW one either side enables rate-simulation for both
338	 * directions.
339	 * NB: the two directions may run at different rates.
340	 */
341
342	/* Find the larger of the number of bits transmitted */
343	bpc = imax(bits_per_char(t), bits_per_char(&tp2->t_termios));
344
345	for (i = 0; i < 2; i++) {
346		/* Use the slower of our receive and their transmit rate */
347		speed = imin(tp2->t_ospeed, t->c_ispeed);
348		if (speed == 0) {
349			sp->rate = 0;
350			sp->other->rate = 0;
351			return (0);
352		}
353
354		speed <<= QS;			/* [bit/sec, scaled] */
355		speed /= bpc;			/* [char/sec, scaled] */
356		rate = (hz << QS) / speed;	/* [hz per callout] */
357		if (rate == 0)
358			rate = 1;
359
360		speed *= rate;
361		speed /= hz;			/* [(char/sec)/tick, scaled */
362
363		sp->credits = speed;
364		sp->rate = rate;
365		callout_reset(&sp->co, rate, nmdm_timeout, sp);
366
367		/*
368		 * swap pointers for second pass so the other end gets
369		 * updated as well.
370		 */
371		sp = sp->other;
372		t = &tp2->t_termios;
373		tp2 = tp;
374	}
375	return (0);
376}
377
378static int
379nmdmmodem(struct tty *tp, int sigon, int sigoff)
380{
381	struct softpart *sp;
382	int i;
383
384	sp = tp->t_sc;
385	if (sigon || sigoff) {
386		if (sigon & SER_DTR)
387			sp->other->nm_dcd = 1;
388		if (sigoff & SER_DTR)
389			sp->other->nm_dcd = 0;
390		ttyld_modem(sp->other->nm_tty, sp->other->nm_dcd);
391		return (0);
392	} else {
393		i = 0;
394		if (sp->nm_dcd)
395			i |= SER_DCD;
396		if (sp->other->nm_dcd)
397			i |= SER_DTR;
398		return (i);
399	}
400}
401
402static int
403nmdmclose(struct cdev *dev, int flag, int mode, struct thread *td)
404{
405
406	return (tty_close(dev->si_tty));
407}
408
409static void
410nmdmoproc(struct tty *tp)
411{
412	struct softpart *pt;
413
414	pt = tp->t_sc;
415	taskqueue_enqueue(taskqueue_swi_giant, &pt->pt_task);
416}
417
418static void
419nmdmstop(struct tty *tp, int flush)
420{
421	struct softpart *pt;
422
423	pt = tp->t_sc;
424	taskqueue_enqueue(taskqueue_swi_giant, &pt->pt_task);
425}
426
427/*
428 * Module handling
429 */
430static int
431nmdm_modevent(module_t mod, int type, void *data)
432{
433	static eventhandler_tag tag;
434	struct nm_softc *pt, *tpt;
435        int error = 0;
436
437        switch(type) {
438        case MOD_LOAD:
439		clone_setup(&nmdmclones);
440		tag = EVENTHANDLER_REGISTER(dev_clone, nmdm_clone, 0, 1000);
441		if (tag == NULL)
442			return (ENOMEM);
443		break;
444
445	case MOD_SHUTDOWN:
446		/* FALLTHROUGH */
447	case MOD_UNLOAD:
448		EVENTHANDLER_DEREGISTER(dev_clone, tag);
449		TAILQ_FOREACH_SAFE(pt, &nmdmhead, pt_list, tpt) {
450			destroy_dev(pt->part1.dev);
451			TAILQ_REMOVE(&nmdmhead, pt, pt_list);
452			free(pt, M_NLMDM);
453		}
454		clone_cleanup(&nmdmclones);
455		break;
456	default:
457		error = EOPNOTSUPP;
458	}
459	return (error);
460}
461
462DEV_MODULE(nmdm, nmdm_modevent, NULL);
463