sys/dev/nmdm/nmdm.c

   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$");
  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
  56 MALLOC_DEFINE(M_NLMDM, "nullmodem", "nullmodem data structures");
  57
  58 static d_close_t        nmdmclose;
  59 static t_modem_t        nmdmmodem;
  60 static d_open_t         nmdmopen;
  61 static t_oproc_t        nmdmoproc;
  62 static t_param_t        nmdmparam;
  63 static t_stop_t         nmdmstop;
  64
  65 static void     nmdminit(struct cdev *dev);
  66
  67
  68 static 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
  81 struct 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
  96 struct  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
 103 static struct clonedevs *nmdmclones;
 104 static TAILQ_HEAD(,nm_softc) nmdmhead = TAILQ_HEAD_INITIALIZER(nmdmhead);
 105
 106 static void
 107 nmdm_clone(void *arg, char *name, int nameen, struct cdev **dev)
 108 {
 109         int i, unit;
 110         char *p;
 111         struct cdev *d1, *d2;
 112
 113         if (*dev != NULL)
 114                 return;
 115         if (strcmp(name, "nmdm") == 0) {
 116                 p = NULL;
 117                 unit = -1;
 118         } else {
 119                 i = dev_stdclone(name, &p, "nmdm", &unit);
 120                 if (i == 0)
 121                         return;
 122                 if (p[0] != '\0' && p[0] != 'A' && p[0] != 'B')
 123                         return;
 124                 else if (p[0] != '\0' && p[1] != '\0')
 125                         return;
 126         }
 127         i = clone_create(&nmdmclones, &nmdm_cdevsw, &unit, &d1, 0);
 128         if (i) {
 129                 d1 = make_dev(&nmdm_cdevsw, unit2minor(unit),
 130                      0, 0, 0666, "nmdm%dA", unit);
 131                 if (d1 == NULL)
 132                         return;
 133                 d2 = make_dev(&nmdm_cdevsw, unit2minor(unit) | BFLAG,
 134                      0, 0, 0666, "nmdm%dB", unit);
 135                 if (d2 == NULL) {
 136                         destroy_dev(d1);
 137                         return;
 138                 }
 139                 d2->si_drv2 = d1;
 140                 d1->si_drv2 = d2;
 141                 dev_depends(d1, d2);
 142                 dev_depends(d2, d1);
 143                 d1->si_flags |= SI_CHEAPCLONE;
 144                 d2->si_flags |= SI_CHEAPCLONE;
 145         }
 146         if (p != NULL && p[0] == 'B')
 147                 *dev = d1->si_drv2;
 148         else
 149                 *dev = d1;
 150         dev_ref(*dev);
 151 }
 152
 153 static void
 154 nmdm_timeout(void *arg)
 155 {
 156         struct softpart *sp;
 157
 158         sp = arg;
 159
 160         if (sp->rate == 0)
 161                 return;
 162
 163         /*
 164          * Do a simple Floyd-Steinberg dither here to avoid FP math.
 165          * Wipe out unused quota from last tick.
 166          */
 167         sp->accumulator += sp->credits;
 168         sp->quota = sp->accumulator >> QS;
 169         sp->accumulator &= ((1 << QS) - 1);
 170
 171         taskqueue_enqueue(taskqueue_swi_giant, &sp->pt_task);
 172         callout_reset(&sp->co, sp->rate, nmdm_timeout, arg);
 173 }
 174
 175 static void
 176 nmdm_task_tty(void *arg, int pending __unused)
 177 {
 178         struct tty *tp, *otp;
 179         struct softpart *sp;
 180         int c;
 181
 182         tp = arg;
 183         sp = tp->t_sc;
 184         otp = sp->other->nm_tty;
 185         KASSERT(otp != NULL, ("NULL otp in nmdmstart"));
 186         KASSERT(otp != tp, ("NULL otp == tp nmdmstart"));
 187         if (sp->other->nm_dcd) {
 188                 if (!(tp->t_state & TS_ISOPEN)) {
 189                         sp->other->nm_dcd = 0;
 190                         (void)ttyld_modem(otp, 0);
 191                 }
 192         } else {
 193                 if (tp->t_state & TS_ISOPEN) {
 194                         sp->other->nm_dcd = 1;
 195                         (void)ttyld_modem(otp, 1);
 196                 }
 197         }
 198         if (tp->t_state & TS_TTSTOP)
 199                 return;
 200         while (tp->t_outq.c_cc != 0) {
 201                 if (sp->rate && !sp->quota)
 202                         return;
 203                 if (otp->t_state & TS_TBLOCK)
 204                         return;
 205                 sp->quota--;
 206                 c = getc(&tp->t_outq);
 207                 if (otp->t_state & TS_ISOPEN)
 208                         ttyld_rint(otp, c);
 209         }
 210         if (tp->t_outq.c_cc == 0)
 211                 ttwwakeup(tp);
 212
 213 }
 214
 215 /*
 216  * This function creates and initializes a pair of ttys.
 217  */
 218 static void
 219 nmdminit(struct cdev *dev1)
 220 {
 221         struct cdev *dev2;
 222         struct nm_softc *pt;
 223
 224         dev2 = dev1->si_drv2;
 225
 226         dev1->si_flags &= ~SI_CHEAPCLONE;
 227         dev2->si_flags &= ~SI_CHEAPCLONE;
 228
 229         pt = malloc(sizeof(*pt), M_NLMDM, M_WAITOK | M_ZERO);
 230         TAILQ_INSERT_TAIL(&nmdmhead, pt, pt_list);
 231
 232         dev1->si_drv1 = dev2->si_drv1 = pt;
 233
 234         pt->part1.dev = dev1;
 235         pt->part2.dev = dev2;
 236
 237         pt->part1.nm_tty = ttymalloc(pt->part1.nm_tty);
 238         pt->part1.nm_tty->t_oproc = nmdmoproc;
 239         pt->part1.nm_tty->t_stop = nmdmstop;
 240         pt->part1.nm_tty->t_modem = nmdmmodem;
 241         pt->part1.nm_tty->t_param = nmdmparam;
 242         pt->part1.nm_tty->t_dev = dev1;
 243         pt->part1.nm_tty->t_sc = &pt->part1;
 244         TASK_INIT(&pt->part1.pt_task, 0, nmdm_task_tty, pt->part1.nm_tty);
 245         callout_init(&pt->part1.co, 0);
 246
 247         pt->part2.nm_tty = ttymalloc(pt->part2.nm_tty);
 248         pt->part2.nm_tty->t_oproc = nmdmoproc;
 249         pt->part2.nm_tty->t_stop = nmdmstop;
 250         pt->part2.nm_tty->t_modem = nmdmmodem;
 251         pt->part2.nm_tty->t_param = nmdmparam;
 252         pt->part2.nm_tty->t_dev = dev2;
 253         pt->part2.nm_tty->t_sc = &pt->part2;
 254         TASK_INIT(&pt->part2.pt_task, 0, nmdm_task_tty, pt->part2.nm_tty);
 255         callout_init(&pt->part2.co, 0);
 256
 257         pt->part1.other = &pt->part2;
 258         pt->part2.other = &pt->part1;
 259
 260         dev1->si_tty = pt->part1.nm_tty;
 261         dev1->si_drv1 = pt;
 262
 263         dev2->si_tty = pt->part2.nm_tty;
 264         dev2->si_drv1 = pt;
 265 }
 266
 267 /*
 268  * Device opened from userland
 269  */
 270 static  int
 271 nmdmopen(struct cdev *dev, int flag, int devtype, struct thread *td)
 272 {
 273         struct tty *tp, *tp2;
 274         int error;
 275         struct nm_softc *pti;
 276         struct softpart *sp;
 277
 278         if (dev->si_drv1 == NULL)
 279                 nmdminit(dev);
 280         pti = dev->si_drv1;
 281         if (pti->pt_prison != td->td_ucred->cr_prison)
 282                 return (EBUSY);
 283
 284         tp = dev->si_tty;
 285         sp = tp->t_sc;
 286         tp2 = sp->other->nm_tty;
 287
 288         if ((tp->t_state & TS_ISOPEN) == 0) {
 289                 ttyinitmode(tp, 0, 0);
 290                 ttsetwater(tp); /* XXX ? */
 291         } else if (tp->t_state & TS_XCLUDE && suser(td)) {
 292                 return (EBUSY);
 293         }
 294
 295         error = ttyld_open(tp, dev);
 296         return (error);
 297 }
 298
 299 static int
 300 bits_per_char(struct termios *t)
 301 {
 302         int bits;
 303
 304         bits = 1;               /* start bit */
 305         switch (t->c_cflag & CSIZE) {
 306         case CS5:       bits += 5;      break;
 307         case CS6:       bits += 6;      break;
 308         case CS7:       bits += 7;      break;
 309         case CS8:       bits += 8;      break;
 310         }
 311         bits++;                 /* stop bit */
 312         if (t->c_cflag & PARENB)
 313                 bits++;
 314         if (t->c_cflag & CSTOPB)
 315                 bits++;
 316         return (bits);
 317 }
 318
 319 static int
 320 nmdmparam(struct tty *tp, struct termios *t)
 321 {
 322         struct softpart *sp;
 323         struct tty *tp2;
 324         int bpc, rate, speed, i;
 325
 326         sp = tp->t_sc;
 327         tp2 = sp->other->nm_tty;
 328
 329         if (!((t->c_cflag | tp2->t_cflag) & CDSR_OFLOW)) {
 330                 sp->rate = 0;
 331                 sp->other->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_ospeed, t->c_ispeed);
 347                 if (speed == 0) {
 348                         sp->rate = 0;
 349                         sp->other->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                 sp->credits = speed;
 363                 sp->rate = rate;
 364                 callout_reset(&sp->co, rate, nmdm_timeout, sp);
 365
 366                 /*
 367                  * swap pointers for second pass so the other end gets
 368                  * updated as well.
 369                  */
 370                 sp = sp->other;
 371                 t = &tp2->t_termios;
 372                 tp2 = tp;
 373         }
 374         return (0);
 375 }
 376
 377 static int
 378 nmdmmodem(struct tty *tp, int sigon, int sigoff)
 379 {
 380         struct softpart *sp;
 381         int i;
 382
 383         sp = tp->t_sc;
 384         if (sigon || sigoff) {
 385                 if (sigon & SER_DTR)
 386                         sp->other->nm_dcd = 1;
 387                 if (sigoff & SER_DTR)
 388                         sp->other->nm_dcd = 0;
 389                 ttyld_modem(sp->other->nm_tty, sp->other->nm_dcd);
 390                 return (0);
 391         } else {
 392                 i = 0;
 393                 if (sp->nm_dcd)
 394                         i |= SER_DCD;
 395                 if (sp->other->nm_dcd)
 396                         i |= SER_DTR;
 397                 return (i);
 398         }
 399 }
 400
 401 static int
 402 nmdmclose(struct cdev *dev, int flag, int mode, struct thread *td)
 403 {
 404
 405         return (tty_close(dev->si_tty));
 406 }
 407
 408 static void
 409 nmdmoproc(struct tty *tp)
 410 {
 411         struct softpart *pt;
 412
 413         pt = tp->t_sc;
 414         taskqueue_enqueue(taskqueue_swi_giant, &pt->pt_task);
 415 }
 416
 417 static void
 418 nmdmstop(struct tty *tp, int flush)
 419 {
 420         struct softpart *pt;
 421
 422         pt = tp->t_sc;
 423         taskqueue_enqueue(taskqueue_swi_giant, &pt->pt_task);
 424 }
 425
 426 /*
 427  * Module handling
 428  */
 429 static int
 430 nmdm_modevent(module_t mod, int type, void *data)
 431 {
 432         static eventhandler_tag tag;
 433         struct nm_softc *pt, *tpt;
 434         int error = 0;
 435
 436         switch(type) {
 437         case MOD_LOAD:
 438                 clone_setup(&nmdmclones);
 439                 tag = EVENTHANDLER_REGISTER(dev_clone, nmdm_clone, 0, 1000);
 440                 if (tag == NULL)
 441                         return (ENOMEM);
 442                 break;
 443
 444         case MOD_SHUTDOWN:
 445                 /* FALLTHROUGH */
 446         case MOD_UNLOAD:
 447                 EVENTHANDLER_DEREGISTER(dev_clone, tag);
 448                 TAILQ_FOREACH_SAFE(pt, &nmdmhead, pt_list, tpt) {
 449                         destroy_dev(pt->part1.dev);
 450                         TAILQ_REMOVE(&nmdmhead, pt, pt_list);
 451                         free(pt, M_NLMDM);
 452                 }
 453                 clone_cleanup(&nmdmclones);
 454                 break;
 455         default:
 456                 error = EOPNOTSUPP;
 457         }
 458         return (error);
 459 }
 460
 461 DEV_MODULE(nmdm, nmdm_modevent, NULL);