sys/dev/serial/dgb/dgm.c

   1 /*-
   2  * $FreeBSD: src/sys/dev/dgb/dgm.c,v 1.31.2.3 2001/10/07 09:02:25 brian Exp $
   3  * $DragonFly: src/sys/dev/serial/dgb/dgm.c,v 1.16 2006/12/22 23:26:24 swildner Exp $
   4  *
   5  *  This driver and the associated header files support the ISA PC/Xem
   6  *  Digiboards.  Its evolutionary roots are described below.
   7  *  Jack O'Neill <jack@diamond.xtalwind.net>
   8  *
   9  *  Digiboard driver.
  10  *
  11  *  Stage 1. "Better than nothing".
  12  *  Stage 2. "Gee, it works!".
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions, and the following disclaimer,
  19  *    without modification, immediately at the beginning of the file.
  20  * 2. Redistributions of binary code must retain the above copyright
  21  *    notice, this list of conditions, and the following disclaimer,
  22  *    without modification, in the accompanying documentation.
  23  * 3. The name of the author may not be used to endorse or promote products
  24  *    derived from this software without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  30  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  *
  38  *  Written by Sergey Babkin,
  39  *      Joint Stock Commercial Bank "Chelindbank"
  40  *      (Chelyabinsk, Russia)
  41  *      babkin@freebsd.org
  42  *
  43  *  Assorted hacks to make it more functional and working under 3.0-current.
  44  *  Fixed broken routines to prevent processes hanging on closed (thanks
  45  *  to Bruce for his patience and assistance). Thanks also to Maxim Bolotin
  46  *  <max@run.net> for his patches which did most of the work to get this
  47  *  running under 2.2/3.0-current.
  48  *  Implemented ioctls: TIOCMSDTRWAIT, TIOCMGDTRWAIT, TIOCTIMESTAMP &
  49  *  TIOCDCDTIMESTAMP.
  50  *  Sysctl debug flag is now a bitflag, to filter noise during debugging.
  51  *      David L. Nugent <davidn@blaze.net.au>
  52  *
  53  * New-busification by Brian Somers <brian@Awfulhak.org>
  54  *
  55  * There was a copyright confusion: I thought that having read the
  56  * GLPed drivers makes me mentally contaminated but in fact it does
  57  * not. Since the Linux driver by Troy De Jongh <troyd@digibd.com> or
  58  * <troyd@skypoint.com> was used only to learn the Digi's interface,
  59  * I've returned this driver to a BSD-style license. I tried to contact
  60  * all the contributors and those who replied agreed with license
  61  * change. If you did any contribution when the driver was GPLed and do
  62  * not agree with the BSD-style re-licensing please contact me.
  63  *  -SB
  64  */
  65
  66 /* How often to run dgmpoll */
  67 #define POLLSPERSEC 25
  68
  69 /* How many charactes can we write to input tty rawq */
  70 #define DGB_IBUFSIZE (TTYHOG - 100)
  71
  72 /* the overall number of ports controlled by this driver */
  73
  74 #include <sys/param.h>
  75
  76 #include <sys/systm.h>
  77 #include <sys/proc.h>
  78 #include <sys/conf.h>
  79 #include <sys/dkstat.h>
  80 #include <sys/fcntl.h>
  81 #include <sys/kernel.h>
  82 #include <sys/sysctl.h>
  83 #include <sys/malloc.h>
  84 #include <sys/sysctl.h>
  85 #include <sys/tty.h>
  86 #include <sys/bus.h>
  87 #include <sys/kobj.h>
  88 #include <sys/bus.h>
  89 #include <sys/rman.h>
  90 #include <sys/thread2.h>
  91
  92 #include <machine/clock.h>
  93
  94 #include <vm/vm.h>
  95 #include <vm/pmap.h>
  96
  97 #include "dgmfep.h"
  98 #include "dgmbios.h"
  99 #include "dgmreg.h"
 100
 101 #define CALLOUT_MASK            0x40000
 102 #define CONTROL_MASK            0xC0
 103 #define CONTROL_INIT_STATE      0x40
 104 #define CONTROL_LOCK_STATE      0x80
 105 #define UNIT_MASK               0x30000
 106 #define PORT_MASK               0x3F
 107 #define DEV_TO_UNIT(dev)        (MINOR_TO_UNIT(minor(dev)))
 108 #define MINOR_MAGIC_MASK        (CALLOUT_MASK | CONTROL_MASK)
 109 #define MINOR_TO_UNIT(mynor)    (((mynor) & UNIT_MASK) >> 16)
 110 #define MINOR_TO_PORT(mynor)    ((mynor) & PORT_MASK)
 111 #define IO_SIZE                 0x04
 112 #define MEM_SIZE                0x8000
 113
 114 #define DGM_UNITMASK            0x30000
 115 #define DGM_UNIT(unit)          ((unit) << 16)
 116
 117 struct dgm_softc;
 118
 119 /* digiboard port structure */
 120 struct dgm_p {
 121         unsigned enabled : 1;
 122
 123         struct dgm_softc *sc;  /* parent softc */
 124         u_char pnum;           /* port number */
 125         u_char omodem;         /* FEP output modem status     */
 126         u_char imodem;         /* FEP input modem status      */
 127         u_char modemfake;      /* Modem values to be forced   */
 128         u_char modem;          /* Force values                */
 129         u_char hflow;
 130         u_char dsr;
 131         u_char dcd;
 132         u_char stopc;
 133         u_char startc;
 134         u_char stopca;
 135         u_char startca;
 136         u_char fepstopc;
 137         u_char fepstartc;
 138         u_char fepstopca;
 139         u_char fepstartca;
 140         u_char txwin;
 141         u_char rxwin;
 142         ushort fepiflag;
 143         ushort fepcflag;
 144         ushort fepoflag;
 145         ushort txbufhead;
 146         ushort txbufsize;
 147         ushort rxbufhead;
 148         ushort rxbufsize;
 149         int close_delay;
 150         u_char *txptr;
 151         u_char *rxptr;
 152         volatile struct board_chan *brdchan;
 153         struct tty *tty;
 154
 155         u_char  active_out;     /* nonzero if the callout device is open */
 156         u_int   wopeners;       /* # processes waiting for DCD in open() */
 157
 158         /* Initial state. */
 159         struct termios  it_in;  /* should be in struct tty */
 160         struct termios  it_out;
 161
 162         /* Lock state. */
 163         struct termios  lt_in;  /* should be in struct tty */
 164         struct termios  lt_out;
 165
 166         unsigned do_timestamp : 1;
 167         unsigned do_dcd_timestamp : 1;
 168         struct timeval  timestamp;
 169         struct timeval  dcd_timestamp;
 170
 171         /* flags of state, are used in sleep() too */
 172         u_char closing; /* port is being closed now */
 173         u_char draining; /* port is being drained now */
 174         u_char used;    /* port is being used now */
 175         u_char mustdrain; /* data must be waited to drain in dgmparam() */
 176
 177         struct callout  hc_timeout;
 178         struct callout  wf_timeout;
 179 };
 180
 181 /* Digiboard per-board structure */
 182 struct dgm_softc {
 183         /* struct board_info */
 184         unsigned enabled : 1;
 185         u_char unit;                    /* unit number */
 186         u_char type;                    /* type of card: PCXE, PCXI, PCXEVE */
 187         u_char altpin;                  /* do we need alternate pin setting ? */
 188         int numports;                   /* number of ports on card */
 189         u_long port;                    /* I/O port */
 190         u_char *vmem;                   /* virtual memory address */
 191         u_long pmem;                    /* physical memory address */
 192         int mem_seg;                    /* internal memory segment */
 193         struct dgm_p *ports;            /* ptr to array of port descriptors */
 194         struct tty *ttys;               /* ptr to array of TTY structures */
 195         volatile struct global_data *mailbox;
 196         struct resource *io_res;
 197         struct resource *mem_res;
 198         int iorid;
 199         int mrid;
 200         struct callout  toh;            /* poll timeout handle */
 201 };
 202
 203 static void     dgmpoll(void *);
 204 static int      dgmprobe(device_t);
 205 static int      dgmattach(device_t);
 206 static int      dgmdetach(device_t);
 207 static int      dgmshutdown(device_t);
 208 static void     fepcmd(struct dgm_p *, unsigned, unsigned, unsigned, unsigned,
 209                     unsigned);
 210 static void     dgmstart(struct tty *);
 211 static void     dgmstop(struct tty *, int);
 212 static int      dgmparam(struct tty *, struct termios *);
 213 static void     dgmhardclose(struct dgm_p *);
 214 static void     dgm_drain_or_flush(struct dgm_p *);
 215 static int      dgmdrain(struct dgm_p *);
 216 static void     dgm_pause(void *);
 217 static void     wakeflush(void *);
 218 static void     disc_optim(struct tty *, struct termios *);
 219
 220 static  d_open_t        dgmopen;
 221 static  d_close_t       dgmclose;
 222 static  d_ioctl_t       dgmioctl;
 223
 224 static device_method_t dgmmethods[] = {
 225         /* Device interface */
 226         DEVMETHOD(device_probe, dgmprobe),
 227         DEVMETHOD(device_attach, dgmattach),
 228         DEVMETHOD(device_detach, dgmdetach),
 229         DEVMETHOD(device_shutdown, dgmshutdown),
 230         { 0, 0 }
 231 };
 232
 233 static driver_t dgmdriver = {
 234         "dgm",
 235         dgmmethods,
 236         sizeof (struct dgm_softc),
 237 };
 238
 239 static devclass_t dgmdevclass;
 240
 241 #define CDEV_MAJOR      101
 242 static struct dev_ops dgm_ops = {
 243         { "dgm", CDEV_MAJOR, D_TTY | D_KQFILTER },
 244         .d_open =       dgmopen,
 245         .d_close =      dgmclose,
 246         .d_read =       ttyread,
 247         .d_write =      ttywrite,
 248         .d_ioctl =      dgmioctl,
 249         .d_poll =       ttypoll,
 250         .d_kqfilter =   ttykqfilter
 251 };
 252
 253 static int
 254 dgmmodhandler(module_t mod, int event, void *arg)
 255 {
 256         int res = 0;
 257
 258         switch (event) {
 259         case MOD_LOAD:
 260                 break;
 261         case MOD_UNLOAD:
 262                 break;
 263         }
 264
 265         return res;
 266 }
 267
 268 DRIVER_MODULE(dgm, isa, dgmdriver, dgmdevclass, dgmmodhandler, 0);
 269
 270 static  speed_t dgmdefaultrate = TTYDEF_SPEED;
 271
 272 static  struct speedtab dgmspeedtab[] = {
 273         { 0,            FEP_B0 }, /* old (sysV-like) Bx codes */
 274         { 50,           FEP_B50 },
 275         { 75,           FEP_B75 },
 276         { 110,          FEP_B110 },
 277         { 134,          FEP_B134 },
 278         { 150,          FEP_B150 },
 279         { 200,          FEP_B200 },
 280         { 300,          FEP_B300 },
 281         { 600,          FEP_B600 },
 282         { 1200,         FEP_B1200 },
 283         { 1800,         FEP_B1800 },
 284         { 2400,         FEP_B2400 },
 285         { 4800,         FEP_B4800 },
 286         { 9600,         FEP_B9600 },
 287         { 19200,        FEP_B19200 },
 288         { 38400,        FEP_B38400 },
 289         { 57600,        (FEP_FASTBAUD|FEP_B50) }, /* B50 & fast baud table */
 290         { 115200,       (FEP_FASTBAUD|FEP_B110) }, /* B100 & fast baud table */
 291         { -1,   -1 }
 292 };
 293
 294 static struct dbgflagtbl {
 295         tcflag_t in_mask;
 296         tcflag_t in_val;
 297         tcflag_t out_val;
 298 } dgm_cflags[] = {
 299         { PARODD,   PARODD,     FEP_PARODD  },
 300         { PARENB,   PARENB,     FEP_PARENB  },
 301         { CSTOPB,   CSTOPB,     FEP_CSTOPB  },
 302         { CSIZE,    CS5,        FEP_CS6     },
 303         { CSIZE,    CS6,        FEP_CS6     },
 304         { CSIZE,    CS7,        FEP_CS7     },
 305         { CSIZE,    CS8,        FEP_CS8     },
 306         { CLOCAL,   CLOCAL,     FEP_CLOCAL  },
 307         { (tcflag_t)-1 }
 308 }, dgm_iflags[] = {
 309         { IGNBRK,   IGNBRK,     FEP_IGNBRK  },
 310         { BRKINT,   BRKINT,     FEP_BRKINT  },
 311         { IGNPAR,   IGNPAR,     FEP_IGNPAR  },
 312         { PARMRK,   PARMRK,     FEP_PARMRK  },
 313         { INPCK,    INPCK,      FEP_INPCK   },
 314         { ISTRIP,   ISTRIP,     FEP_ISTRIP  },
 315         { IXON,     IXON,       FEP_IXON    },
 316         { IXOFF,    IXOFF,      FEP_IXOFF   },
 317         { IXANY,    IXANY,      FEP_IXANY   },
 318         { (tcflag_t)-1 }
 319 }, dgm_flow[] = {
 320         { CRTSCTS,  CRTSCTS,    CTS|RTS },
 321         { CRTSCTS,  CCTS_OFLOW, CTS     },
 322         { CRTSCTS,  CRTS_IFLOW, RTS     },
 323         { (tcflag_t)-1 }
 324 };
 325
 326 /* xlat bsd termios flags to dgm sys-v style */
 327 static tcflag_t
 328 dgmflags(struct dbgflagtbl *tbl, tcflag_t input)
 329 {
 330         tcflag_t output = 0;
 331         int i;
 332
 333         for (i = 0; tbl[i].in_mask != (tcflag_t)-1; i++)
 334                 if ((input & tbl[i].in_mask) == tbl[i].in_val)
 335                         output |= tbl[i].out_val;
 336
 337         return output;
 338 }
 339
 340 static int dgmdebug = 0;
 341 SYSCTL_INT(_debug, OID_AUTO, dgm_debug, CTLFLAG_RW, &dgmdebug, 0, "");
 342
 343 static __inline int setwin(struct dgm_softc *, unsigned);
 344 static __inline void hidewin(struct dgm_softc *);
 345 static __inline void towin(struct dgm_softc *, int);
 346
 347 /*Helg: to allow recursive dgm...() calls */
 348 typedef struct {
 349         /* If we were called and don't want to disturb we need: */
 350         int port;       /* write to this port */
 351         u_char data;    /* this data on exit */
 352         /* or DATA_WINOFF  to close memory window on entry */
 353 } BoardMemWinState;     /* so several channels and even boards can coexist */
 354
 355 #define DATA_WINOFF 0
 356 static BoardMemWinState bmws;
 357
 358 static u_long validio[] = { 0x104, 0x114, 0x124, 0x204, 0x224, 0x304, 0x324 };
 359 static u_long validmem[] = {
 360         0x80000, 0x88000, 0x90000, 0x98000, 0xa0000, 0xa8000, 0xb0000, 0xb8000,
 361         0xc0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000, 0xe8000, 0xf0000, 0xf8000,
 362         0xf0000000, 0xf1000000, 0xf2000000, 0xf3000000, 0xf4000000, 0xf5000000,
 363         0xf6000000, 0xf7000000, 0xf8000000, 0xf9000000, 0xfa000000, 0xfb000000,
 364         0xfc000000, 0xfd000000, 0xfe000000, 0xff000000
 365 };
 366
 367 /* return current memory window state and close window */
 368 static BoardMemWinState
 369 bmws_get(void)
 370 {
 371         BoardMemWinState bmwsRet = bmws;
 372
 373         if (bmws.data != DATA_WINOFF)
 374                 outb(bmws.port, bmws.data = DATA_WINOFF);
 375         return bmwsRet;
 376 }
 377
 378 /* restore memory window state */
 379 static void
 380 bmws_set(BoardMemWinState ws)
 381 {
 382         if (ws.data != bmws.data || ws.port != bmws.port) {
 383                 if (bmws.data != DATA_WINOFF)
 384                         outb(bmws.port, DATA_WINOFF);
 385                 if (ws.data != DATA_WINOFF)
 386                         outb(ws.port, ws.data);
 387                 bmws = ws;
 388         }
 389 }
 390
 391 static __inline int
 392 setwin(struct dgm_softc *sc, unsigned int addr)
 393 {
 394         outb(bmws.port = sc->port + 1, bmws.data = FEPWIN|(addr >> 15));
 395         return (addr & 0x7FFF);
 396 }
 397
 398 static __inline void
 399 hidewin(struct dgm_softc *sc)
 400 {
 401         bmws.data = 0;
 402         outb(bmws.port = sc->port + 1, bmws.data);
 403 }
 404
 405 static __inline void
 406 towin(struct dgm_softc *sc, int win)
 407 {
 408         outb(bmws.port = sc->port + 1, bmws.data = win);
 409 }
 410
 411 static int
 412 dgmprobe(device_t dev)
 413 {
 414         struct dgm_softc *sc = device_get_softc(dev);
 415         int i, v;
 416
 417         /*
 418          * Assign unit number.  Due to bits we use in the minor number for
 419          * the various tty types, only 4 units are supported.
 420          */
 421         sc->unit = device_get_unit(dev);
 422         if (sc->unit > 3) {
 423                 device_printf(dev, "Too many units, only 4 supported\n");
 424                 return(ENXIO);
 425         }
 426
 427         /* Check that we've got a valid i/o address */
 428         if ((sc->port = bus_get_resource_start(dev, SYS_RES_IOPORT, 0)) == 0)
 429                 return (ENXIO);
 430         for (i = sizeof (validio) / sizeof (validio[0]) - 1; i >= 0; i--)
 431                 if (sc->port == validio[i])
 432                         break;
 433         if (i == -1) {
 434                 device_printf(dev, "0x%03lx: Invalid i/o address\n", sc->port);
 435                 return (ENXIO);
 436         }
 437
 438         /* Ditto for our memory address */
 439         if ((sc->pmem = bus_get_resource_start(dev, SYS_RES_MEMORY, 0)) == 0)
 440                 return (ENXIO);
 441         for (i = sizeof (validmem) / sizeof (validmem[0]) - 1; i >= 0; i--)
 442                 if (sc->pmem == validmem[i])
 443                         break;
 444         if (i == -1) {
 445                 device_printf(dev, "0x%lx: Invalid memory address\n", sc->pmem);
 446                 return (ENXIO);
 447         }
 448         if ((sc->pmem & 0xFFFFFFul) != sc->pmem) {
 449                 device_printf(dev, "0x%lx: Memory address not supported\n",
 450                     sc->pmem);
 451                 return (ENXIO);
 452         }
 453         sc->vmem = (u_char *)sc->pmem;
 454
 455         DPRINT4(DB_INFO, "dgm%d: port 0x%lx mem 0x%lx\n", sc->unit,
 456             sc->port, sc->pmem);
 457
 458         /* Temporarily map our io ports */
 459         sc->iorid = 0;
 460         sc->io_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->iorid,
 461             0ul, ~0ul, IO_SIZE, RF_ACTIVE);
 462         if (sc->io_res == NULL)
 463                 return (ENXIO);
 464
 465         outb(sc->port, FEPRST);
 466         sc->enabled = 0;
 467
 468         for (i = 0; i < 1000; i++) {
 469                 DELAY(1);
 470                 if ((inb(sc->port) & FEPMASK) == FEPRST) {
 471                         sc->enabled = 1;
 472                         DPRINT3(DB_EXCEPT, "dgm%d: got reset after %d us\n",
 473                             sc->unit, i);
 474                         break;
 475                 }
 476         }
 477
 478         if (!sc->enabled) {
 479                 DPRINT2(DB_EXCEPT, "dgm%d: failed to respond\n", sc->unit);
 480                 bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 481                 return (ENXIO);
 482         }
 483
 484         /* check type of card and get internal memory characteristics */
 485
 486         v = inb(sc->port);
 487
 488         if (!(v & 0x1)) {
 489                 int second;
 490
 491                 outb(sc->port, 1);
 492                 second = inb(sc->port);
 493                 kprintf("dgm%d: PC/Xem (type %d, %d)\n", sc->unit, v, second);
 494         } else
 495                 kprintf("dgm%d: PC/Xem (type %d)\n", sc->unit, v);
 496
 497         sc->type = PCXEM;
 498         sc->mem_seg = 0x8000;
 499
 500         /* Temporarily map our memory too */
 501         sc->mrid = 0;
 502         sc->mem_res = bus_alloc_resource(dev, SYS_RES_MEMORY, &sc->mrid,
 503             0ul, ~0ul, MEM_SIZE, RF_ALLOCATED);
 504         if (sc->mem_res == NULL) {
 505                 device_printf(dev, "0x%lx: Memory range is in use\n", sc->pmem);
 506                 bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 507                 return (ENXIO);
 508         }
 509
 510         outb(sc->port, FEPCLR); /* drop RESET */
 511         hidewin(sc);    /* Helg: to set initial bmws state */
 512
 513         bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 514         bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 515
 516         bus_set_resource(dev, SYS_RES_IOPORT, 0, sc->port, IO_SIZE);
 517         bus_set_resource(dev, SYS_RES_MEMORY, 0, sc->pmem, MEM_SIZE);
 518
 519         DPRINT2(DB_INFO, "dgm%d: Probe returns 0\n", sc->unit);
 520
 521         return (0);
 522 }
 523
 524 static int
 525 dgmattach(device_t dev)
 526 {
 527         struct dgm_softc *sc = device_get_softc(dev);
 528         int i, t;
 529         u_char *mem;
 530         u_char *ptr;
 531         int addr;
 532         struct dgm_p *port;
 533         volatile struct board_chan *bc;
 534         int shrinkmem;
 535         int lowwater;
 536         u_long msize, iosize;
 537
 538         DPRINT2(DB_INFO, "dbg%d: attaching\n", device_get_unit(dev));
 539
 540         callout_init(&sc->toh);
 541         sc->unit = device_get_unit(dev);
 542         bus_get_resource(dev, SYS_RES_IOPORT, 0, &sc->port, &iosize);
 543         bus_get_resource(dev, SYS_RES_MEMORY, 0, &sc->pmem, &msize);
 544         sc->altpin = !!(device_get_flags(dev) & DGBFLAG_ALTPIN);
 545         sc->type = PCXEM;
 546         sc->mem_seg = 0x8000;
 547         sc->enabled = 1;
 548         sc->type = PCXEM;
 549         sc->mem_seg = 0x8000;
 550
 551         /* Allocate resources (should have been verified in dgmprobe()) */
 552         sc->iorid = 0;
 553         sc->io_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->iorid,
 554             0ul, ~0ul, iosize, RF_ACTIVE);
 555         if (sc->io_res == NULL)
 556                 return (ENXIO);
 557         sc->mrid = 0;
 558         sc->mem_res = bus_alloc_resource(dev, SYS_RES_MEMORY, &sc->mrid,
 559             0ul, ~0ul, msize, RF_ACTIVE);
 560         if (sc->mem_res == NULL) {
 561                 device_printf(dev, "0x%lx: Memory range is in use\n", sc->pmem);
 562                 bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 563                 return (ENXIO);
 564         }
 565
 566         /* map memory */
 567         mem = sc->vmem = pmap_mapdev(sc->pmem, msize);
 568
 569         DPRINT3(DB_INFO, "dgm%d: internal memory segment 0x%x\n", sc->unit,
 570             sc->mem_seg);
 571
 572         outb(sc->port, FEPRST);
 573         DELAY(1);
 574
 575         for (i = 0; (inb(sc->port) & FEPMASK) != FEPRST; i++) {
 576                 if (i > 10000) {
 577                         device_printf(dev, "1st reset failed\n");
 578                         sc->enabled = 0;
 579                         hidewin(sc);
 580                         bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 581                         bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 582                         return (ENXIO);
 583                 }
 584                 DELAY(1);
 585         }
 586
 587         DPRINT3(DB_INFO, "dgm%d: got reset after %d us\n", sc->unit, i);
 588
 589         t = sc->pmem >> 8;      /* disable windowing */
 590         outb(sc->port + 2, t & 0xFF);
 591         outb(sc->port + 3, t >> 8);
 592
 593         mem = sc->vmem;
 594
 595         /* very short memory test */
 596         DPRINT2(DB_INFO, "dbg%d: short memory test\n", sc->unit);
 597
 598         addr = setwin(sc, BOTWIN);
 599         *(u_long *)(mem + addr) = 0xA55A3CC3;
 600         if (*(u_long *)(mem + addr) != 0xA55A3CC3) {
 601                 device_printf(dev, "1st memory test failed\n");
 602                 sc->enabled = 0;
 603                 hidewin(sc);
 604                 bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 605                 bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 606                 return (ENXIO);
 607         }
 608
 609         DPRINT2(DB_INFO, "dbg%d: 1st memory test ok\n", sc->unit);
 610
 611         addr = setwin(sc, TOPWIN);
 612         *(u_long *)(mem + addr) = 0x5AA5C33C;
 613         if (*(u_long *)(mem + addr) != 0x5AA5C33C) {
 614                 device_printf(dev, "2nd memory test failed\n");
 615                 sc->enabled = 0;
 616                 hidewin(sc);
 617                 bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 618                 bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 619                 return (ENXIO);
 620         }
 621
 622         DPRINT2(DB_INFO, "dbg%d: 2nd memory test ok\n", sc->unit);
 623
 624         addr = setwin(sc, BIOSCODE + ((0xF000 - sc->mem_seg) << 4));
 625         *(u_long *)(mem + addr) = 0x5AA5C33C;
 626         if (*(u_long *)(mem + addr) != 0x5AA5C33C)
 627                 device_printf(dev, "3rd (BIOS) memory test failed\n");
 628
 629         DPRINT2(DB_INFO, "dbg%d: 3rd memory test ok\n", sc->unit);
 630
 631         addr = setwin(sc, MISCGLOBAL);
 632         for (i = 0; i < 16; i++)
 633                 mem[addr + i] = 0;
 634
 635         addr = setwin(sc, BIOSOFFSET);
 636         ptr = mem + addr;
 637         for (i = 0; ptr < mem + msize; i++)
 638                 *ptr++ = pcem_bios[i];
 639
 640         ptr = mem + BIOSOFFSET;
 641         for (i = 0; ptr < mem + msize; i++) {
 642                 if (*ptr++ != pcem_bios[i]) {
 643                         kprintf("Low BIOS load failed\n");
 644                         sc->enabled = 0;
 645                         hidewin(sc);
 646                         bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 647                         bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 648                         return (ENXIO);
 649                 }
 650         }
 651         DPRINT2(DB_INFO, "dbg%d: pcem_bios seg 1 loaded\n", sc->unit);
 652
 653         addr = setwin(sc, msize);
 654         ptr = mem + addr;
 655         for (;i < pcem_nbios; i++)
 656                 *ptr++ = pcem_bios[i];
 657
 658         ptr = mem;
 659         for (i = msize - BIOSOFFSET; i < pcem_nbios; i++) {
 660                 if (*ptr++ != pcem_bios[i]) {
 661                         kprintf("High BIOS load failed\n");
 662                         sc->enabled = 0;
 663                         hidewin(sc);
 664                         bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 665                         bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 666                         return (ENXIO);
 667                 }
 668         }
 669         DPRINT2(DB_INFO, "dbg%d: pcem_bios seg 2 loaded\n", sc->unit);
 670         device_printf(dev, "DigiBIOS loaded, initializing");
 671
 672         addr = setwin(sc, 0);
 673
 674         *(u_int *)(mem + addr) = 0x0bf00401;
 675         *(u_int *)(mem + addr + 4) = 0;
 676         *(ushort *)(mem + addr + 0xc00) = 0;
 677         outb(sc->port, 0);
 678
 679         for (i = 0; *(u_char *)(mem + addr + 0xc00) != 0x47; i++) {
 680                 DELAY(10000);
 681                 if (i > 3000) {
 682                         kprintf("\nBIOS initialize failed(1)\n");
 683                         sc->enabled = 0;
 684                         hidewin(sc);
 685                         bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 686                         bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 687                         return (ENXIO);
 688                 }
 689         }
 690
 691         if (*(u_char *)(mem + addr + 0xc01) != 0x44) {
 692                 kprintf("\nBIOS initialize failed(2)\n");
 693                 sc->enabled = 0;
 694                 hidewin(sc);
 695                 bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 696                 bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 697                 return (ENXIO);
 698         }
 699         kprintf(", DigiBIOS running\n");
 700
 701         DELAY(10000);
 702
 703         addr = setwin(sc, BIOSOFFSET);
 704         ptr = mem + addr;
 705         for (i = 0; i < pcem_ncook; i++)
 706                 *ptr++ = pcem_cook[i];
 707
 708         ptr = mem + BIOSOFFSET;
 709         for (i = 0; i < pcem_ncook; i++) {
 710                 if (*ptr++ != pcem_cook[i]) {
 711                         kprintf("FEP/OS load failed\n");
 712                         sc->enabled = 0;
 713                         hidewin(sc);
 714                         bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 715                         bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 716                         return (ENXIO);
 717                 }
 718         }
 719         device_printf(dev, "FEP/OS loaded, initializing");
 720
 721         addr = setwin(sc, 0);
 722         *(ushort *)(mem + addr + 0xd20) = 0;
 723         *(u_int *)(mem + addr + 0xc34) = 0xbfc01004;
 724         *(u_int *)(mem + addr + 0xc30) = 0x3L;
 725         outb(sc->port, 0);
 726
 727         for (i = 0; *(u_char *)(mem + addr + 0xd20) != 'O'; i++) {
 728                 DELAY(10000);
 729                 if (i > 3000) {
 730                         kprintf("\nFEP/OS initialize failed(1)\n");
 731                         sc->enabled = 0;
 732                         hidewin(sc);
 733                         bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 734                         bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 735                         return (ENXIO);
 736                 }
 737         }
 738
 739         if (*(u_char *)(mem + addr + 0xd21) != 'S') {
 740                 kprintf("\nFEP/OS initialize failed(2)\n");
 741                 sc->enabled = 0;
 742                 hidewin(sc);
 743                 bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 744                 bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 745                 return (ENXIO);
 746         }
 747         kprintf(", FEP/OS running\n");
 748
 749         sc->numports = *(ushort *)(mem + setwin(sc, NPORT));
 750         device_printf(dev, "%d ports attached\n", sc->numports);
 751
 752         if (sc->numports > MAX_DGM_PORTS) {
 753                 kprintf("dgm%d: too many ports\n", sc->unit);
 754                 sc->enabled = 0;
 755                 hidewin(sc);
 756                 bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 757                 bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 758                 return (ENXIO);
 759         }
 760
 761         MALLOC(sc->ports, struct dgm_p *, sizeof (*sc->ports) * sc->numports,
 762             M_TTYS, M_WAITOK|M_ZERO);
 763         MALLOC(sc->ttys, struct tty *, sizeof (*sc->ttys) * sc->numports,
 764             M_TTYS, M_WAITOK|M_ZERO);
 765
 766         DPRINT3(DB_INFO, "dgm%d: enable %d ports\n", sc->unit, sc->numports);
 767         for (i = 0; i < sc->numports; i++) {
 768                 sc->ports[i].enabled = 1;
 769                 callout_init(&sc->ports[i].hc_timeout);
 770                 callout_init(&sc->ports[i].wf_timeout);
 771         }
 772
 773         /* We should now init per-port structures */
 774         setwin(sc, 0);
 775         bc = (volatile struct board_chan *)(mem + CHANSTRUCT);
 776         sc->mailbox = (volatile struct global_data *)(mem + FEP_GLOBAL);
 777
 778         if (sc->numports < 3)
 779                 shrinkmem = 1;
 780         else
 781                 shrinkmem = 0;
 782
 783         dev_ops_add(&dgm_ops, DGM_UNITMASK, DGM_UNIT(sc->unit));
 784         for (i = 0; i < sc->numports; i++, bc++) {
 785                 DPRINT3(DB_INFO, "dgm%d: Set up port %d\n", sc->unit, i);
 786                 port = &sc->ports[i];
 787                 port->sc = sc;
 788
 789                 port->tty = &sc->ttys[i];
 790
 791                 port->brdchan = bc;
 792
 793                 port->dcd = CD;
 794                 port->dsr = DSR;
 795                 port->pnum = i;
 796
 797                 DPRINT3(DB_INFO, "dgm%d port %d: shrinkmem ?\n", sc->unit, i);
 798                 if (shrinkmem) {
 799                         DPRINT2(DB_INFO, "dgm%d: shrinking memory\n", sc->unit);
 800                         fepcmd(port, SETBUFFER, 32, 0, 0, 0);
 801                         shrinkmem = 0;
 802                 }
 803
 804                 DPRINT3(DB_INFO, "dgm%d port %d: assign ptrs\n", sc->unit, i);
 805                 port->txptr = mem + ((bc->tseg << 4) & 0x7FFF);
 806                 port->rxptr = mem + ((bc->rseg << 4) & 0x7FFF);
 807                 port->txwin = FEPWIN | (bc->tseg >> 11);
 808                 port->rxwin = FEPWIN | (bc->rseg >> 11);
 809
 810                 port->txbufhead = 0;
 811                 port->rxbufhead = 0;
 812                 port->txbufsize = bc->tmax + 1;
 813                 port->rxbufsize = bc->rmax + 1;
 814
 815                 lowwater = (port->txbufsize >= 2000) ?
 816                     1024 : (port->txbufsize / 2);
 817
 818                 setwin(sc, 0);
 819                 DPRINT4(DB_INFO, "dgm%d port %d: fepcmd STXLWATER %d\n",
 820                     sc->unit, i, lowwater);
 821                 fepcmd(port, STXLWATER, lowwater, 0, 10, 0);
 822                 DPRINT4(DB_INFO, "dgm%d port %d: fepcmd SRXLWATER %d\n",
 823                     sc->unit, i, port->rxbufsize / 4);
 824                 fepcmd(port, SRXLWATER, port->rxbufsize / 4, 0, 10, 0);
 825                 DPRINT4(DB_INFO, "dgm%d port %d: fepcmd SRXHWATER %d\n",
 826                     sc->unit, i, 3 * port->rxbufsize / 4);
 827                 fepcmd(port, SRXHWATER, 3 * port->rxbufsize / 4, 0, 10, 0);
 828
 829                 bc->edelay = 100;
 830                 bc->idata = 1;
 831
 832                 port->startc = bc->startc;
 833                 port->startca = bc->startca;
 834                 port->stopc = bc->stopc;
 835                 port->stopca = bc->stopca;
 836
 837                 /* port->close_delay = 50; */
 838                 port->close_delay = 3 * hz;
 839                 port->do_timestamp = 0;
 840                 port->do_dcd_timestamp = 0;
 841
 842                 DPRINT3(DB_INFO, "dgm%d port %d: setup flags\n", sc->unit, i);
 843                 /*
 844                  * We don't use all the flags from <sys/ttydefaults.h> since
 845                  * they are only relevant for logins.  It's important to have
 846                  * echo off initially so that the line doesn't start
 847                  * blathering before the echo flag can be turned off.
 848                  */
 849                 port->it_in.c_iflag = TTYDEF_IFLAG;
 850                 port->it_in.c_oflag = TTYDEF_OFLAG;
 851                 port->it_in.c_cflag = TTYDEF_CFLAG;
 852                 port->it_in.c_lflag = TTYDEF_LFLAG;
 853                 termioschars(&port->it_in);
 854                 port->it_in.c_ispeed = port->it_in.c_ospeed = dgmdefaultrate;
 855                 port->it_out = port->it_in;
 856
 857                 DPRINT3(DB_INFO, "dgm%d port %d: make devices\n", sc->unit, i);
 858                 make_dev(&dgm_ops, (sc->unit*65536) + i, UID_ROOT,
 859                     GID_WHEEL, 0600, "ttyM%d%x", sc->unit, i + 0xa0);
 860                 make_dev(&dgm_ops, sc->unit * 65536 + i + 64, UID_ROOT,
 861                     GID_WHEEL, 0600, "ttyiM%d%x", sc->unit, i + 0xa0);
 862                 make_dev(&dgm_ops, sc->unit * 65536 + i + 128, UID_ROOT,
 863                     GID_WHEEL, 0600, "ttylM%d%x", sc->unit, i + 0xa0);
 864                 make_dev(&dgm_ops, sc->unit * 65536 + i + 262144, UID_UUCP,
 865                     GID_DIALER, 0660, "cuaM%d%x", sc->unit, i + 0xa0);
 866                 make_dev(&dgm_ops, sc->unit * 65536 + i + 262208, UID_UUCP,
 867                     GID_DIALER, 0660, "cuaiM%d%x", sc->unit, i + 0xa0);
 868                 make_dev(&dgm_ops, sc->unit * 65536 + i + 262272, UID_UUCP,
 869                     GID_DIALER, 0660, "cualM%d%x", sc->unit, i + 0xa0);
 870         }
 871
 872         DPRINT3(DB_INFO, "dgm%d: %d device nodes created\n", sc->unit, sc->numports);
 873
 874         hidewin(sc);
 875
 876         /* start the polling function */
 877         callout_reset(&sc->toh, hz / POLLSPERSEC,
 878                         dgmpoll, (void *)(int)sc->unit);
 879
 880         DPRINT2(DB_INFO, "dgm%d: poll thread started\n", sc->unit);
 881
 882         return (0);
 883 }
 884
 885 static int
 886 dgmdetach(device_t dev)
 887 {
 888         struct dgm_softc *sc = device_get_softc(dev);
 889         int i;
 890
 891         for (i = 0; i < sc->numports; i++)
 892                 if (sc->ttys[i].t_state & TS_ISOPEN)
 893                         return (EBUSY);
 894
 895         DPRINT2(DB_INFO, "dgm%d: detach\n", sc->unit);
 896
 897         /*
 898          * The dev_ops_remove() call will destroy all associated devices
 899          * and dereference any ad-hoc-created devices, but does not
 900          * dereference devices created via make_dev().
 901          */
 902         dev_ops_remove(&dgm_ops, DGM_UNITMASK, DGM_UNIT(sc->unit));
 903
 904         callout_stop(&sc->toh);
 905
 906         bus_release_resource(dev, SYS_RES_MEMORY, sc->mrid, sc->mem_res);
 907         bus_release_resource(dev, SYS_RES_IOPORT, sc->iorid, sc->io_res);
 908
 909         FREE(sc->ports, M_TTYS);
 910         FREE(sc->ttys, M_TTYS);
 911
 912         return (0);
 913 }
 914
 915 int
 916 dgmshutdown(device_t dev)
 917 {
 918 #ifdef DEBUG
 919         struct dgm_softc *sc = device_get_softc(dev);
 920
 921         DPRINT2(DB_INFO, "dgm%d: shutdown\n", sc->unit);
 922 #endif
 923
 924         return 0;
 925 }
 926
 927 /* ARGSUSED */
 928 static int
 929 dgmopen(struct dev_open_args *ap)
 930 {
 931         cdev_t dev = ap->a_head.a_dev;
 932         struct dgm_softc *sc;
 933         struct tty *tp;
 934         int unit;
 935         int mynor;
 936         int pnum;
 937         struct dgm_p *port;
 938         int error;
 939         volatile struct board_chan *bc;
 940
 941         error = 0;
 942         mynor = minor(dev);
 943         unit = MINOR_TO_UNIT(mynor);
 944         pnum = MINOR_TO_PORT(mynor);
 945
 946         sc = devclass_get_softc(dgmdevclass, unit);
 947         if (sc == NULL) {
 948                 DPRINT2(DB_EXCEPT, "dgm%d: try to open a nonexisting card\n",
 949                     unit);
 950                 return ENXIO;
 951         }
 952
 953         DPRINT2(DB_INFO, "dgm%d: open\n", sc->unit);
 954
 955         if (!sc->enabled) {
 956                 DPRINT2(DB_EXCEPT, "dgm%d: try to open a disabled card\n",
 957                     unit);
 958                 return ENXIO;
 959         }
 960
 961         if (pnum >= sc->numports) {
 962                 DPRINT3(DB_EXCEPT, "dgm%d: try to open non-existing port %d\n",
 963                     unit, pnum);
 964                 return ENXIO;
 965         }
 966
 967         if (mynor & CONTROL_MASK)
 968                 return 0;
 969
 970         tp = &sc->ttys[pnum];
 971         dev->si_tty = tp;
 972         port = &sc->ports[pnum];
 973         bc = port->brdchan;
 974
 975 open_top:
 976         crit_enter();
 977
 978         while (port->closing) {
 979                 error = tsleep(&port->closing, PCATCH, "dgocl", 0);
 980
 981                 if (error) {
 982                         DPRINT4(DB_OPEN, "dgm%d: port%d: tsleep(dgocl)"
 983                             " error = %d\n", unit, pnum, error);
 984                         goto out;
 985                 }
 986         }
 987
 988         if (tp->t_state & TS_ISOPEN) {
 989                 /*
 990                  * The device is open, so everything has been initialized.
 991                  * Handle conflicts.
 992                  */
 993                 if (mynor & CALLOUT_MASK) {
 994                         if (!port->active_out) {
 995                                 error = EBUSY;
 996                                 DPRINT4(DB_OPEN, "dgm%d: port%d:"
 997                                     " BUSY error = %d\n", unit, pnum, error);
 998                                 goto out;
 999                         }
1000                 } else if (port->active_out) {
1001                         if (ap->a_oflags & O_NONBLOCK) {
1002                                 error = EBUSY;
1003                                 DPRINT4(DB_OPEN, "dgm%d: port%d:"
1004                                     " BUSY error = %d\n", unit, pnum, error);
1005                                 goto out;
1006                         }
1007                         error = tsleep(&port->active_out, PCATCH, "dgmi", 0);
1008                         if (error != 0) {
1009                                 DPRINT4(DB_OPEN, "dgm%d: port%d: tsleep(dgmi)"
1010                                     " error = %d\n", unit, pnum, error);
1011                                 goto out;
1012                         }
1013                         crit_exit();
1014                         goto open_top;
1015                 }
1016                 if (tp->t_state & TS_XCLUDE && suser_cred(ap->a_cred, 0)) {
1017                         error = EBUSY;
1018                         goto out;
1019                 }
1020         } else {
1021                 /*
1022                  * The device isn't open, so there are no conflicts.
1023                  * Initialize it.  Initialization is done twice in many
1024                  * cases: to preempt sleeping callin opens if we are
1025                  * callout, and to complete a callin open after DCD rises.
1026                  */
1027                 tp->t_oproc = dgmstart;
1028                 tp->t_param = dgmparam;
1029                 tp->t_stop = dgmstop;
1030                 tp->t_dev = dev;
1031                 tp->t_termios= (mynor & CALLOUT_MASK) ?
1032                                                         port->it_out :
1033                                                         port->it_in;
1034
1035                 crit_enter();
1036                 setwin(sc, 0);
1037                 port->imodem = bc->mstat;
1038                 bc->rout = bc->rin; /* clear input queue */
1039                 bc->idata = 1;
1040 #ifdef PRINT_BUFSIZE
1041                 kprintf("dgm buffers tx = %x:%x rx = %x:%x\n",
1042                     bc->tseg, bc->tmax, bc->rseg, bc->rmax);
1043 #endif
1044
1045                 hidewin(sc);
1046                 crit_exit();
1047
1048                 port->wopeners++;
1049                 error = dgmparam(tp, &tp->t_termios);
1050                 port->wopeners--;
1051
1052                 if (error != 0) {
1053                         DPRINT4(DB_OPEN, "dgm%d: port%d: dgmparam error = %d\n",
1054                             unit, pnum, error);
1055                         goto out;
1056                 }
1057
1058                 /* handle fake DCD for callout devices */
1059                 /* and initial DCD */
1060
1061                 if ((port->imodem & port->dcd) || mynor & CALLOUT_MASK)
1062                         linesw[tp->t_line].l_modem(tp, 1);
1063         }
1064
1065         /*
1066          * Wait for DCD if necessary.
1067          */
1068         if (!(tp->t_state & TS_CARR_ON) && !(mynor & CALLOUT_MASK)
1069             && !(tp->t_cflag & CLOCAL) && !(ap->a_oflags & O_NONBLOCK)) {
1070                 ++port->wopeners;
1071                 error = tsleep(TSA_CARR_ON(tp), PCATCH, "dgdcd", 0);
1072                 --port->wopeners;
1073                 if (error != 0) {
1074                         DPRINT4(DB_OPEN, "dgm%d: port%d: tsleep(dgdcd)"
1075                             " error = %d\n", unit, pnum, error);
1076                         goto out;
1077                 }
1078                 crit_exit();
1079                 goto open_top;
1080         }
1081         error = linesw[tp->t_line].l_open(dev, tp);
1082         disc_optim(tp, &tp->t_termios);
1083         DPRINT4(DB_OPEN, "dgm%d: port%d: l_open error = %d\n",
1084             unit, pnum, error);
1085
1086         if (tp->t_state & TS_ISOPEN && mynor & CALLOUT_MASK)
1087                 port->active_out = 1;
1088
1089         port->used = 1;
1090
1091         /* If any port is open (i.e. the open() call is completed for it)
1092          * the device is busy
1093          */
1094
1095 out:
1096         disc_optim(tp, &tp->t_termios);
1097         crit_exit();
1098
1099         if (!(tp->t_state & TS_ISOPEN) && port->wopeners == 0)
1100                 dgmhardclose(port);
1101
1102         DPRINT4(DB_OPEN, "dgm%d: port%d: open() returns %d\n",
1103             unit, pnum, error);
1104
1105         return error;
1106 }
1107
1108 /*ARGSUSED*/
1109 static int
1110 dgmclose(struct dev_close_args *ap)
1111 {
1112         cdev_t dev = ap->a_head.a_dev;
1113         int             mynor;
1114         struct tty      *tp;
1115         int unit, pnum;
1116         struct dgm_softc *sc;
1117         struct dgm_p *port;
1118         int i;
1119
1120         mynor = minor(dev);
1121         if (mynor & CONTROL_MASK)
1122                 return 0;
1123         unit = MINOR_TO_UNIT(mynor);
1124         pnum = MINOR_TO_PORT(mynor);
1125
1126         sc = devclass_get_softc(dgmdevclass, unit);
1127         tp = &sc->ttys[pnum];
1128         port = sc->ports + pnum;
1129
1130         DPRINT3(DB_CLOSE, "dgm%d: port%d: closing\n", unit, pnum);
1131
1132         DPRINT3(DB_CLOSE, "dgm%d: port%d: draining port\n", unit, pnum);
1133         dgm_drain_or_flush(port);
1134
1135         crit_enter();
1136
1137         port->closing = 1;
1138         DPRINT3(DB_CLOSE, "dgm%d: port%d: closing line disc\n", unit, pnum);
1139         linesw[tp->t_line].l_close(tp, ap->a_fflag);
1140         disc_optim(tp, &tp->t_termios);
1141
1142         DPRINT3(DB_CLOSE, "dgm%d: port%d: hard closing\n", unit, pnum);
1143         dgmhardclose(port);
1144         DPRINT3(DB_CLOSE, "dgm%d: port%d: closing tty\n", unit, pnum);
1145         ttyclose(tp);
1146         port->closing = 0;
1147         wakeup(&port->closing);
1148         port->used = 0;
1149
1150         /* mark the card idle when all ports are closed */
1151
1152         for (i = 0; i < sc->numports; i++)
1153                 if (sc->ports[i].used)
1154                         break;
1155
1156         crit_exit();
1157
1158         DPRINT3(DB_CLOSE, "dgm%d: port%d: closed\n", unit, pnum);
1159
1160         wakeup(TSA_CARR_ON(tp));
1161         wakeup(&port->active_out);
1162         port->active_out = 0;
1163
1164         DPRINT3(DB_CLOSE, "dgm%d: port%d: close exit\n", unit, pnum);
1165
1166         return 0;
1167 }
1168
1169 static void
1170 dgmhardclose(struct dgm_p *port)
1171 {
1172         volatile struct board_chan *bc = port->brdchan;
1173         struct dgm_softc *sc;
1174
1175         sc = devclass_get_softc(dgmdevclass, port->sc->unit);
1176         DPRINT2(DB_INFO, "dgm%d: dgmhardclose\n", sc->unit);
1177         crit_enter();
1178         port->do_timestamp = 0;
1179         setwin(sc, 0);
1180
1181         bc->idata = 0;
1182         bc->iempty = 0;
1183         bc->ilow = 0;
1184         if (port->tty->t_cflag & HUPCL) {
1185                 port->omodem &= ~(RTS|DTR);
1186                 fepcmd(port, SETMODEM, 0, DTR|RTS, 0, 1);
1187         }
1188
1189         hidewin(sc);
1190         crit_exit();
1191
1192         callout_reset(&port->hc_timeout, hz / 2, dgm_pause, &port->brdchan);
1193         tsleep(&port->brdchan, PCATCH, "dgclo", 0);
1194 }
1195
1196 static void
1197 dgm_pause(void *chan)
1198 {
1199         wakeup((caddr_t)chan);
1200 }
1201
1202 static void
1203 dgmpoll(void *unit_c)
1204 {
1205         int unit = (int)unit_c;
1206         int pnum;
1207         struct dgm_p *port;
1208         struct dgm_softc *sc;
1209         int head, tail;
1210         u_char *eventbuf;
1211         int event, mstat, lstat;
1212         volatile struct board_chan *bc;
1213         struct tty *tp;
1214         int rhead, rtail;
1215         int whead, wtail;
1216         int size;
1217         u_char *ptr;
1218         int ocount;
1219         int ibuf_full, obuf_full;
1220         BoardMemWinState ws = bmws_get();
1221
1222         sc = devclass_get_softc(dgmdevclass, unit);
1223         DPRINT2(DB_INFO, "dgm%d: poll\n", sc->unit);
1224
1225         if (!sc->enabled) {
1226                 kprintf("dgm%d: polling of disabled board stopped\n", unit);
1227                 return;
1228         }
1229
1230         setwin(sc, 0);
1231
1232         head = sc->mailbox->ein;
1233         tail = sc->mailbox->eout;
1234
1235         while (head != tail) {
1236                 if (head >= FEP_IMAX - FEP_ISTART
1237                 || tail >= FEP_IMAX - FEP_ISTART
1238                 || (head|tail) & 03 ) {
1239                         kprintf("dgm%d: event queue's head or tail is wrong!"
1240                             " hd = %d, tl = %d\n", unit, head, tail);
1241                         break;
1242                 }
1243
1244                 eventbuf = sc->vmem + tail + FEP_ISTART;
1245                 pnum = eventbuf[0];
1246                 event = eventbuf[1];
1247                 mstat = eventbuf[2];
1248                 lstat = eventbuf[3];
1249
1250                 port = &sc->ports[pnum];
1251                 bc = port->brdchan;
1252                 tp = &sc->ttys[pnum];
1253
1254                 if (pnum >= sc->numports || !port->enabled) {
1255                         kprintf("dgm%d: port%d: got event on nonexisting port\n",
1256                             unit, pnum);
1257                 } else if (port->used || port->wopeners > 0 ) {
1258
1259                         int wrapmask = port->rxbufsize - 1;
1260
1261                         if (!(event & ALL_IND))
1262                                 kprintf("dgm%d: port%d: ? event 0x%x mstat 0x%x lstat 0x%x\n",
1263                                         unit, pnum, event, mstat, lstat);
1264
1265                         if (event & DATA_IND) {
1266                                 DPRINT3(DB_DATA, "dgm%d: port%d: DATA_IND\n",
1267                                     unit, pnum);
1268
1269                                 rhead = bc->rin & wrapmask;
1270                                 rtail = bc->rout & wrapmask;
1271
1272                                 if (!(tp->t_cflag & CREAD) || !port->used ) {
1273                                         bc->rout = rhead;
1274                                         goto end_of_data;
1275                                 }
1276
1277                                 if (bc->orun) {
1278                                         kprintf("dgm%d: port%d: overrun\n", unit, pnum);
1279                                         bc->orun = 0;
1280                                 }
1281
1282                                 if (!(tp->t_state & TS_ISOPEN))
1283                                         goto end_of_data;
1284
1285                                 for (ibuf_full = FALSE; rhead != rtail && !ibuf_full;) {
1286                                         DPRINT5(DB_RXDATA, "dgm%d: port%d:"
1287                                             " p rx head = %d tail = %d\n", unit,
1288                                             pnum, rhead, rtail);
1289
1290                                         if (rhead > rtail)
1291                                                 size = rhead - rtail;
1292                                         else
1293                                                 size = port->rxbufsize - rtail;
1294
1295                                         ptr = port->rxptr + rtail;
1296
1297 /* Helg: */
1298                                         if (tp->t_rawq.c_cc + size > DGB_IBUFSIZE ) {
1299                                                 size = DGB_IBUFSIZE - tp->t_rawq.c_cc;
1300                                                 DPRINT1(DB_RXDATA, "*");
1301                                                 ibuf_full = TRUE;
1302                                         }
1303
1304                                         if (size) {
1305                                                 if (tp->t_state & TS_CAN_BYPASS_L_RINT) {
1306                                                         DPRINT1(DB_RXDATA, "!");
1307                                                         towin(sc, port->rxwin);
1308                                                         tk_nin += size;
1309                                                         tk_rawcc += size;
1310                                                         tp->t_rawcc += size;
1311                                                         b_to_q(ptr, size,
1312                                                             &tp->t_rawq);
1313                                                         setwin(sc, 0);
1314                                                 } else {
1315                                                         int i = size;
1316                                                         unsigned char chr;
1317                                                         do {
1318                                                                 towin(sc, port->rxwin);
1319                                                                 chr = *ptr++;
1320                                                                 hidewin(sc);
1321                                                                (*linesw[tp->t_line].l_rint)(chr, tp);
1322                                                         } while (--i > 0 );
1323                                                         setwin(sc, 0);
1324                                                 }
1325                                         }
1326                                         rtail= (rtail + size) & wrapmask;
1327                                         bc->rout = rtail;
1328                                         rhead = bc->rin & wrapmask;
1329                                         hidewin(sc);
1330                                         ttwakeup(tp);
1331                                         setwin(sc, 0);
1332                                 }
1333                         end_of_data: ;
1334                         }
1335
1336                         if (event & MODEMCHG_IND) {
1337                                 DPRINT3(DB_MODEM, "dgm%d: port%d: "
1338                                     "MODEMCHG_IND\n", unit, pnum);
1339                                 port->imodem = mstat;
1340                                 if (mstat & port->dcd) {
1341                                         hidewin(sc);
1342                                         linesw[tp->t_line].l_modem(tp, 1);
1343                                         setwin(sc, 0);
1344                                         wakeup(TSA_CARR_ON(tp));
1345                                 } else {
1346                                         hidewin(sc);
1347                                         linesw[tp->t_line].l_modem(tp, 0);
1348                                         setwin(sc, 0);
1349                                         if (port->draining) {
1350                                                 port->draining = 0;
1351                                                 wakeup(&port->draining);
1352                                         }
1353                                 }
1354                         }
1355
1356                         if (event & BREAK_IND) {
1357                                 if ((tp->t_state & TS_ISOPEN) && (tp->t_iflag & IGNBRK))        {
1358                                         DPRINT3(DB_BREAK, "dgm%d: port%d:"
1359                                             " BREAK_IND\n", unit, pnum);
1360                                         hidewin(sc);
1361                                         linesw[tp->t_line].l_rint(TTY_BI, tp);
1362                                         setwin(sc, 0);
1363                                 }
1364                         }
1365
1366 /* Helg: with output flow control */
1367
1368                         if (event & (LOWTX_IND | EMPTYTX_IND) ) {
1369                                 DPRINT3(DB_TXDATA, "dgm%d: port%d:"
1370                                     " LOWTX_IND or EMPTYTX_IND\n", unit, pnum);
1371
1372                                 if ((event & EMPTYTX_IND ) &&
1373                                     tp->t_outq.c_cc == 0 && port->draining) {
1374                                         port->draining = 0;
1375                                         wakeup(&port->draining);
1376                                         bc->ilow = 0;
1377                                         bc->iempty = 0;
1378                                 } else {
1379
1380                                         int wrapmask = port->txbufsize - 1;
1381
1382                                         for (obuf_full = FALSE;
1383                                             tp->t_outq.c_cc != 0 && !obuf_full;
1384                                             ) {
1385                                                 /* add "last-minute" data to write buffer */
1386                                                 if (!(tp->t_state & TS_BUSY)) {
1387                                                         hidewin(sc);
1388 #ifndef TS_ASLEEP       /* post 2.0.5 FreeBSD */
1389                                                         ttwwakeup(tp);
1390 #else
1391                                                         if (tp->t_outq.c_cc <= tp->t_lowat) {
1392                                                                 if (tp->t_state & TS_ASLEEP) {
1393                                                                         tp->t_state &= ~TS_ASLEEP;
1394                                                                         wakeup(TSA_OLOWAT(tp));
1395                                                                 }
1396                                                                 /* selwakeup(&tp->t_wsel); */
1397                                                         }
1398 #endif
1399                                                         setwin(sc, 0);
1400                                                 }
1401                                                 crit_enter();
1402
1403                                         whead = bc->tin & wrapmask;
1404                                         wtail = bc->tout & wrapmask;
1405
1406                                         if (whead < wtail)
1407                                                 size = wtail - whead - 1;
1408                                         else {
1409                                                 size = port->txbufsize - whead;
1410                                                 if (wtail == 0)
1411                                                         size--;
1412                                         }
1413
1414                                         if (size == 0) {
1415                                                 DPRINT5(DB_WR, "dgm: head = %d tail = %d size = %d full = %d\n",
1416                                                         whead, wtail, size, obuf_full);
1417                                                 bc->iempty = 1;
1418                                                 bc->ilow = 1;
1419                                                 obuf_full = TRUE;
1420                                                 crit_exit();
1421                                                 break;
1422                                         }
1423
1424                                         towin(sc, port->txwin);
1425
1426                                         ocount = q_to_b(&tp->t_outq, port->txptr + whead, size);
1427                                         whead += ocount;
1428
1429                                         setwin(sc, 0);
1430                                         bc->tin = whead;
1431                                         bc->tin = whead & wrapmask;
1432                                         crit_exit();
1433                                 }
1434
1435                                 if (obuf_full) {
1436                                         DPRINT1(DB_WR, " +BUSY\n");
1437                                         tp->t_state |= TS_BUSY;
1438                                 } else {
1439                                         DPRINT1(DB_WR, " -BUSY\n");
1440                                         hidewin(sc);
1441 #ifndef TS_ASLEEP       /* post 2.0.5 FreeBSD */
1442                                         /* should clear TS_BUSY before ttwwakeup */
1443                                         if (tp->t_state & TS_BUSY)      {
1444                                                 tp->t_state &= ~TS_BUSY;
1445                                                 linesw[tp->t_line].l_start(tp);
1446                                                 ttwwakeup(tp);
1447                                         }
1448 #else
1449                                 if (tp->t_state & TS_ASLEEP) {
1450                                         tp->t_state &= ~TS_ASLEEP;
1451                                         wakeup(TSA_OLOWAT(tp));
1452                                 }
1453                                 tp->t_state &= ~TS_BUSY;
1454 #endif
1455                                         setwin(sc, 0);
1456                                         }
1457                                 }
1458                         }
1459                         bc->idata = 1;   /* require event on incoming data */
1460
1461                 } else {
1462                         bc = port->brdchan;
1463                         DPRINT4(DB_EXCEPT, "dgm%d: port%d: got event 0x%x on closed port\n",
1464                                 unit, pnum, event);
1465                         bc->rout = bc->rin;
1466                         bc->idata = bc->iempty = bc->ilow = 0;
1467                 }
1468
1469                 tail = (tail + 4) & (FEP_IMAX - FEP_ISTART - 4);
1470         }
1471
1472         sc->mailbox->eout = tail;
1473         bmws_set(ws);
1474
1475         callout_reset(&sc->toh, hz / POLLSPERSEC, dgmpoll, unit_c);
1476
1477         DPRINT2(DB_INFO, "dgm%d: poll done\n", sc->unit);
1478 }
1479
1480 static int
1481 dgmioctl(struct dev_ioctl_args *ap)
1482 {
1483         cdev_t dev = ap->a_head.a_dev;
1484         u_long cmd = ap->a_cmd;
1485         caddr_t data = ap->a_data;
1486         struct dgm_softc *sc;
1487         int unit, pnum;
1488         struct dgm_p *port;
1489         int mynor;
1490         struct tty *tp;
1491         volatile struct board_chan *bc;
1492         int error;
1493         int tiocm_xxx;
1494
1495 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1496         u_long          oldcmd;
1497         struct termios  term;
1498 #endif
1499
1500         BoardMemWinState ws = bmws_get();
1501
1502         mynor = minor(dev);
1503         unit = MINOR_TO_UNIT(mynor);
1504         pnum = MINOR_TO_PORT(mynor);
1505
1506         sc = devclass_get_softc(dgmdevclass, unit);
1507         port = &sc->ports[pnum];
1508         tp = &sc->ttys[pnum];
1509         bc = port->brdchan;
1510
1511         if (mynor & CONTROL_MASK) {
1512                 struct termios *ct;
1513
1514                 switch (mynor & CONTROL_MASK) {
1515                 case CONTROL_INIT_STATE:
1516                         ct = mynor & CALLOUT_MASK ? &port->it_out : &port->it_in;
1517                         break;
1518                 case CONTROL_LOCK_STATE:
1519                         ct = mynor & CALLOUT_MASK ? &port->lt_out : &port->lt_in;
1520                         break;
1521                 default:
1522                         return (ENODEV);        /* /dev/nodev */
1523                 }
1524                 switch (cmd) {
1525                 case TIOCSETA:
1526                         error = suser_cred(ap->a_cred, 0);
1527                         if (error != 0)
1528                                 return (error);
1529                         *ct = *(struct termios *)data;
1530                         return (0);
1531                 case TIOCGETA:
1532                         *(struct termios *)data = *ct;
1533                         return (0);
1534                 case TIOCGETD:
1535                         *(int *)data = TTYDISC;
1536                         return (0);
1537                 case TIOCGWINSZ:
1538                         bzero(data, sizeof(struct winsize));
1539                         return (0);
1540                 default:
1541                         return (ENOTTY);
1542                 }
1543         }
1544
1545 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1546         term = tp->t_termios;
1547         if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) {
1548           DPRINT6(DB_PARAM, "dgm%d: port%d: dgmioctl-ISNOW c = 0x%x i = 0x%x l = 0x%x\n", unit, pnum, term.c_cflag, term.c_iflag, term.c_lflag);
1549         }
1550         oldcmd = cmd;
1551         error = ttsetcompat(tp, &cmd, data, &term);
1552         if (error != 0)
1553                 return (error);
1554         if (cmd != oldcmd)
1555                 data = (caddr_t)&term;
1556 #endif
1557
1558         if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) {
1559                 int     cc;
1560                 struct termios *dt = (struct termios *)data;
1561                 struct termios *lt = mynor & CALLOUT_MASK
1562                                      ? &port->lt_out : &port->lt_in;
1563
1564                 DPRINT6(DB_PARAM, "dgm%d: port%d: dgmioctl-TOSET c = 0x%x i = 0x%x l = 0x%x\n", unit, pnum, dt->c_cflag, dt->c_iflag, dt->c_lflag);
1565                 dt->c_iflag = (tp->t_iflag & lt->c_iflag)
1566                               | (dt->c_iflag & ~lt->c_iflag);
1567                 dt->c_oflag = (tp->t_oflag & lt->c_oflag)
1568                               | (dt->c_oflag & ~lt->c_oflag);
1569                 dt->c_cflag = (tp->t_cflag & lt->c_cflag)
1570                               | (dt->c_cflag & ~lt->c_cflag);
1571                 dt->c_lflag = (tp->t_lflag & lt->c_lflag)
1572                               | (dt->c_lflag & ~lt->c_lflag);
1573                 for (cc = 0; cc < NCCS; ++cc)
1574                         if (lt->c_cc[cc] != 0)
1575                                 dt->c_cc[cc] = tp->t_cc[cc];
1576                 if (lt->c_ispeed != 0)
1577                         dt->c_ispeed = tp->t_ispeed;
1578                 if (lt->c_ospeed != 0)
1579                         dt->c_ospeed = tp->t_ospeed;
1580         }
1581
1582         if (cmd == TIOCSTOP) {
1583                 crit_enter();
1584                 setwin(sc, 0);
1585                 fepcmd(port, PAUSETX, 0, 0, 0, 0);
1586                 bmws_set(ws);
1587                 crit_exit();
1588                 return 0;
1589         } else if (cmd == TIOCSTART) {
1590                 crit_enter();
1591                 setwin(sc, 0);
1592                 fepcmd(port, RESUMETX, 0, 0, 0, 0);
1593                 bmws_set(ws);
1594                 crit_exit();
1595                 return 0;
1596         }
1597
1598         if (cmd == TIOCSETAW || cmd == TIOCSETAF)
1599                 port->mustdrain = 1;
1600
1601         error = linesw[tp->t_line].l_ioctl(tp, cmd, data,
1602                                            ap->a_fflag, ap->a_cred);
1603         if (error != ENOIOCTL)
1604                 return error;
1605         crit_enter();
1606         error = ttioctl(tp, cmd, data, ap->a_fflag);
1607         disc_optim(tp, &tp->t_termios);
1608         port->mustdrain = 0;
1609         if (error != ENOIOCTL) {
1610                 crit_exit();
1611                 if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) {
1612                         DPRINT6(DB_PARAM, "dgm%d: port%d: dgmioctl-RES c = 0x%x i = 0x%x l = 0x%x\n", unit, pnum, tp->t_cflag, tp->t_iflag, tp->t_lflag);
1613                 }
1614                 return error;
1615         }
1616
1617         switch (cmd) {
1618         case TIOCSBRK:
1619 #if 0
1620                 error = dgmdrain(port);
1621
1622                 if (error != 0) {
1623                         crit_exit();
1624                         return error;
1625                 }
1626 #endif
1627
1628                 crit_enter();
1629                 setwin(sc, 0);
1630
1631                 /* now it sends 400 millisecond break because I don't know */
1632                 /* how to send an infinite break */
1633
1634                 fepcmd(port, SENDBREAK, 400, 0, 10, 0);
1635                 hidewin(sc);
1636                 crit_exit();
1637                 break;
1638         case TIOCCBRK:
1639                 /* now it's empty */
1640                 break;
1641         case TIOCSDTR:
1642                 DPRINT3(DB_MODEM, "dgm%d: port%d: set DTR\n", unit, pnum);
1643                 port->omodem |= DTR;
1644                 crit_enter();
1645                 setwin(sc, 0);
1646                 fepcmd(port, SETMODEM, port->omodem, RTS, 0, 1);
1647
1648                 if (!(bc->mstat & DTR))
1649                         DPRINT3(DB_MODEM, "dgm%d: port%d: DTR is off\n", unit, pnum);
1650
1651                 hidewin(sc);
1652                 crit_exit();
1653                 break;
1654         case TIOCCDTR:
1655                 DPRINT3(DB_MODEM, "dgm%d: port%d: reset DTR\n", unit, pnum);
1656                 port->omodem &= ~DTR;
1657                 crit_enter();
1658                 setwin(sc, 0);
1659                 fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
1660
1661                 if (bc->mstat & DTR) {
1662                         DPRINT3(DB_MODEM, "dgm%d: port%d: DTR is on\n", unit, pnum);
1663                 }
1664
1665                 hidewin(sc);
1666                 crit_exit();
1667                 break;
1668         case TIOCMSET:
1669                 if (*(int *)data & TIOCM_DTR)
1670                         port->omodem |= DTR;
1671                 else
1672                         port->omodem &= ~DTR;
1673
1674                 if (*(int *)data & TIOCM_RTS)
1675                         port->omodem |= RTS;
1676                 else
1677                         port->omodem &= ~RTS;
1678
1679                 crit_enter();
1680                 setwin(sc, 0);
1681                 fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
1682                 hidewin(sc);
1683                 crit_exit();
1684                 break;
1685         case TIOCMBIS:
1686                 if (*(int *)data & TIOCM_DTR)
1687                         port->omodem |= DTR;
1688
1689                 if (*(int *)data & TIOCM_RTS)
1690                         port->omodem |= RTS;
1691
1692                 crit_enter();
1693                 setwin(sc, 0);
1694                 fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
1695                 hidewin(sc);
1696                 crit_exit();
1697                 break;
1698         case TIOCMBIC:
1699                 if (*(int *)data & TIOCM_DTR)
1700                         port->omodem &= ~DTR;
1701
1702                 if (*(int *)data & TIOCM_RTS)
1703                         port->omodem &= ~RTS;
1704
1705                 crit_enter();
1706                 setwin(sc, 0);
1707                 fepcmd(port, SETMODEM, port->omodem, RTS|DTR, 0, 1);
1708                 hidewin(sc);
1709                 crit_exit();
1710                 break;
1711         case TIOCMGET:
1712                 setwin(sc, 0);
1713                 port->imodem = bc->mstat;
1714                 hidewin(sc);
1715
1716                 tiocm_xxx = TIOCM_LE;   /* XXX - always enabled while open */
1717
1718                 DPRINT3(DB_MODEM, "dgm%d: port%d: modem stat -- ", unit, pnum);
1719
1720                 if (port->imodem & DTR) {
1721                         DPRINT1(DB_MODEM, "DTR ");
1722                         tiocm_xxx |= TIOCM_DTR;
1723                 }
1724                 if (port->imodem & RTS) {
1725                         DPRINT1(DB_MODEM, "RTS ");
1726                         tiocm_xxx |= TIOCM_RTS;
1727                 }
1728                 if (port->imodem & CTS) {
1729                         DPRINT1(DB_MODEM, "CTS ");
1730                         tiocm_xxx |= TIOCM_CTS;
1731                 }
1732                 if (port->imodem & port->dcd) {
1733                         DPRINT1(DB_MODEM, "DCD ");
1734                         tiocm_xxx |= TIOCM_CD;
1735                 }
1736                 if (port->imodem & port->dsr) {
1737                         DPRINT1(DB_MODEM, "DSR ");
1738                         tiocm_xxx |= TIOCM_DSR;
1739                 }
1740                 if (port->imodem & RI) {
1741                         DPRINT1(DB_MODEM, "RI ");
1742                         tiocm_xxx |= TIOCM_RI;
1743                 }
1744                 *(int *)data = tiocm_xxx;
1745                 DPRINT1(DB_MODEM, "--\n");
1746                 break;
1747         case TIOCMSDTRWAIT:
1748                 /* must be root since the wait applies to following logins */
1749                 error = suser_cred(ap->a_cred, 0);
1750                 if (error != 0) {
1751                         crit_exit();
1752                         return (error);
1753                 }
1754                 port->close_delay = *(int *)data * hz / 100;
1755                 break;
1756         case TIOCMGDTRWAIT:
1757                 *(int *)data = port->close_delay * 100 / hz;
1758                 break;
1759         case TIOCTIMESTAMP:
1760                 port->do_timestamp = 1;
1761                 *(struct timeval *)data = port->timestamp;
1762                 break;
1763         case TIOCDCDTIMESTAMP:
1764                 port->do_dcd_timestamp = 1;
1765                 *(struct timeval *)data = port->dcd_timestamp;
1766                 break;
1767         default:
1768                 bmws_set(ws);
1769                 crit_exit();
1770                 return ENOTTY;
1771         }
1772         bmws_set(ws);
1773         crit_exit();
1774
1775         return 0;
1776 }
1777
1778 static void
1779 wakeflush(void *p)
1780 {
1781         struct dgm_p *port = p;
1782
1783         wakeup(&port->draining);
1784 }
1785
1786 /* wait for the output to drain */
1787
1788 static int
1789 dgmdrain(struct dgm_p *port)
1790 {
1791         volatile struct board_chan *bc = port->brdchan;
1792         struct dgm_softc *sc;
1793         int error;
1794         int head, tail;
1795         BoardMemWinState ws = bmws_get();
1796
1797         sc = devclass_get_softc(dgmdevclass, port->sc->unit);
1798
1799         setwin(sc, 0);
1800
1801         bc->iempty = 1;
1802         tail = bc->tout;
1803         head = bc->tin;
1804
1805         while (tail != head) {
1806                 DPRINT5(DB_WR, "dgm%d: port%d: drain: head = %d tail = %d\n",
1807                         port->sc->unit, port->pnum, head, tail);
1808
1809                 hidewin(sc);
1810                 port->draining = 1;
1811                 callout_reset(&port->wf_timeout, hz, wakeflush, port);
1812                 error = tsleep(&port->draining, PCATCH, "dgdrn", 0);
1813                 port->draining = 0;
1814                 setwin(sc, 0);
1815
1816                 if (error != 0) {
1817                         DPRINT4(DB_WR, "dgm%d: port%d: tsleep(dgdrn) error = %d\n",
1818                                 port->sc->unit, port->pnum, error);
1819
1820                         bc->iempty = 0;
1821                         bmws_set(ws);
1822                         return error;
1823                 }
1824
1825                 tail = bc->tout;
1826                 head = bc->tin;
1827         }
1828         DPRINT5(DB_WR, "dgm%d: port%d: drain: head = %d tail = %d\n",
1829                 port->sc->unit, port->pnum, head, tail);
1830         bmws_set(ws);
1831         return 0;
1832 }
1833
1834 /* wait for the output to drain */
1835 /* or simply clear the buffer it it's stopped */
1836
1837 static void
1838 dgm_drain_or_flush(struct dgm_p *port)
1839 {
1840         volatile struct board_chan *bc = port->brdchan;
1841         struct tty *tp = port->tty;
1842         struct dgm_softc *sc;
1843         int error;
1844         int lasttail;
1845         int head, tail;
1846
1847         sc = devclass_get_softc(dgmdevclass, port->sc->unit);
1848         setwin(sc, 0);
1849
1850         lasttail = -1;
1851         bc->iempty = 1;
1852         tail = bc->tout;
1853         head = bc->tin;
1854
1855         while (tail != head /* && tail != lasttail */ ) {
1856                 DPRINT5(DB_WR, "dgm%d: port%d: flush: head = %d tail = %d\n",
1857                         port->sc->unit, port->pnum, head, tail);
1858
1859                 /* if there is no carrier simply clean the buffer */
1860                 if (!(tp->t_state & TS_CARR_ON)) {
1861                         bc->tout = bc->tin = 0;
1862                         bc->iempty = 0;
1863                         hidewin(sc);
1864                         return;
1865                 }
1866
1867                 hidewin(sc);
1868                 port->draining = 1;
1869                 callout_reset(&port->wf_timeout, hz, wakeflush, port);
1870                 error = tsleep(&port->draining, PCATCH, "dgfls", 0);
1871                 port->draining = 0;
1872                 setwin(sc, 0);
1873
1874                 if (error != 0) {
1875                         DPRINT4(DB_WR, "dgm%d: port%d: tsleep(dgfls)"
1876                             " error = %d\n", port->sc->unit, port->pnum, error);
1877
1878                         /* silently clean the buffer */
1879
1880                         bc->tout = bc->tin = 0;
1881                         bc->iempty = 0;
1882                         hidewin(sc);
1883                         return;
1884                 }
1885
1886                 lasttail = tail;
1887                 tail = bc->tout;
1888                 head = bc->tin;
1889         }
1890         hidewin(sc);
1891         DPRINT5(DB_WR, "dgm%d: port%d: flush: head = %d tail = %d\n",
1892                         port->sc->unit, port->pnum, head, tail);
1893 }
1894
1895 static int
1896 dgmparam(struct tty *tp, struct termios *t)
1897 {
1898         int unit = MINOR_TO_UNIT(minor(tp->t_dev));
1899         int pnum = MINOR_TO_PORT(minor(tp->t_dev));
1900         volatile struct board_chan *bc;
1901         struct dgm_softc *sc;
1902         struct dgm_p *port;
1903         int cflag;
1904         int head;
1905         int mval;
1906         int iflag;
1907         int hflow;
1908         BoardMemWinState ws = bmws_get();
1909
1910         sc = devclass_get_softc(dgmdevclass, unit);
1911         port = &sc->ports[pnum];
1912         bc = port->brdchan;
1913
1914         DPRINT6(DB_PARAM, "dgm%d: port%d: dgmparm c = 0x%x i = 0x%x l = 0x%x\n", unit, pnum, t->c_cflag, t->c_iflag, t->c_lflag);
1915
1916         if (port->mustdrain) {
1917                 DPRINT3(DB_PARAM, "dgm%d: port%d: must call dgmdrain()\n", unit, pnum);
1918                 dgmdrain(port);
1919         }
1920
1921         cflag = ttspeedtab(t->c_ospeed, dgmspeedtab);
1922
1923         if (t->c_ispeed == 0)
1924                 t->c_ispeed = t->c_ospeed;
1925
1926         if (cflag < 0 /* || cflag > 0 && t->c_ispeed != t->c_ospeed */) {
1927                 DPRINT4(DB_PARAM, "dgm%d: port%d: invalid cflag = 0%o\n", unit, pnum, cflag);
1928                 return (EINVAL);
1929         }
1930
1931         crit_enter();
1932         setwin(sc, 0);
1933
1934         if (cflag == 0) { /* hangup */
1935                 DPRINT3(DB_PARAM, "dgm%d: port%d: hangup\n", unit, pnum);
1936                 head = bc->rin;
1937                 bc->rout = head;
1938                 head = bc->tin;
1939                 fepcmd(port, STOUT, (unsigned)head, 0, 0, 0);
1940                 mval= port->omodem & ~(DTR|RTS);
1941         } else {
1942                 cflag |= dgmflags(dgm_cflags, t->c_cflag);
1943
1944                 if (cflag != port->fepcflag) {
1945                         port->fepcflag = cflag;
1946                         DPRINT5(DB_PARAM, "dgm%d: port%d: set cflag = 0x%x c = 0x%x\n",
1947                                         unit, pnum, cflag, t->c_cflag&~CRTSCTS);
1948                         fepcmd(port, SETCTRLFLAGS, (unsigned)cflag, 0, 0, 0);
1949                 }
1950                 mval= port->omodem | (DTR|RTS);
1951         }
1952
1953         iflag = dgmflags(dgm_iflags, t->c_iflag);
1954         if (iflag != port->fepiflag) {
1955                 port->fepiflag = iflag;
1956                 DPRINT5(DB_PARAM, "dgm%d: port%d: set iflag = 0x%x c = 0x%x\n", unit, pnum, iflag, t->c_iflag);
1957                 fepcmd(port, SETIFLAGS, (unsigned)iflag, 0, 0, 0);
1958         }
1959
1960         bc->mint = port->dcd;
1961
1962         hflow = dgmflags(dgm_flow, t->c_cflag);
1963         if (hflow != port->hflow) {
1964                 port->hflow = hflow;
1965                 DPRINT5(DB_PARAM, "dgm%d: port%d: set hflow = 0x%x f = 0x%x\n", unit, pnum, hflow, t->c_cflag&CRTSCTS);
1966                 fepcmd(port, SETHFLOW, (unsigned)hflow, 0xff, 0, 1);
1967         }
1968
1969         if (port->omodem != mval) {
1970                 DPRINT5(DB_PARAM, "dgm%d: port%d: setting modem parameters 0x%x was 0x%x\n",
1971                         unit, pnum, mval, port->omodem);
1972                 port->omodem = mval;
1973                 fepcmd(port, SETMODEM, (unsigned)mval, RTS|DTR, 0, 1);
1974         }
1975
1976         if (port->fepstartc != t->c_cc[VSTART] ||
1977             port->fepstopc != t->c_cc[VSTOP]) {
1978                 DPRINT5(DB_PARAM, "dgm%d: port%d: set startc = %d, stopc = %d\n", unit, pnum, t->c_cc[VSTART], t->c_cc[VSTOP]);
1979                 port->fepstartc = t->c_cc[VSTART];
1980                 port->fepstopc = t->c_cc[VSTOP];
1981                 fepcmd(port, SONOFFC, port->fepstartc, port->fepstopc, 0, 1);
1982         }
1983
1984         bmws_set(ws);
1985         crit_exit();
1986
1987         return 0;
1988
1989 }
1990
1991 static void
1992 dgmstart(struct tty *tp)
1993 {
1994         int unit;
1995         int pnum;
1996         struct dgm_p *port;
1997         struct dgm_softc *sc;
1998         volatile struct board_chan *bc;
1999         int head, tail;
2000         int size, ocount;
2001         int wmask;
2002
2003         BoardMemWinState ws = bmws_get();
2004
2005         unit = MINOR_TO_UNIT(minor(tp->t_dev));
2006         pnum = MINOR_TO_PORT(minor(tp->t_dev));
2007         sc = devclass_get_softc(dgmdevclass, unit);
2008         port = &sc->ports[pnum];
2009         bc = port->brdchan;
2010
2011         wmask = port->txbufsize - 1;
2012
2013         crit_enter();
2014
2015         while (tp->t_outq.c_cc != 0) {
2016 #ifndef TS_ASLEEP       /* post 2.0.5 FreeBSD */
2017                 ttwwakeup(tp);
2018 #else
2019                 if (tp->t_outq.c_cc <= tp->t_lowat) {
2020                         if (tp->t_state & TS_ASLEEP) {
2021                                 tp->t_state &= ~TS_ASLEEP;
2022                                 wakeup(TSA_OLOWAT(tp));
2023                         }
2024                         /*selwakeup(&tp->t_wsel);*/
2025                 }
2026 #endif
2027                 crit_enter();
2028                 setwin(sc, 0);
2029
2030                 head = bc->tin & wmask;
2031
2032                 do { tail = bc->tout; } while (tail != bc->tout);
2033                 tail = bc->tout & wmask;
2034
2035                 DPRINT5(DB_WR, "dgm%d: port%d: s tx head = %d tail = %d\n", unit, pnum, head, tail);
2036
2037 #ifdef LEAVE_FREE_CHARS
2038                 if (tail > head) {
2039                         size = tail - head - LEAVE_FREE_CHARS;
2040                         if (size < 0)
2041                                 size = 0;
2042                         else {
2043                                 size = port->txbufsize - head;
2044                                 if (tail + port->txbufsize < head)
2045                                         size = 0;
2046                         }
2047                 }
2048 #else
2049                 if (tail > head)
2050                         size = tail - head - 1;
2051                 else {
2052                         size = port->txbufsize - head;
2053                         if (tail == 0)
2054                                 size--;
2055                 }
2056 #endif
2057
2058                 if (size == 0) {
2059                         bc->iempty = 1;
2060                         bc->ilow = 1;
2061                         crit_exit();
2062                         bmws_set(ws);
2063                         tp->t_state |= TS_BUSY;
2064                         crit_exit();
2065                         return;
2066                 }
2067
2068                 towin(sc, port->txwin);
2069
2070                 ocount = q_to_b(&tp->t_outq, port->txptr + head, size);
2071                 head += ocount;
2072                 if (head >= port->txbufsize)
2073                         head -= port->txbufsize;
2074
2075                 setwin(sc, 0);
2076                 bc->tin = head;
2077
2078                 DPRINT5(DB_WR, "dgm%d: port%d: tx avail = %d count = %d\n",
2079                     unit, pnum, size, ocount);
2080                 hidewin(sc);
2081                 crit_exit();
2082         }
2083
2084         bmws_set(ws);
2085         crit_exit();
2086
2087 #ifndef TS_ASLEEP       /* post 2.0.5 FreeBSD */
2088         if (tp->t_state & TS_BUSY) {
2089                 tp->t_state &= ~TS_BUSY;
2090                 linesw[tp->t_line].l_start(tp);
2091                 ttwwakeup(tp);
2092         }
2093 #else
2094         if (tp->t_state & TS_ASLEEP) {
2095                 tp->t_state &= ~TS_ASLEEP;
2096                 wakeup(TSA_OLOWAT(tp));
2097         }
2098         tp->t_state& = ~TS_BUSY;
2099 #endif
2100 }
2101
2102 void
2103 dgmstop(struct tty *tp, int rw)
2104 {
2105         int unit;
2106         int pnum;
2107         struct dgm_p *port;
2108         struct dgm_softc *sc;
2109         volatile struct board_chan *bc;
2110
2111         BoardMemWinState ws = bmws_get();
2112
2113         unit = MINOR_TO_UNIT(minor(tp->t_dev));
2114         pnum = MINOR_TO_PORT(minor(tp->t_dev));
2115
2116         sc = devclass_get_softc(dgmdevclass, unit);
2117         port = &sc->ports[pnum];
2118         bc = port->brdchan;
2119
2120         DPRINT3(DB_WR, "dgm%d: port%d: stop\n", port->sc->unit, port->pnum);
2121
2122         crit_enter();
2123         setwin(sc, 0);
2124
2125         if (rw & FWRITE) {
2126                 /* clear output queue */
2127                 bc->tout = bc->tin = 0;
2128                 bc->ilow = 0;
2129                 bc->iempty = 0;
2130         }
2131         if (rw & FREAD) {
2132                 /* clear input queue */
2133                 bc->rout = bc->rin;
2134                 bc->idata = 1;
2135         }
2136         hidewin(sc);
2137         bmws_set(ws);
2138         crit_exit();
2139         dgmstart(tp);
2140 }
2141
2142 static void
2143 fepcmd(struct dgm_p *port,
2144         unsigned cmd,
2145         unsigned op1,
2146         unsigned op2,
2147         unsigned ncmds,
2148         unsigned bytecmd)
2149 {
2150         u_char *mem;
2151         unsigned tail, head;
2152         int count, n;
2153
2154         KASSERT(port->sc, ("Couldn't (re)obtain driver softc"));
2155         mem = port->sc->vmem;
2156
2157         if (!port->enabled) {
2158                 kprintf("dgm%d: port%d: FEP command on disabled port\n",
2159                         port->sc->unit, port->pnum);
2160                 return;
2161         }
2162
2163         /* setwin(port->sc, 0); Require this to be set by caller */
2164         head = port->sc->mailbox->cin;
2165
2166         if (head >= FEP_CMAX - FEP_CSTART || (head & 3)) {
2167                 kprintf("dgm%d: port%d: wrong pointer head of command queue : 0x%x\n",
2168                         port->sc->unit, port->pnum, head);
2169                 return;
2170         }
2171
2172         mem[head + FEP_CSTART] = cmd;
2173         mem[head + FEP_CSTART + 1] = port->pnum;
2174         if (bytecmd) {
2175                 mem[head + FEP_CSTART + 2] = op1;
2176                 mem[head + FEP_CSTART + 3] = op2;
2177         } else {
2178                 mem[head + FEP_CSTART + 2] = op1 & 0xff;
2179                 mem[head + FEP_CSTART + 3] = (op1 >> 8) & 0xff;
2180         }
2181
2182         DPRINT7(DB_FEP, "dgm%d: port%d: %s cmd = 0x%x op1 = 0x%x op2 = 0x%x\n", port->sc->unit, port->pnum,
2183                         (bytecmd)?"byte":"word", cmd, mem[head + FEP_CSTART + 2], mem[head + FEP_CSTART + 3]);
2184
2185         head = (head + 4) & (FEP_CMAX - FEP_CSTART - 4);
2186         port->sc->mailbox->cin = head;
2187
2188         count = FEPTIMEOUT;
2189
2190         while (count-- != 0) {
2191                 head = port->sc->mailbox->cin;
2192                 tail = port->sc->mailbox->cout;
2193
2194                 n = (head - tail) & (FEP_CMAX - FEP_CSTART - 4);
2195                 if (n <= ncmds * (sizeof(ushort)*4))
2196                         return;
2197         }
2198         kprintf("dgm%d(%d): timeout on FEP cmd = 0x%x\n", port->sc->unit, port->pnum, cmd);
2199 }
2200
2201 static void
2202 disc_optim(struct tty *tp, struct termios *t)
2203 {
2204         if (!(t->c_iflag & (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP | IXON))
2205             && (!(t->c_iflag & BRKINT) || (t->c_iflag & IGNBRK))
2206             && (!(t->c_iflag & PARMRK)
2207                 || (t->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK))
2208             && !(t->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN))
2209             && linesw[tp->t_line].l_rint == ttyinput)
2210                 tp->t_state |= TS_CAN_BYPASS_L_RINT;
2211         else
2212                 tp->t_state &= ~TS_CAN_BYPASS_L_RINT;
2213 }