sys/dev/cx/if_cx.c

   1 /*-
   2  * Cronyx-Sigma adapter driver for FreeBSD.
   3  * Supports PPP/HDLC and Cisco/HDLC protocol in synchronous mode,
   4  * and asynchronous channels with full modem control.
   5  * Keepalive protocol implemented in both Cisco and PPP modes.
   6  *
   7  * Copyright (C) 1994-2002 Cronyx Engineering.
   8  * Author: Serge Vakulenko, <vak@cronyx.ru>
   9  *
  10  * Copyright (C) 1999-2004 Cronyx Engineering.
  11  * Rewritten on DDK, ported to NETGRAPH, rewritten for FreeBSD 3.x-5.x by
  12  * Kurakin Roman, <rik@cronyx.ru>
  13  *
  14  * This software is distributed with NO WARRANTIES, not even the implied
  15  * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  16  *
  17  * Authors grant any other persons or organisations a permission to use,
  18  * modify and redistribute this software in source and binary forms,
  19  * as long as this message is kept with the software, all derivative
  20  * works or modified versions.
  21  *
  22  * Cronyx Id: if_cx.c,v 1.1.2.34 2004/06/23 17:09:13 rik Exp $
  23  */
  24
  25 #include <sys/cdefs.h>
  26 __FBSDID("$FreeBSD$");
  27
  28 #include <sys/param.h>
  29
  30 #include <sys/systm.h>
  31 #include <sys/kernel.h>
  32 #include <sys/module.h>
  33 #include <sys/priv.h>
  34 #include <sys/proc.h>
  35 #include <sys/mbuf.h>
  36 #include <sys/sockio.h>
  37 #include <sys/malloc.h>
  38 #include <sys/socket.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/conf.h>
  41 #include <sys/errno.h>
  42 #include <sys/serial.h>
  43 #include <sys/tty.h>
  44 #include <sys/bus.h>
  45 #include <machine/bus.h>
  46 #include <sys/rman.h>
  47 #include <isa/isavar.h>
  48 #include <sys/fcntl.h>
  49 #include <sys/interrupt.h>
  50 #include <vm/vm.h>
  51 #include <vm/pmap.h>
  52 #include <net/if.h>
  53 #include <net/if_var.h>
  54 #include <machine/cpufunc.h>
  55 #include <machine/cserial.h>
  56 #include <machine/resource.h>
  57 #include <dev/cx/machdep.h>
  58 #include <dev/cx/cxddk.h>
  59 #include <dev/cx/cronyxfw.h>
  60 #include "opt_ng_cronyx.h"
  61 #ifdef NETGRAPH_CRONYX
  62 #   include "opt_netgraph.h"
  63 #   include <netgraph/ng_message.h>
  64 #   include <netgraph/netgraph.h>
  65 #   include <dev/cx/ng_cx.h>
  66 #else
  67 #   include <net/if_types.h>
  68 #   include <net/if_sppp.h>
  69 #   define PP_CISCO IFF_LINK2
  70 #   include <net/bpf.h>
  71 #endif
  72
  73 #define NCX     1
  74
  75 /* If we don't have Cronyx's sppp version, we don't have fr support via sppp */
  76 #ifndef PP_FR
  77 #define PP_FR 0
  78 #endif
  79
  80 #define CX_DEBUG(d,s)   ({if (d->chan->debug) {\
  81                                 printf ("%s: ", d->name); printf s;}})
  82 #define CX_DEBUG2(d,s)  ({if (d->chan->debug>1) {\
  83                                 printf ("%s: ", d->name); printf s;}})
  84
  85 #define CX_LOCK_NAME    "cxX"
  86
  87 #define CX_LOCK(_bd)            mtx_lock (&(_bd)->cx_mtx)
  88 #define CX_UNLOCK(_bd)          mtx_unlock (&(_bd)->cx_mtx)
  89 #define CX_LOCK_ASSERT(_bd)     mtx_assert (&(_bd)->cx_mtx, MA_OWNED)
  90
  91 typedef struct _async_q {
  92         int beg;
  93         int end;
  94         #define BF_SZ 14400
  95         int buf[BF_SZ+1];
  96 } async_q;
  97
  98 #define AQ_GSZ(q)       ((BF_SZ + (q)->end - (q)->beg)%BF_SZ)
  99 #define AQ_PUSH(q,c)    {*((q)->buf + (q)->end) = c;\
 100                         (q)->end = ((q)->end + 1)%BF_SZ;}
 101 #define AQ_POP(q,c)     {c = *((q)->buf + (q)->beg);\
 102                         (q)->beg = ((q)->beg + 1)%BF_SZ;}
 103
 104 static void cx_identify         __P((driver_t *, device_t));
 105 static int cx_probe             __P((device_t));
 106 static int cx_attach            __P((device_t));
 107 static int cx_detach            __P((device_t));
 108 static t_open_t                 cx_topen;
 109 static t_modem_t                cx_tmodem;
 110 static t_close_t                cx_tclose;
 111
 112 static device_method_t cx_isa_methods [] = {
 113         DEVMETHOD(device_identify,      cx_identify),
 114         DEVMETHOD(device_probe,         cx_probe),
 115         DEVMETHOD(device_attach,        cx_attach),
 116         DEVMETHOD(device_detach,        cx_detach),
 117
 118         DEVMETHOD_END
 119 };
 120
 121 typedef struct _cx_dma_mem_t {
 122         unsigned long   phys;
 123         void            *virt;
 124         size_t          size;
 125         bus_dma_tag_t   dmat;
 126         bus_dmamap_t    mapp;
 127 } cx_dma_mem_t;
 128
 129 typedef struct _drv_t {
 130         char name [8];
 131         cx_chan_t *chan;
 132         cx_board_t *board;
 133         cx_dma_mem_t dmamem;
 134         struct tty *tty;
 135         struct callout dcd_timeout_handle;
 136         unsigned callout;
 137         unsigned lock;
 138         int open_dev;
 139         int cd;
 140         int running;
 141 #ifdef NETGRAPH
 142         char    nodename [NG_NODESIZ];
 143         hook_p  hook;
 144         hook_p  debug_hook;
 145         node_p  node;
 146         struct  ifqueue lo_queue;
 147         struct  ifqueue hi_queue;
 148 #else
 149         struct  ifqueue queue;
 150         struct  ifnet *ifp;
 151 #endif
 152         short   timeout;
 153         struct  callout timeout_handle;
 154         struct  cdev *devt;
 155         async_q aqueue;
 156 #define CX_READ 1
 157 #define CX_WRITE 2
 158         int intr_action;
 159         short atimeout;
 160 } drv_t;
 161
 162 typedef struct _bdrv_t {
 163         cx_board_t      *board;
 164         struct resource *base_res;
 165         struct resource *drq_res;
 166         struct resource *irq_res;
 167         int             base_rid;
 168         int             drq_rid;
 169         int             irq_rid;
 170         void            *intrhand;
 171         drv_t           channel [NCHAN];
 172         struct mtx      cx_mtx;
 173 } bdrv_t;
 174
 175 static driver_t cx_isa_driver = {
 176         "cx",
 177         cx_isa_methods,
 178         sizeof (bdrv_t),
 179 };
 180
 181 static devclass_t cx_devclass;
 182
 183 extern long csigma_fw_len;
 184 extern const char *csigma_fw_version;
 185 extern const char *csigma_fw_date;
 186 extern const char *csigma_fw_copyright;
 187 extern const cr_dat_tst_t csigma_fw_tvec[];
 188 extern const u_char csigma_fw_data[];
 189 static void cx_oproc (struct tty *tp);
 190 static int cx_param (struct tty *tp, struct termios *t);
 191 static void cx_stop (struct tty *tp, int flag);
 192 static void cx_receive (cx_chan_t *c, char *data, int len);
 193 static void cx_transmit (cx_chan_t *c, void *attachment, int len);
 194 static void cx_error (cx_chan_t *c, int data);
 195 static void cx_modem (cx_chan_t *c);
 196 static void cx_up (drv_t *d);
 197 static void cx_start (drv_t *d);
 198 static void cx_softintr (void *);
 199 static void *cx_fast_ih;
 200 static void cx_down (drv_t *d);
 201 static void cx_watchdog (drv_t *d);
 202 static void cx_watchdog_timer (void *arg);
 203 static void cx_carrier (void *arg);
 204
 205 #ifdef NETGRAPH
 206 extern struct ng_type typestruct;
 207 #else
 208 static void cx_ifstart (struct ifnet *ifp);
 209 static void cx_tlf (struct sppp *sp);
 210 static void cx_tls (struct sppp *sp);
 211 static int cx_sioctl (struct ifnet *ifp, u_long cmd, caddr_t data);
 212 static void cx_initialize (void *softc);
 213 #endif
 214
 215 static cx_board_t *adapter [NCX];
 216 static drv_t *channel [NCX*NCHAN];
 217 static struct callout led_timo [NCX];
 218 static struct callout timeout_handle;
 219
 220 static int cx_open (struct cdev *dev, int flag, int mode, struct thread *td);
 221 static int cx_close (struct cdev *dev, int flag, int mode, struct thread *td);
 222 static int cx_ioctl (struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td);
 223 static struct cdevsw cx_cdevsw = {
 224         .d_version  = D_VERSION,
 225         .d_open     = cx_open,
 226         .d_close    = cx_close,
 227         .d_ioctl    = cx_ioctl,
 228         .d_name     = "cx",
 229         .d_flags    = D_TTY,
 230 };
 231
 232 static int MY_SOFT_INTR;
 233
 234 /*
 235  * Make an mbuf from data.
 236  */
 237 static struct mbuf *makembuf (void *buf, u_int len)
 238 {
 239         struct mbuf *m, *o, *p;
 240
 241         MGETHDR (m, M_NOWAIT, MT_DATA);
 242
 243         if (! m)
 244                 return 0;
 245
 246         if (len >= MINCLSIZE)
 247                 MCLGET (m, M_NOWAIT);
 248
 249         m->m_pkthdr.len = len;
 250         m->m_len = 0;
 251
 252         p = m;
 253         while (len) {
 254                 u_int n = M_TRAILINGSPACE (p);
 255                 if (n > len)
 256                         n = len;
 257                 if (! n) {
 258                         /* Allocate new mbuf. */
 259                         o = p;
 260                         MGET (p, M_NOWAIT, MT_DATA);
 261                         if (! p) {
 262                                 m_freem (m);
 263                                 return 0;
 264                         }
 265                         if (len >= MINCLSIZE)
 266                                 MCLGET (p, M_NOWAIT);
 267                         p->m_len = 0;
 268                         o->m_next = p;
 269
 270                         n = M_TRAILINGSPACE (p);
 271                         if (n > len)
 272                                 n = len;
 273                 }
 274                 bcopy (buf, mtod (p, caddr_t) + p->m_len, n);
 275
 276                 p->m_len += n;
 277                 buf = n + (char*) buf;
 278                 len -= n;
 279         }
 280         return m;
 281 }
 282
 283 /*
 284  * Recover after lost transmit interrupts.
 285  */
 286 static void cx_timeout (void *arg)
 287 {
 288         drv_t *d;
 289         int s, i, k;
 290
 291         for (i = 0; i < NCX; i++) {
 292                 if (adapter[i] == NULL)
 293                         continue;
 294                 for (k = 0; k < NCHAN; ++k) {
 295                         d = channel[i * NCHAN + k];
 296                         if (! d)
 297                                 continue;
 298                         s = splhigh ();
 299                         CX_LOCK ((bdrv_t *)d->board->sys);
 300                         if (d->atimeout == 1 && d->tty && d->tty->t_state & TS_BUSY) {
 301                                 d->tty->t_state &= ~TS_BUSY;
 302                                 if (d->tty->t_dev) {
 303                                         d->intr_action |= CX_WRITE;
 304                                         MY_SOFT_INTR = 1;
 305                                         swi_sched (cx_fast_ih, 0);
 306                                 }
 307                                 CX_DEBUG (d, ("cx_timeout\n"));
 308                         }
 309                         if (d->atimeout)
 310                                 d->atimeout--;
 311                         CX_UNLOCK ((bdrv_t *)d->board->sys);
 312                         splx (s);
 313                 }
 314         }
 315         callout_reset (&timeout_handle, hz*5, cx_timeout, 0);
 316 }
 317
 318 static void cx_led_off (void *arg)
 319 {
 320         cx_board_t *b = arg;
 321         bdrv_t *bd = b->sys;
 322         int s;
 323
 324         s = splhigh ();
 325         CX_LOCK (bd);
 326         cx_led (b, 0);
 327         CX_UNLOCK (bd);
 328         splx (s);
 329 }
 330
 331 /*
 332  * Activate interrupt handler from DDK.
 333  */
 334 static void cx_intr (void *arg)
 335 {
 336         bdrv_t *bd = arg;
 337         cx_board_t *b = bd->board;
 338 #ifndef NETGRAPH
 339         int i;
 340 #endif
 341         int s = splhigh ();
 342
 343         CX_LOCK (bd);
 344         /* Turn LED on. */
 345         cx_led (b, 1);
 346
 347         cx_int_handler (b);
 348
 349         /* Turn LED off 50 msec later. */
 350         callout_reset (&led_timo[b->num], hz/20, cx_led_off, b);
 351         CX_UNLOCK (bd);
 352         splx (s);
 353
 354 #ifndef NETGRAPH
 355         /* Pass packets in a lock-free state */
 356         for (i = 0; i < NCHAN && b->chan[i].type; i++) {
 357                 drv_t *d = b->chan[i].sys;
 358                 struct mbuf *m;
 359                 if (!d || !d->running)
 360                         continue;
 361                 while (_IF_QLEN(&d->queue)) {
 362                         IF_DEQUEUE (&d->queue,m);
 363                         if (!m)
 364                                 continue;
 365                         sppp_input (d->ifp, m);
 366                 }
 367         }
 368 #endif
 369 }
 370
 371 static int probe_irq (cx_board_t *b, int irq)
 372 {
 373         int mask, busy, cnt;
 374
 375         /* Clear pending irq, if any. */
 376         cx_probe_irq (b, -irq);
 377         DELAY (100);
 378         for (cnt=0; cnt<5; ++cnt) {
 379                 /* Get the mask of pending irqs, assuming they are busy.
 380                  * Activate the adapter on given irq. */
 381                 busy = cx_probe_irq (b, irq);
 382                 DELAY (100);
 383
 384                 /* Get the mask of active irqs.
 385                  * Deactivate our irq. */
 386                 mask = cx_probe_irq (b, -irq);
 387                 DELAY (100);
 388                 if ((mask & ~busy) == 1 << irq) {
 389                         cx_probe_irq (b, 0);
 390                         /* printf ("cx%d: irq %d ok, mask=0x%04x, busy=0x%04x\n",
 391                                 b->num, irq, mask, busy); */
 392                         return 1;
 393                 }
 394         }
 395         /* printf ("cx%d: irq %d not functional, mask=0x%04x, busy=0x%04x\n",
 396                 b->num, irq, mask, busy); */
 397         cx_probe_irq (b, 0);
 398         return 0;
 399 }
 400
 401 static short porttab [] = {
 402         0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0,
 403         0x300, 0x320, 0x340, 0x360, 0x380, 0x3a0, 0x3c0, 0x3e0, 0
 404 };
 405 static char dmatab [] = { 7, 6, 5, 0 };
 406 static char irqtab [] = { 5, 10, 11, 7, 3, 15, 12, 0 };
 407
 408 static int cx_is_free_res (device_t dev, int rid, int type, rman_res_t start,
 409         rman_res_t end, rman_res_t count)
 410 {
 411         struct resource *res;
 412
 413         if (!(res = bus_alloc_resource (dev, type, &rid, start, end, count, 0)))
 414                 return 0;
 415
 416         bus_release_resource (dev, type, rid, res);
 417
 418         return 1;
 419 }
 420
 421 static void cx_identify (driver_t *driver, device_t dev)
 422 {
 423         rman_res_t iobase, rescount;
 424         int devcount;
 425         device_t *devices;
 426         device_t child;
 427         devclass_t my_devclass;
 428         int i, k;
 429
 430         if ((my_devclass = devclass_find ("cx")) == NULL)
 431                 return;
 432
 433         devclass_get_devices (my_devclass, &devices, &devcount);
 434
 435         if (devcount == 0) {
 436                 /* We should find all devices by our self. We could alter other
 437                  * devices, but we don't have a choise
 438                  */
 439                 for (i = 0; (iobase = porttab [i]) != 0; i++) {
 440                         if (!cx_is_free_res (dev, 0, SYS_RES_IOPORT,
 441                             iobase, iobase + NPORT, NPORT))
 442                                 continue;
 443                         if (cx_probe_board (iobase, -1, -1) == 0)
 444                                 continue;
 445
 446                         devcount++;
 447
 448                         child = BUS_ADD_CHILD (dev, ISA_ORDER_SPECULATIVE, "cx",
 449                             -1);
 450
 451                         if (child == NULL)
 452                                 return;
 453
 454                         device_set_desc_copy (child, "Cronyx Sigma");
 455                         device_set_driver (child, driver);
 456                         bus_set_resource (child, SYS_RES_IOPORT, 0,
 457                             iobase, NPORT);
 458
 459                         if (devcount >= NCX)
 460                                 break;
 461                 }
 462         } else {
 463                 static short porttab [] = {
 464                         0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0,
 465                         0x300, 0x320, 0x340, 0x360, 0x380, 0x3a0, 0x3c0, 0x3e0, 0
 466                 };
 467                 /* Lets check user choise.
 468                  */
 469                 for (k = 0; k < devcount; k++) {
 470                         if (bus_get_resource (devices[k], SYS_RES_IOPORT, 0,
 471                             &iobase, &rescount) != 0)
 472                                 continue;
 473
 474                         for (i = 0; porttab [i] != 0; i++) {
 475                                 if (porttab [i] != iobase)
 476                                         continue;
 477                                 if (!cx_is_free_res (devices[k], 0, SYS_RES_IOPORT,
 478                                     iobase, iobase + NPORT, NPORT))
 479                                         continue;
 480                                 if (cx_probe_board (iobase, -1, -1) == 0)
 481                                         continue;
 482                                 porttab [i] = -1;
 483                                 device_set_desc_copy (devices[k], "Cronyx Sigma");
 484                                 break;
 485                         }
 486
 487                         if (porttab [i] == 0) {
 488                                 device_delete_child (
 489                                     device_get_parent (devices[k]),
 490                                     devices [k]);
 491                                 devices[k] = 0;
 492                                 continue;
 493                         }
 494                 }
 495                 for (k = 0; k < devcount; k++) {
 496                         if (devices[k] == 0)
 497                                 continue;
 498                         if (bus_get_resource (devices[k], SYS_RES_IOPORT, 0,
 499                             &iobase, &rescount) == 0)
 500                                 continue;
 501                         for (i = 0; (iobase = porttab [i]) != 0; i++) {
 502                                 if (porttab [i] == -1) {
 503                                         continue;
 504                                 }
 505                                 if (!cx_is_free_res (devices[k], 0, SYS_RES_IOPORT,
 506                                     iobase, iobase + NPORT, NPORT))
 507                                         continue;
 508                                 if (cx_probe_board (iobase, -1, -1) == 0)
 509                                         continue;
 510
 511                                 bus_set_resource (devices[k], SYS_RES_IOPORT, 0,
 512                                     iobase, NPORT);
 513                                 porttab [i] = -1;
 514                                 device_set_desc_copy (devices[k], "Cronyx Sigma");
 515                                 break;
 516                         }
 517                         if (porttab [i] == 0) {
 518                                 device_delete_child (
 519                                     device_get_parent (devices[k]),
 520                                     devices [k]);
 521                         }
 522                 }
 523                 free (devices, M_TEMP);
 524         }
 525
 526         return;
 527 }
 528
 529 static int cx_probe (device_t dev)
 530 {
 531         int unit = device_get_unit (dev);
 532         int i;
 533         rman_res_t iobase, rescount;
 534
 535         if (!device_get_desc (dev) ||
 536             strcmp (device_get_desc (dev), "Cronyx Sigma"))
 537                 return ENXIO;
 538
 539         if (bus_get_resource (dev, SYS_RES_IOPORT, 0, &iobase, &rescount) != 0) {
 540                 printf ("cx%d: Couldn't get IOPORT\n", unit);
 541                 return ENXIO;
 542         }
 543
 544         if (!cx_is_free_res (dev, 0, SYS_RES_IOPORT,
 545             iobase, iobase + NPORT, NPORT)) {
 546                 printf ("cx%d: Resource IOPORT isn't free %lx\n", unit, iobase);
 547                 return ENXIO;
 548         }
 549
 550         for (i = 0; porttab [i] != 0; i++) {
 551                 if (porttab [i] == iobase) {
 552                         porttab [i] = -1;
 553                         break;
 554                 }
 555         }
 556
 557         if (porttab [i] == 0) {
 558                 return ENXIO;
 559         }
 560
 561         if (!cx_probe_board (iobase, -1, -1)) {
 562                 printf ("cx%d: probing for Sigma at %lx faild\n", unit, iobase);
 563                 return ENXIO;
 564         }
 565
 566         return 0;
 567 }
 568
 569 static void
 570 cx_bus_dmamap_addr (void *arg, bus_dma_segment_t *segs, int nseg, int error)
 571 {
 572         unsigned long *addr;
 573
 574         if (error)
 575                 return;
 576
 577         KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg));
 578         addr = arg;
 579         *addr = segs->ds_addr;
 580 }
 581
 582 static int
 583 cx_bus_dma_mem_alloc (int bnum, int cnum, cx_dma_mem_t *dmem)
 584 {
 585         int error;
 586
 587         error = bus_dma_tag_create (NULL, 16, 0, BUS_SPACE_MAXADDR_24BIT,
 588                 BUS_SPACE_MAXADDR, NULL, NULL, dmem->size, 1,
 589                 dmem->size, 0, NULL, NULL, &dmem->dmat);
 590         if (error) {
 591                 if (cnum >= 0)  printf ("cx%d-%d: ", bnum, cnum);
 592                 else            printf ("cx%d: ", bnum);
 593                 printf ("couldn't allocate tag for dma memory\n");
 594                 return 0;
 595         }
 596         error = bus_dmamem_alloc (dmem->dmat, (void **)&dmem->virt,
 597                 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &dmem->mapp);
 598         if (error) {
 599                 if (cnum >= 0)  printf ("cx%d-%d: ", bnum, cnum);
 600                 else            printf ("cx%d: ", bnum);
 601                 printf ("couldn't allocate mem for dma memory\n");
 602                 bus_dma_tag_destroy (dmem->dmat);
 603                 return 0;
 604         }
 605         error = bus_dmamap_load (dmem->dmat, dmem->mapp, dmem->virt,
 606                 dmem->size, cx_bus_dmamap_addr, &dmem->phys, 0);
 607         if (error) {
 608                 if (cnum >= 0)  printf ("cx%d-%d: ", bnum, cnum);
 609                 else            printf ("cx%d: ", bnum);
 610                 printf ("couldn't load mem map for dma memory\n");
 611                 bus_dmamem_free (dmem->dmat, dmem->virt, dmem->mapp);
 612                 bus_dma_tag_destroy (dmem->dmat);
 613                 return 0;
 614         }
 615         return 1;
 616 }
 617
 618 static void
 619 cx_bus_dma_mem_free (cx_dma_mem_t *dmem)
 620 {
 621         bus_dmamap_unload (dmem->dmat, dmem->mapp);
 622         bus_dmamem_free (dmem->dmat, dmem->virt, dmem->mapp);
 623         bus_dma_tag_destroy (dmem->dmat);
 624 }
 625
 626 /*
 627  * The adapter is present, initialize the driver structures.
 628  */
 629 static int cx_attach (device_t dev)
 630 {
 631         bdrv_t *bd = device_get_softc (dev);
 632         rman_res_t iobase, drq, irq, rescount;
 633         int unit = device_get_unit (dev);
 634         char *cx_ln = CX_LOCK_NAME;
 635         cx_board_t *b;
 636         cx_chan_t *c;
 637         drv_t *d;
 638         int i;
 639         int s;
 640
 641         KASSERT ((bd != NULL), ("cx%d: NULL device softc\n", unit));
 642
 643         bus_get_resource (dev, SYS_RES_IOPORT, 0, &iobase, &rescount);
 644         bd->base_rid = 0;
 645         bd->base_res = bus_alloc_resource (dev, SYS_RES_IOPORT, &bd->base_rid,
 646                 iobase, iobase + NPORT, NPORT, RF_ACTIVE);
 647         if (! bd->base_res) {
 648                 printf ("cx%d: cannot allocate base address\n", unit);
 649                 return ENXIO;
 650         }
 651
 652         if (bus_get_resource (dev, SYS_RES_DRQ, 0, &drq, &rescount) != 0) {
 653                 for (i = 0; (drq = dmatab [i]) != 0; i++) {
 654                         if (!cx_is_free_res (dev, 0, SYS_RES_DRQ,
 655                             drq, drq + 1, 1))
 656                                 continue;
 657                         bus_set_resource (dev, SYS_RES_DRQ, 0, drq, 1);
 658                         break;
 659                 }
 660
 661                 if (dmatab[i] == 0) {
 662                         bus_release_resource (dev, SYS_RES_IOPORT, bd->base_rid,
 663                                 bd->base_res);
 664                         printf ("cx%d: Couldn't get DRQ\n", unit);
 665                         return ENXIO;
 666                 }
 667         }
 668
 669         bd->drq_rid = 0;
 670         bd->drq_res = bus_alloc_resource (dev, SYS_RES_DRQ, &bd->drq_rid,
 671                 drq, drq + 1, 1, RF_ACTIVE);
 672         if (! bd->drq_res) {
 673                 printf ("cx%d: cannot allocate drq\n", unit);
 674                 bus_release_resource (dev, SYS_RES_IOPORT, bd->base_rid,
 675                         bd->base_res);
 676                 return ENXIO;
 677         }
 678
 679         if (bus_get_resource (dev, SYS_RES_IRQ, 0, &irq, &rescount) != 0) {
 680                 for (i = 0; (irq = irqtab [i]) != 0; i++) {
 681                         if (!cx_is_free_res (dev, 0, SYS_RES_IRQ,
 682                             irq, irq + 1, 1))
 683                                 continue;
 684                         bus_set_resource (dev, SYS_RES_IRQ, 0, irq, 1);
 685                         break;
 686                 }
 687
 688                 if (irqtab[i] == 0) {
 689                         bus_release_resource (dev, SYS_RES_DRQ, bd->drq_rid,
 690                                 bd->drq_res);
 691                         bus_release_resource (dev, SYS_RES_IOPORT, bd->base_rid,
 692                                 bd->base_res);
 693                         printf ("cx%d: Couldn't get IRQ\n", unit);
 694                         return ENXIO;
 695                 }
 696         }
 697
 698         bd->irq_rid = 0;
 699         bd->irq_res = bus_alloc_resource (dev, SYS_RES_IRQ, &bd->irq_rid,
 700                 irq, irq + 1, 1, RF_ACTIVE);
 701         if (! bd->irq_res) {
 702                 printf ("cx%d: Couldn't allocate irq\n", unit);
 703                 bus_release_resource (dev, SYS_RES_DRQ, bd->drq_rid,
 704                         bd->drq_res);
 705                 bus_release_resource (dev, SYS_RES_IOPORT, bd->base_rid,
 706                         bd->base_res);
 707                 return ENXIO;
 708         }
 709
 710         b = malloc (sizeof (cx_board_t), M_DEVBUF, M_WAITOK);
 711         if (!b) {
 712                 printf ("cx:%d: Couldn't allocate memory\n", unit);
 713                 return (ENXIO);
 714         }
 715         adapter[unit] = b;
 716         bzero (b, sizeof(cx_board_t));
 717
 718         if (! cx_open_board (b, unit, iobase, irq, drq)) {
 719                 printf ("cx%d: error loading firmware\n", unit);
 720                 free (b, M_DEVBUF);
 721                 bus_release_resource (dev, SYS_RES_IRQ, bd->irq_rid,
 722                         bd->irq_res);
 723                 bus_release_resource (dev, SYS_RES_DRQ, bd->drq_rid,
 724                         bd->drq_res);
 725                 bus_release_resource (dev, SYS_RES_IOPORT, bd->base_rid,
 726                         bd->base_res);
 727                 return ENXIO;
 728         }
 729
 730         bd->board = b;
 731
 732         cx_ln[2] = '0' + unit;
 733         mtx_init (&bd->cx_mtx, cx_ln, MTX_NETWORK_LOCK, MTX_DEF|MTX_RECURSE);
 734         if (! probe_irq (b, irq)) {
 735                 printf ("cx%d: irq %ld not functional\n", unit, irq);
 736                 bd->board = 0;
 737                 adapter [unit] = 0;
 738                 mtx_destroy (&bd->cx_mtx);
 739                 free (b, M_DEVBUF);
 740                 bus_release_resource (dev, SYS_RES_IRQ, bd->irq_rid,
 741                         bd->irq_res);
 742                 bus_release_resource (dev, SYS_RES_DRQ, bd->drq_rid,
 743                         bd->drq_res);
 744                 bus_release_resource (dev, SYS_RES_IOPORT, bd->base_rid,
 745                         bd->base_res);
 746                 return ENXIO;
 747         }
 748         b->sys = bd;
 749         callout_init (&led_timo[b->num], 1);
 750         s = splhigh ();
 751         if (bus_setup_intr (dev, bd->irq_res,
 752                            INTR_TYPE_NET|INTR_MPSAFE,
 753                            NULL, cx_intr, bd, &bd->intrhand)) {
 754                 printf ("cx%d: Can't setup irq %ld\n", unit, irq);
 755                 bd->board = 0;
 756                 b->sys = 0;
 757                 adapter [unit] = 0;
 758                 mtx_destroy (&bd->cx_mtx);
 759                 free (b, M_DEVBUF);
 760                 bus_release_resource (dev, SYS_RES_IRQ, bd->irq_rid,
 761                         bd->irq_res);
 762                 bus_release_resource (dev, SYS_RES_DRQ, bd->drq_rid,
 763                         bd->drq_res);
 764                 bus_release_resource (dev, SYS_RES_IOPORT, bd->base_rid,
 765                         bd->base_res);
 766                 splx (s);
 767                 return ENXIO;
 768         }
 769
 770         CX_LOCK (bd);
 771         cx_init (b, b->num, b->port, irq, drq);
 772         cx_setup_board (b, 0, 0, 0);
 773         CX_UNLOCK (bd);
 774
 775         printf ("cx%d: <Cronyx-Sigma-%s>\n", b->num, b->name);
 776
 777         for (c=b->chan; c<b->chan+NCHAN; ++c) {
 778                 if (c->type == T_NONE)
 779                         continue;
 780                 d = &bd->channel[c->num];
 781                 d->dmamem.size = sizeof(cx_buf_t);
 782                 if (! cx_bus_dma_mem_alloc (unit, c->num, &d->dmamem))
 783                         continue;
 784                 d->board = b;
 785                 d->chan = c;
 786                 d->open_dev = 0;
 787                 c->sys = d;
 788                 channel [b->num*NCHAN + c->num] = d;
 789                 sprintf (d->name, "cx%d.%d", b->num, c->num);
 790
 791                 switch (c->type) {
 792                 case T_SYNC_RS232:
 793                 case T_SYNC_V35:
 794                 case T_SYNC_RS449:
 795                 case T_UNIV:
 796                 case T_UNIV_RS232:
 797                 case T_UNIV_RS449:
 798                 case T_UNIV_V35:
 799                 callout_init (&d->timeout_handle, 1);
 800 #ifdef NETGRAPH
 801                 if (ng_make_node_common (&typestruct, &d->node) != 0) {
 802                         printf ("%s: cannot make common node\n", d->name);
 803                         channel [b->num*NCHAN + c->num] = 0;
 804                         c->sys = 0;
 805                         cx_bus_dma_mem_free (&d->dmamem);
 806                         continue;
 807                 }
 808                 NG_NODE_SET_PRIVATE (d->node, d);
 809                 sprintf (d->nodename, "%s%d", NG_CX_NODE_TYPE,
 810                          c->board->num*NCHAN + c->num);
 811                 if (ng_name_node (d->node, d->nodename)) {
 812                         printf ("%s: cannot name node\n", d->nodename);
 813                         NG_NODE_UNREF (d->node);
 814                         channel [b->num*NCHAN + c->num] = 0;
 815                         c->sys = 0;
 816                         cx_bus_dma_mem_free (&d->dmamem);
 817                         continue;
 818                 }
 819                 d->lo_queue.ifq_maxlen = ifqmaxlen;
 820                 d->hi_queue.ifq_maxlen = ifqmaxlen;
 821                 mtx_init (&d->lo_queue.ifq_mtx, "cx_queue_lo", NULL, MTX_DEF);
 822                 mtx_init (&d->hi_queue.ifq_mtx, "cx_queue_hi", NULL, MTX_DEF);
 823 #else /*NETGRAPH*/
 824                 d->ifp = if_alloc(IFT_PPP);
 825                 if (d->ifp == NULL) {
 826                         printf ("%s: cannot if_alloc() common interface\n",
 827                             d->name);
 828                         channel [b->num*NCHAN + c->num] = 0;
 829                         c->sys = 0;
 830                         cx_bus_dma_mem_free (&d->dmamem);
 831                         continue;
 832                 }
 833                 d->ifp->if_softc        = d;
 834                 if_initname (d->ifp, "cx", b->num * NCHAN + c->num);
 835                 d->ifp->if_mtu          = PP_MTU;
 836                 d->ifp->if_flags        = IFF_POINTOPOINT | IFF_MULTICAST;
 837                 d->ifp->if_ioctl        = cx_sioctl;
 838                 d->ifp->if_start        = cx_ifstart;
 839                 d->ifp->if_init         = cx_initialize;
 840                 d->queue.ifq_maxlen     = 2;
 841                 mtx_init (&d->queue.ifq_mtx, "cx_queue", NULL, MTX_DEF);
 842                 sppp_attach (d->ifp);
 843                 if_attach (d->ifp);
 844                 IFP2SP(d->ifp)->pp_tlf  = cx_tlf;
 845                 IFP2SP(d->ifp)->pp_tls  = cx_tls;
 846                 /* If BPF is in the kernel, call the attach for it.
 847                  * Size of PPP header is 4 bytes. */
 848                 bpfattach (d->ifp, DLT_PPP, 4);
 849 #endif /*NETGRAPH*/
 850                 }
 851                 d->tty = ttyalloc ();
 852                 d->tty->t_open  = cx_topen;
 853                 d->tty->t_close = cx_tclose;
 854                 d->tty->t_param = cx_param;
 855                 d->tty->t_stop  = cx_stop;
 856                 d->tty->t_modem = cx_tmodem;
 857                 d->tty->t_oproc = cx_oproc;
 858                 d->tty->t_sc    = d;
 859                 CX_LOCK (bd);
 860                 cx_start_chan (c, d->dmamem.virt, d->dmamem.phys);
 861                 cx_register_receive (c, &cx_receive);
 862                 cx_register_transmit (c, &cx_transmit);
 863                 cx_register_error (c, &cx_error);
 864                 cx_register_modem (c, &cx_modem);
 865                 CX_UNLOCK (bd);
 866
 867                 ttycreate(d->tty, TS_CALLOUT, "x%r%r", b->num, c->num);
 868                 d->devt = make_dev (&cx_cdevsw, b->num*NCHAN + c->num + 64, UID_ROOT, GID_WHEEL, 0600, "cx%d", b->num*NCHAN + c->num);
 869                 d->devt->si_drv1 = d;
 870                 callout_init (&d->dcd_timeout_handle, 1);
 871         }
 872         splx (s);
 873
 874         return 0;
 875 }
 876
 877 static int cx_detach (device_t dev)
 878 {
 879         bdrv_t *bd = device_get_softc (dev);
 880         cx_board_t *b = bd->board;
 881         cx_chan_t *c;
 882         int s;
 883
 884         KASSERT (mtx_initialized (&bd->cx_mtx), ("cx mutex not initialized"));
 885
 886         s = splhigh ();
 887         CX_LOCK (bd);
 888         /* Check if the device is busy (open). */
 889         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 890                 drv_t *d = (drv_t*) c->sys;
 891
 892                 if (!d || d->chan->type == T_NONE)
 893                         continue;
 894                 if (d->lock) {
 895                         CX_UNLOCK (bd);
 896                         splx (s);
 897                         return EBUSY;
 898                 }
 899                 if (c->mode == M_ASYNC && d->tty && (d->tty->t_state & TS_ISOPEN) &&
 900                     (d->open_dev|0x2)) {
 901                         CX_UNLOCK (bd);
 902                         splx (s);
 903                         return EBUSY;
 904                 }
 905                 if (d->running) {
 906                         CX_UNLOCK (bd);
 907                         splx (s);
 908                         return EBUSY;
 909                 }
 910         }
 911
 912         /* Deactivate the timeout routine. And soft interrupt*/
 913         callout_stop (&led_timo[b->num]);
 914
 915         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 916                 drv_t *d = c->sys;
 917
 918                 if (!d || d->chan->type == T_NONE)
 919                         continue;
 920
 921                 callout_stop (&d->dcd_timeout_handle);
 922         }
 923         CX_UNLOCK (bd);
 924         bus_teardown_intr (dev, bd->irq_res, bd->intrhand);
 925         bus_release_resource (dev, SYS_RES_IRQ, bd->irq_rid, bd->irq_res);
 926
 927         bus_release_resource (dev, SYS_RES_DRQ, bd->drq_rid, bd->drq_res);
 928
 929         bus_release_resource (dev, SYS_RES_IOPORT, bd->base_rid, bd->base_res);
 930
 931         CX_LOCK (bd);
 932         cx_close_board (b);
 933
 934         /* Detach the interfaces, free buffer memory. */
 935         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 936                 drv_t *d = (drv_t*) c->sys;
 937
 938                 if (!d || d->chan->type == T_NONE)
 939                         continue;
 940
 941                 if (d->tty) {
 942                         ttyfree (d->tty);
 943                         d->tty = NULL;
 944                 }
 945
 946                 callout_stop (&d->timeout_handle);
 947 #ifdef NETGRAPH
 948                 if (d->node) {
 949                         ng_rmnode_self (d->node);
 950                         NG_NODE_UNREF (d->node);
 951                         d->node = NULL;
 952                 }
 953                 mtx_destroy (&d->lo_queue.ifq_mtx);
 954                 mtx_destroy (&d->hi_queue.ifq_mtx);
 955 #else
 956                 /* Detach from the packet filter list of interfaces. */
 957                 bpfdetach (d->ifp);
 958                 /* Detach from the sync PPP list. */
 959                 sppp_detach (d->ifp);
 960
 961                 if_detach (d->ifp);
 962                 if_free(d->ifp);
 963                 /* XXXRIK: check interconnection with irq handler */
 964                 IF_DRAIN (&d->queue);
 965                 mtx_destroy (&d->queue.ifq_mtx);
 966 #endif
 967                 destroy_dev (d->devt);
 968         }
 969
 970         cx_led_off (b);
 971         CX_UNLOCK (bd);
 972         callout_drain (&led_timo[b->num]);
 973         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 974                 drv_t *d = c->sys;
 975
 976                 if (!d || d->chan->type == T_NONE)
 977                         continue;
 978
 979                 callout_drain (&d->dcd_timeout_handle);
 980                 callout_drain (&d->timeout_handle);
 981         }
 982         splx (s);
 983
 984         s = splhigh ();
 985         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 986                 drv_t *d = (drv_t*) c->sys;
 987
 988                 if (!d || d->chan->type == T_NONE)
 989                         continue;
 990
 991                 /* Deallocate buffers. */
 992                 cx_bus_dma_mem_free (&d->dmamem);
 993         }
 994         bd->board = NULL;
 995         adapter [b->num] = NULL;
 996         free (b, M_DEVBUF);
 997         splx (s);
 998
 999         mtx_destroy (&bd->cx_mtx);
1000
1001         return 0;
1002 }
1003
1004 #ifndef NETGRAPH
1005 static void cx_ifstart (struct ifnet *ifp)
1006 {
1007         drv_t *d = ifp->if_softc;
1008         bdrv_t *bd = d->board->sys;
1009
1010         CX_LOCK (bd);
1011         cx_start (d);
1012         CX_UNLOCK (bd);
1013 }
1014
1015 static void cx_tlf (struct sppp *sp)
1016 {
1017         drv_t *d = SP2IFP(sp)->if_softc;
1018
1019         CX_DEBUG (d, ("cx_tlf\n"));
1020 /*      cx_set_dtr (d->chan, 0);*/
1021 /*      cx_set_rts (d->chan, 0);*/
1022         if (!(IFP2SP(d->ifp)->pp_flags & PP_FR) && !(d->ifp->if_flags & PP_CISCO))
1023                 sp->pp_down (sp);
1024 }
1025
1026 static void cx_tls (struct sppp *sp)
1027 {
1028         drv_t *d = SP2IFP(sp)->if_softc;
1029
1030         CX_DEBUG (d, ("cx_tls\n"));
1031         if (!(IFP2SP(d->ifp)->pp_flags & PP_FR) && !(d->ifp->if_flags & PP_CISCO))
1032                 sp->pp_up (sp);
1033 }
1034
1035 /*
1036  * Initialization of interface.
1037  * It seems to be never called by upper level.
1038  */
1039 static void cx_initialize (void *softc)
1040 {
1041         drv_t *d = softc;
1042
1043         CX_DEBUG (d, ("cx_initialize\n"));
1044 }
1045
1046 /*
1047  * Process an ioctl request.
1048  */
1049 static int cx_sioctl (struct ifnet *ifp, u_long cmd, caddr_t data)
1050 {
1051         drv_t *d = ifp->if_softc;
1052         bdrv_t *bd = d->board->sys;
1053         int error, s, was_up, should_be_up;
1054
1055         /* No socket ioctls while the channel is in async mode. */
1056         if (d->chan->type == T_NONE || d->chan->mode == M_ASYNC)
1057                 return EBUSY;
1058
1059         /* Socket ioctls on slave subchannels are not allowed. */
1060         was_up = (ifp->if_drv_flags & IFF_DRV_RUNNING) != 0;
1061         error = sppp_ioctl (ifp, cmd, data);
1062         if (error)
1063                 return error;
1064
1065         s = splhigh ();
1066         CX_LOCK (bd);
1067         if (! (ifp->if_flags & IFF_DEBUG))
1068                 d->chan->debug = 0;
1069         else
1070                 d->chan->debug = d->chan->debug_shadow;
1071         CX_UNLOCK (bd);
1072         splx (s);
1073
1074         switch (cmd) {
1075         default:           CX_DEBUG2 (d, ("ioctl 0x%lx\n", cmd)); return 0;
1076         case SIOCADDMULTI: CX_DEBUG2 (d, ("SIOCADDMULTI\n"));     return 0;
1077         case SIOCDELMULTI: CX_DEBUG2 (d, ("SIOCDELMULTI\n"));     return 0;
1078         case SIOCSIFFLAGS: CX_DEBUG2 (d, ("SIOCSIFFLAGS\n"));     break;
1079         case SIOCSIFADDR:  CX_DEBUG2 (d, ("SIOCSIFADDR\n"));      break;
1080         }
1081
1082         /* We get here only in case of SIFFLAGS or SIFADDR. */
1083         s = splhigh ();
1084         CX_LOCK (bd);
1085         should_be_up = (ifp->if_drv_flags & IFF_DRV_RUNNING) != 0;
1086         if (!was_up && should_be_up) {
1087                 /* Interface goes up -- start it. */
1088                 cx_up (d);
1089                 cx_start (d);
1090         } else if (was_up && !should_be_up) {
1091                 /* Interface is going down -- stop it. */
1092                 /* if ((IFP2SP(d->ifp)->pp_flags & PP_FR) || (ifp->if_flags & PP_CISCO))*/
1093                 cx_down (d);
1094         }
1095         CX_UNLOCK (bd);
1096         splx (s);
1097         return 0;
1098 }
1099 #endif /*NETGRAPH*/
1100
1101 /*
1102  * Stop the interface.  Called on splimp().
1103  */
1104 static void cx_down (drv_t *d)
1105 {
1106         int s = splhigh ();
1107         CX_DEBUG (d, ("cx_down\n"));
1108         cx_set_dtr (d->chan, 0);
1109         cx_set_rts (d->chan, 0);
1110         d->running = 0;
1111         callout_stop (&d->timeout_handle);
1112         splx (s);
1113 }
1114
1115 /*
1116  * Start the interface.  Called on splimp().
1117  */
1118 static void cx_up (drv_t *d)
1119 {
1120         int s = splhigh ();
1121         CX_DEBUG (d, ("cx_up\n"));
1122         cx_set_dtr (d->chan, 1);
1123         cx_set_rts (d->chan, 1);
1124         d->running = 1;
1125         splx (s);
1126 }
1127
1128 /*
1129  * Start output on the (slave) interface.  Get another datagram to send
1130  * off of the interface queue, and copy it to the interface
1131  * before starting the output.
1132  */
1133 static void cx_send (drv_t *d)
1134 {
1135         struct mbuf *m;
1136         u_short len;
1137
1138         CX_DEBUG2 (d, ("cx_send\n"));
1139
1140         /* No output if the interface is down. */
1141         if (! d->running)
1142                 return;
1143
1144         /* No output if the modem is off. */
1145         if (! cx_get_dsr (d->chan) && ! cx_get_loop(d->chan))
1146                 return;
1147
1148         if (cx_buf_free (d->chan)) {
1149                 /* Get the packet to send. */
1150 #ifdef NETGRAPH
1151                 IF_DEQUEUE (&d->hi_queue, m);
1152                 if (! m)
1153                         IF_DEQUEUE (&d->lo_queue, m);
1154 #else
1155                 m = sppp_dequeue (d->ifp);
1156 #endif
1157                 if (! m)
1158                         return;
1159 #ifndef NETGRAPH
1160                 BPF_MTAP (d->ifp, m);
1161 #endif
1162                 len = m_length (m, NULL);
1163                 if (! m->m_next)
1164                         cx_send_packet (d->chan, (u_char*)mtod (m, caddr_t),
1165                                 len, 0);
1166                 else {
1167                         u_char buf [DMABUFSZ];
1168                         m_copydata (m, 0, len, buf);
1169                         cx_send_packet (d->chan, buf, len, 0);
1170                 }
1171                 m_freem (m);
1172
1173                 /* Set up transmit timeout, 10 seconds. */
1174                 d->timeout = 10;
1175         }
1176 #ifndef NETGRAPH
1177         d->ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1178 #endif
1179 }
1180
1181 /*
1182  * Start output on the interface.
1183  * Always called on splimp().
1184  */
1185 static void cx_start (drv_t *d)
1186 {
1187         int s = splhigh ();
1188         if (d->running) {
1189                 if (! d->chan->dtr)
1190                         cx_set_dtr (d->chan, 1);
1191                 if (! d->chan->rts)
1192                         cx_set_rts (d->chan, 1);
1193                 cx_send (d);
1194                 callout_reset (&d->timeout_handle, hz, cx_watchdog_timer, d);
1195         }
1196         splx (s);
1197 }
1198
1199 /*
1200  * Handle transmit timeouts.
1201  * Recover after lost transmit interrupts.
1202  * Always called on splimp().
1203  */
1204 static void cx_watchdog (drv_t *d)
1205 {
1206
1207         CX_DEBUG (d, ("device timeout\n"));
1208         if (d->running) {
1209                 cx_setup_chan (d->chan);
1210                 cx_start_chan (d->chan, 0, 0);
1211                 cx_set_dtr (d->chan, 1);
1212                 cx_set_rts (d->chan, 1);
1213                 cx_start (d);
1214         }
1215 }
1216
1217 static void cx_watchdog_timer (void *arg)
1218 {
1219         drv_t *d = arg;
1220         bdrv_t *bd = d->board->sys;
1221
1222         CX_LOCK (bd);
1223         if (d->timeout == 1)
1224                 cx_watchdog (d);
1225         if (d->timeout)
1226                 d->timeout--;
1227         callout_reset (&d->timeout_handle, hz, cx_watchdog_timer, d);
1228         CX_UNLOCK (bd);
1229 }
1230
1231 /*
1232  * Transmit callback function.
1233  */
1234 static void cx_transmit (cx_chan_t *c, void *attachment, int len)
1235 {
1236         drv_t *d = c->sys;
1237
1238         if (!d)
1239                 return;
1240
1241         if (c->mode == M_ASYNC && d->tty) {
1242                 d->tty->t_state &= ~(TS_BUSY | TS_FLUSH);
1243                 d->atimeout = 0;
1244                 if (d->tty->t_dev) {
1245                         d->intr_action |= CX_WRITE;
1246                         MY_SOFT_INTR = 1;
1247                         swi_sched (cx_fast_ih, 0);
1248                 }
1249                 return;
1250         }
1251         d->timeout = 0;
1252 #ifndef NETGRAPH
1253         if_inc_counter(d->ifp, IFCOUNTER_OPACKETS, 1);
1254         d->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1255 #endif
1256         cx_start (d);
1257 }
1258
1259 /*
1260  * Process the received packet.
1261  */
1262 static void cx_receive (cx_chan_t *c, char *data, int len)
1263 {
1264         drv_t *d = c->sys;
1265         struct mbuf *m;
1266         char *cc = data;
1267 #ifdef NETGRAPH
1268         int error;
1269 #endif
1270
1271         if (!d)
1272                 return;
1273
1274         if (c->mode == M_ASYNC && d->tty) {
1275                 if (d->tty->t_state & TS_ISOPEN) {
1276                         async_q *q = &d->aqueue;
1277                         int size = BF_SZ - 1 - AQ_GSZ (q);
1278
1279                         if (len <= 0 && !size)
1280                                 return;
1281
1282                         if (len > size) {
1283                                 c->ierrs++;
1284                                 cx_error (c, CX_OVERRUN);
1285                                 len = size - 1;
1286                         }
1287
1288                         while (len--) {
1289                                 AQ_PUSH (q, *(unsigned char *)cc);
1290                                 cc++;
1291                         }
1292
1293                         d->intr_action |= CX_READ;
1294                         MY_SOFT_INTR = 1;
1295                         swi_sched (cx_fast_ih, 0);
1296                 }
1297                 return;
1298         }
1299         if (! d->running)
1300                 return;
1301
1302         m = makembuf (data, len);
1303         if (! m) {
1304                 CX_DEBUG (d, ("no memory for packet\n"));
1305 #ifndef NETGRAPH
1306                 if_inc_counter(d->ifp, IFCOUNTER_IQDROPS, 1);
1307 #endif
1308                 return;
1309         }
1310         if (c->debug > 1)
1311                 m_print (m, 0);
1312 #ifdef NETGRAPH
1313         m->m_pkthdr.rcvif = 0;
1314         NG_SEND_DATA_ONLY (error, d->hook, m);
1315 #else
1316         if_inc_counter(d->ifp, IFCOUNTER_IPACKETS, 1);
1317         m->m_pkthdr.rcvif = d->ifp;
1318         /* Check if there's a BPF listener on this interface.
1319          * If so, hand off the raw packet to bpf. */
1320         BPF_MTAP(d->ifp, m);
1321         IF_ENQUEUE (&d->queue, m);
1322 #endif
1323 }
1324
1325 #define CONDITION(t,tp) (!(t->c_iflag & (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP | IXON))\
1326             && (!(tp->t_iflag & BRKINT) || (tp->t_iflag & IGNBRK))\
1327             && (!(tp->t_iflag & PARMRK)\
1328                 || (tp->t_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK))\
1329             && !(t->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN))\
1330             && linesw[tp->t_line]->l_rint == ttyinput)
1331
1332 /*
1333  * Error callback function.
1334  */
1335 static void cx_error (cx_chan_t *c, int data)
1336 {
1337         drv_t *d = c->sys;
1338         async_q *q;
1339
1340         if (!d)
1341                 return;
1342
1343         q = &(d->aqueue);
1344
1345         switch (data) {
1346         case CX_FRAME:
1347                 CX_DEBUG (d, ("frame error\n"));
1348                 if (c->mode == M_ASYNC && d->tty && (d->tty->t_state & TS_ISOPEN)
1349                         && (AQ_GSZ (q) < BF_SZ - 1)
1350                         && (!CONDITION((&d->tty->t_termios), (d->tty))
1351                         || !(d->tty->t_iflag & (IGNPAR | PARMRK)))) {
1352                         AQ_PUSH (q, TTY_FE);
1353                         d->intr_action |= CX_READ;
1354                         MY_SOFT_INTR = 1;
1355                         swi_sched (cx_fast_ih, 0);
1356                 }
1357 #ifndef NETGRAPH
1358                 else
1359                         if_inc_counter(d->ifp, IFCOUNTER_IERRORS, 1);
1360 #endif
1361                 break;
1362         case CX_CRC:
1363                 CX_DEBUG (d, ("crc error\n"));
1364                 if (c->mode == M_ASYNC && d->tty && (d->tty->t_state & TS_ISOPEN)
1365                         && (AQ_GSZ (q) < BF_SZ - 1)
1366                         && (!CONDITION((&d->tty->t_termios), (d->tty))
1367                         || !(d->tty->t_iflag & INPCK)
1368                         || !(d->tty->t_iflag & (IGNPAR | PARMRK)))) {
1369                         AQ_PUSH (q, TTY_PE);
1370                         d->intr_action |= CX_READ;
1371                         MY_SOFT_INTR = 1;
1372                         swi_sched (cx_fast_ih, 0);
1373                 }
1374 #ifndef NETGRAPH
1375                 else
1376                         if_inc_counter(d->ifp, IFCOUNTER_IERRORS, 1);
1377 #endif
1378                 break;
1379         case CX_OVERRUN:
1380                 CX_DEBUG (d, ("overrun error\n"));
1381 #ifdef TTY_OE
1382                 if (c->mode == M_ASYNC && d->tty && (d->tty->t_state & TS_ISOPEN)
1383                         && (AQ_GSZ (q) < BF_SZ - 1)
1384                         && (!CONDITION((&d->tty->t_termios), (d->tty)))) {
1385                         AQ_PUSH (q, TTY_OE);
1386                         d->intr_action |= CX_READ;
1387                         MY_SOFT_INTR = 1;
1388                         swi_sched (cx_fast_ih, 0);
1389                 }
1390 #endif
1391 #ifndef NETGRAPH
1392                 else {
1393                         if_inc_counter(d->ifp, IFCOUNTER_COLLISIONS, 1);
1394                         if_inc_counter(d->ifp, IFCOUNTER_IERRORS, 1);
1395                 }
1396 #endif
1397                 break;
1398         case CX_OVERFLOW:
1399                 CX_DEBUG (d, ("overflow error\n"));
1400 #ifndef NETGRAPH
1401                 if (c->mode != M_ASYNC)
1402                         if_inc_counter(d->ifp, IFCOUNTER_IERRORS, 1);
1403 #endif
1404                 break;
1405         case CX_UNDERRUN:
1406                 CX_DEBUG (d, ("underrun error\n"));
1407                 if (c->mode != M_ASYNC) {
1408                         d->timeout = 0;
1409 #ifndef NETGRAPH
1410                         if_inc_counter(d->ifp, IFCOUNTER_OERRORS, 1);
1411                         d->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1412 #endif
1413                         cx_start (d);
1414                 }
1415                 break;
1416         case CX_BREAK:
1417                 CX_DEBUG (d, ("break error\n"));
1418                 if (c->mode == M_ASYNC && d->tty && (d->tty->t_state & TS_ISOPEN)
1419                         && (AQ_GSZ (q) < BF_SZ - 1)
1420                         && (!CONDITION((&d->tty->t_termios), (d->tty))
1421                         || !(d->tty->t_iflag & (IGNBRK | BRKINT | PARMRK)))) {
1422                         AQ_PUSH (q, TTY_BI);
1423                         d->intr_action |= CX_READ;
1424                         MY_SOFT_INTR = 1;
1425                         swi_sched (cx_fast_ih, 0);
1426                 }
1427 #ifndef NETGRAPH
1428                 else
1429                         if_inc_counter(d->ifp, IFCOUNTER_IERRORS, 1);
1430 #endif
1431                 break;
1432         default:
1433                 CX_DEBUG (d, ("error #%d\n", data));
1434         }
1435 }
1436
1437 static int cx_topen (struct tty *tp, struct cdev *dev)
1438 {
1439         bdrv_t *bd;
1440         drv_t *d;
1441
1442         d = tp->t_sc;
1443         CX_DEBUG2 (d, ("cx_open (serial)\n"));
1444
1445         bd = d->board->sys;
1446
1447         if (d->chan->mode != M_ASYNC)
1448                 return (EBUSY);
1449
1450         d->open_dev |= 0x2;
1451         CX_LOCK (bd);
1452         cx_start_chan (d->chan, 0, 0);
1453         cx_set_dtr (d->chan, 1);
1454         cx_set_rts (d->chan, 1);
1455         d->cd = cx_get_cd (d->chan);
1456         CX_UNLOCK (bd);
1457
1458         CX_DEBUG2 (d, ("cx_open done\n"));
1459
1460         return 0;
1461 }
1462
1463 static void cx_tclose (struct tty *tp)
1464 {
1465         drv_t *d;
1466         bdrv_t *bd;
1467
1468         d = tp->t_sc;
1469         CX_DEBUG2 (d, ("cx_close\n"));
1470         bd = d->board->sys;
1471         CX_LOCK (bd);
1472         /* Disable receiver.
1473          * Transmitter continues sending the queued data. */
1474         cx_enable_receive (d->chan, 0);
1475         CX_UNLOCK (bd);
1476         d->open_dev &= ~0x2;
1477 }
1478
1479 static int cx_tmodem (struct tty *tp, int sigon, int sigoff)
1480 {
1481         drv_t *d;
1482         bdrv_t *bd;
1483
1484         d = tp->t_sc;
1485         bd = d->board->sys;
1486
1487         CX_LOCK (bd);
1488         if (!sigon && !sigoff) {
1489                 if (cx_get_dsr (d->chan)) sigon |= SER_DSR;
1490                 if (cx_get_cd  (d->chan)) sigon |= SER_DCD;
1491                 if (cx_get_cts (d->chan)) sigon |= SER_CTS;
1492                 if (d->chan->dtr)         sigon |= SER_DTR;
1493                 if (d->chan->rts)         sigon |= SER_RTS;
1494                 CX_UNLOCK (bd);
1495                 return sigon;
1496         }
1497
1498         if (sigon & SER_DTR)
1499                 cx_set_dtr (d->chan, 1);
1500         if (sigoff & SER_DTR)
1501                 cx_set_dtr (d->chan, 0);
1502         if (sigon & SER_RTS)
1503                 cx_set_rts (d->chan, 1);
1504         if (sigoff & SER_RTS)
1505                 cx_set_rts (d->chan, 0);
1506         CX_UNLOCK (bd);
1507
1508         return (0);
1509 }
1510
1511 static int cx_open (struct cdev *dev, int flag, int mode, struct thread *td)
1512 {
1513         int unit;
1514         drv_t *d;
1515
1516         d = dev->si_drv1;
1517         unit = d->chan->num;
1518
1519         CX_DEBUG2 (d, ("cx_open unit=%d, flag=0x%x, mode=0x%x\n",
1520                     unit, flag, mode));
1521
1522         d->open_dev |= 0x1;
1523
1524         CX_DEBUG2 (d, ("cx_open done\n"));
1525
1526         return 0;
1527 }
1528
1529 static int cx_close (struct cdev *dev, int flag, int mode, struct thread *td)
1530 {
1531         drv_t *d;
1532
1533         d = dev->si_drv1;
1534         CX_DEBUG2 (d, ("cx_close\n"));
1535         d->open_dev &= ~0x1;
1536         return 0;
1537 }
1538
1539 static int cx_modem_status (drv_t *d)
1540 {
1541         bdrv_t *bd = d->board->sys;
1542         int status = 0, s = splhigh ();
1543         CX_LOCK (bd);
1544         /* Already opened by someone or network interface is up? */
1545         if ((d->chan->mode == M_ASYNC && d->tty && (d->tty->t_state & TS_ISOPEN) &&
1546             (d->open_dev|0x2)) || (d->chan->mode != M_ASYNC && d->running))
1547                 status = TIOCM_LE;      /* always enabled while open */
1548
1549         if (cx_get_dsr (d->chan)) status |= TIOCM_DSR;
1550         if (cx_get_cd  (d->chan)) status |= TIOCM_CD;
1551         if (cx_get_cts (d->chan)) status |= TIOCM_CTS;
1552         if (d->chan->dtr)         status |= TIOCM_DTR;
1553         if (d->chan->rts)         status |= TIOCM_RTS;
1554         CX_UNLOCK (bd);
1555         splx (s);
1556         return status;
1557 }
1558
1559 static int cx_ioctl (struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
1560 {
1561         drv_t *d;
1562         bdrv_t *bd;
1563         cx_chan_t *c;
1564         struct serial_statistics *st;
1565         int error, s;
1566         char mask[16];
1567
1568         d = dev->si_drv1;
1569         c = d->chan;
1570
1571         bd = d->board->sys;
1572
1573         switch (cmd) {
1574         case SERIAL_GETREGISTERED:
1575                 CX_DEBUG2 (d, ("ioctl: getregistered\n"));
1576                 bzero (mask, sizeof(mask));
1577                 for (s=0; s<NCX*NCHAN; ++s)
1578                         if (channel [s])
1579                                 mask [s/8] |= 1 << (s & 7);
1580                 bcopy (mask, data, sizeof (mask));
1581                 return 0;
1582
1583         case SERIAL_GETPORT:
1584                 CX_DEBUG2 (d, ("ioctl: getport\n"));
1585                 s = splhigh ();
1586                 CX_LOCK (bd);
1587                 *(int *)data = cx_get_port (c);
1588                 CX_UNLOCK (bd);
1589                 splx (s);
1590                 if (*(int *)data<0)
1591                         return (EINVAL);
1592                 else
1593                         return 0;
1594
1595         case SERIAL_SETPORT:
1596                 CX_DEBUG2 (d, ("ioctl: setproto\n"));
1597                 /* Only for superuser! */
1598                 error = priv_check (td, PRIV_DRIVER);
1599                 if (error)
1600                         return error;
1601
1602                 s = splhigh ();
1603                 CX_LOCK (bd);
1604                 cx_set_port (c, *(int *)data);
1605                 CX_UNLOCK (bd);
1606                 splx (s);
1607                 return 0;
1608
1609 #ifndef NETGRAPH
1610         case SERIAL_GETPROTO:
1611                 CX_DEBUG2 (d, ("ioctl: getproto\n"));
1612                 s = splhigh ();
1613                 CX_LOCK (bd);
1614                 strcpy ((char*)data, (c->mode == M_ASYNC) ? "async" :
1615                         (IFP2SP(d->ifp)->pp_flags & PP_FR) ? "fr" :
1616                         (d->ifp->if_flags & PP_CISCO) ? "cisco" : "ppp");
1617                 CX_UNLOCK (bd);
1618                 splx (s);
1619                 return 0;
1620
1621         case SERIAL_SETPROTO:
1622                 CX_DEBUG2 (d, ("ioctl: setproto\n"));
1623                 /* Only for superuser! */
1624                 error = priv_check (td, PRIV_DRIVER);
1625                 if (error)
1626                         return error;
1627                 if (c->mode == M_ASYNC)
1628                         return EBUSY;
1629                 if (d->ifp->if_drv_flags & IFF_DRV_RUNNING)
1630                         return EBUSY;
1631                 if (! strcmp ("cisco", (char*)data)) {
1632                         IFP2SP(d->ifp)->pp_flags &= ~(PP_FR);
1633                         IFP2SP(d->ifp)->pp_flags |= PP_KEEPALIVE;
1634                         d->ifp->if_flags |= PP_CISCO;
1635                 } else if (! strcmp ("fr", (char*)data)) {
1636                         d->ifp->if_flags &= ~(PP_CISCO);
1637                         IFP2SP(d->ifp)->pp_flags |= PP_FR | PP_KEEPALIVE;
1638                 } else if (! strcmp ("ppp", (char*)data)) {
1639                         IFP2SP(d->ifp)->pp_flags &= ~(PP_FR | PP_KEEPALIVE);
1640                         d->ifp->if_flags &= ~(PP_CISCO);
1641                 } else
1642                         return EINVAL;
1643                 return 0;
1644
1645         case SERIAL_GETKEEPALIVE:
1646                 CX_DEBUG2 (d, ("ioctl: getkeepalive\n"));
1647                 if ((IFP2SP(d->ifp)->pp_flags & PP_FR) ||
1648                     (d->ifp->if_flags & PP_CISCO) ||
1649                     (c->mode == M_ASYNC))
1650                         return EINVAL;
1651                 s = splhigh ();
1652                 CX_LOCK (bd);
1653                 *(int*)data = (IFP2SP(d->ifp)->pp_flags & PP_KEEPALIVE) ? 1 : 0;
1654                 CX_UNLOCK (bd);
1655                 splx (s);
1656                 return 0;
1657
1658         case SERIAL_SETKEEPALIVE:
1659                 CX_DEBUG2 (d, ("ioctl: setkeepalive\n"));
1660                 /* Only for superuser! */
1661                 error = priv_check (td, PRIV_DRIVER);
1662                 if (error)
1663                         return error;
1664                 if ((IFP2SP(d->ifp)->pp_flags & PP_FR) ||
1665                         (d->ifp->if_flags & PP_CISCO))
1666                         return EINVAL;
1667                 s = splhigh ();
1668                 CX_LOCK (bd);
1669                 if (*(int*)data)
1670                         IFP2SP(d->ifp)->pp_flags |= PP_KEEPALIVE;
1671                 else
1672                         IFP2SP(d->ifp)->pp_flags &= ~PP_KEEPALIVE;
1673                 CX_UNLOCK (bd);
1674                 splx (s);
1675                 return 0;
1676 #endif /*NETGRAPH*/
1677
1678         case SERIAL_GETMODE:
1679                 CX_DEBUG2 (d, ("ioctl: getmode\n"));
1680                 s = splhigh ();
1681                 CX_LOCK (bd);
1682                 *(int*)data = (c->mode == M_ASYNC) ?
1683                         SERIAL_ASYNC : SERIAL_HDLC;
1684                 CX_UNLOCK (bd);
1685                 splx (s);
1686                 return 0;
1687
1688         case SERIAL_SETMODE:
1689                 CX_DEBUG2 (d, ("ioctl: setmode\n"));
1690                 /* Only for superuser! */
1691                 error = priv_check (td, PRIV_DRIVER);
1692                 if (error)
1693                         return error;
1694
1695                 /* Somebody is waiting for carrier? */
1696                 if (d->lock)
1697                         return EBUSY;
1698                 /* /dev/ttyXX is already opened by someone? */
1699                 if (c->mode == M_ASYNC && d->tty && (d->tty->t_state & TS_ISOPEN) &&
1700                     (d->open_dev|0x2))
1701                         return EBUSY;
1702                 /* Network interface is up?
1703                  * Cannot change to async mode. */
1704                 if (c->mode != M_ASYNC && d->running &&
1705                     (*(int*)data == SERIAL_ASYNC))
1706                         return EBUSY;
1707
1708                 s = splhigh ();
1709                 CX_LOCK (bd);
1710                 if (c->mode == M_HDLC && *(int*)data == SERIAL_ASYNC) {
1711                         cx_set_mode (c, M_ASYNC);
1712                         cx_enable_receive (c, 0);
1713                         cx_enable_transmit (c, 0);
1714                 } else if (c->mode == M_ASYNC && *(int*)data == SERIAL_HDLC) {
1715                         if (d->ifp->if_flags & IFF_DEBUG)
1716                                 c->debug = c->debug_shadow;
1717                         cx_set_mode (c, M_HDLC);
1718                         cx_enable_receive (c, 1);
1719                         cx_enable_transmit (c, 1);
1720                 }
1721                 CX_UNLOCK (bd);
1722                 splx (s);
1723                 return 0;
1724
1725         case SERIAL_GETSTAT:
1726                 CX_DEBUG2 (d, ("ioctl: getestat\n"));
1727                 st = (struct serial_statistics*) data;
1728                 s = splhigh ();
1729                 CX_LOCK (bd);
1730                 st->rintr  = c->rintr;
1731                 st->tintr  = c->tintr;
1732                 st->mintr  = c->mintr;
1733                 st->ibytes = c->ibytes;
1734                 st->ipkts  = c->ipkts;
1735                 st->ierrs  = c->ierrs;
1736                 st->obytes = c->obytes;
1737                 st->opkts  = c->opkts;
1738                 st->oerrs  = c->oerrs;
1739                 CX_UNLOCK (bd);
1740                 splx (s);
1741                 return 0;
1742
1743         case SERIAL_CLRSTAT:
1744                 CX_DEBUG2 (d, ("ioctl: clrstat\n"));
1745                 /* Only for superuser! */
1746                 error = priv_check (td, PRIV_DRIVER);
1747                 if (error)
1748                         return error;
1749                 s = splhigh ();
1750                 CX_LOCK (bd);
1751                 c->rintr = 0;
1752                 c->tintr = 0;
1753                 c->mintr = 0;
1754                 c->ibytes = 0;
1755                 c->ipkts = 0;
1756                 c->ierrs = 0;
1757                 c->obytes = 0;
1758                 c->opkts = 0;
1759                 c->oerrs = 0;
1760                 CX_UNLOCK (bd);
1761                 splx (s);
1762                 return 0;
1763
1764         case SERIAL_GETBAUD:
1765                 CX_DEBUG2 (d, ("ioctl: getbaud\n"));
1766                 if (c->mode == M_ASYNC)
1767                         return EINVAL;
1768                 s = splhigh ();
1769                 CX_LOCK (bd);
1770                 *(long*)data = cx_get_baud(c);
1771                 CX_UNLOCK (bd);
1772                 splx (s);
1773                 return 0;
1774
1775         case SERIAL_SETBAUD:
1776                 CX_DEBUG2 (d, ("ioctl: setbaud\n"));
1777                 /* Only for superuser! */
1778                 error = priv_check (td, PRIV_DRIVER);
1779                 if (error)
1780                         return error;
1781                 if (c->mode == M_ASYNC)
1782                         return EINVAL;
1783                 s = splhigh ();
1784                 CX_LOCK (bd);
1785                 cx_set_baud (c, *(long*)data);
1786                 CX_UNLOCK (bd);
1787                 splx (s);
1788                 return 0;
1789
1790         case SERIAL_GETLOOP:
1791                 CX_DEBUG2 (d, ("ioctl: getloop\n"));
1792                 if (c->mode == M_ASYNC)
1793                         return EINVAL;
1794                 s = splhigh ();
1795                 CX_LOCK (bd);
1796                 *(int*)data = cx_get_loop (c);
1797                 CX_UNLOCK (bd);
1798                 splx (s);
1799                 return 0;
1800
1801         case SERIAL_SETLOOP:
1802                 CX_DEBUG2 (d, ("ioctl: setloop\n"));
1803                 /* Only for superuser! */
1804                 error = priv_check (td, PRIV_DRIVER);
1805                 if (error)
1806                         return error;
1807                 if (c->mode == M_ASYNC)
1808                         return EINVAL;
1809                 s = splhigh ();
1810                 CX_LOCK (bd);
1811                 cx_set_loop (c, *(int*)data);
1812                 CX_UNLOCK (bd);
1813                 splx (s);
1814                 return 0;
1815
1816         case SERIAL_GETDPLL:
1817                 CX_DEBUG2 (d, ("ioctl: getdpll\n"));
1818                 if (c->mode == M_ASYNC)
1819                         return EINVAL;
1820                 s = splhigh ();
1821                 CX_LOCK (bd);
1822                 *(int*)data = cx_get_dpll (c);
1823                 CX_UNLOCK (bd);
1824                 splx (s);
1825                 return 0;
1826
1827         case SERIAL_SETDPLL:
1828                 CX_DEBUG2 (d, ("ioctl: setdpll\n"));
1829                 /* Only for superuser! */
1830                 error = priv_check (td, PRIV_DRIVER);
1831                 if (error)
1832                         return error;
1833                 if (c->mode == M_ASYNC)
1834                         return EINVAL;
1835                 s = splhigh ();
1836                 CX_LOCK (bd);
1837                 cx_set_dpll (c, *(int*)data);
1838                 CX_UNLOCK (bd);
1839                 splx (s);
1840                 return 0;
1841
1842         case SERIAL_GETNRZI:
1843                 CX_DEBUG2 (d, ("ioctl: getnrzi\n"));
1844                 if (c->mode == M_ASYNC)
1845                         return EINVAL;
1846                 s = splhigh ();
1847                 CX_LOCK (bd);
1848                 *(int*)data = cx_get_nrzi (c);
1849                 CX_UNLOCK (bd);
1850                 splx (s);
1851                 return 0;
1852
1853         case SERIAL_SETNRZI:
1854                 CX_DEBUG2 (d, ("ioctl: setnrzi\n"));
1855                 /* Only for superuser! */
1856                 error = priv_check (td, PRIV_DRIVER);
1857                 if (error)
1858                         return error;
1859                 if (c->mode == M_ASYNC)
1860                         return EINVAL;
1861                 s = splhigh ();
1862                 CX_LOCK (bd);
1863                 cx_set_nrzi (c, *(int*)data);
1864                 CX_UNLOCK (bd);
1865                 splx (s);
1866                 return 0;
1867
1868         case SERIAL_GETDEBUG:
1869                 CX_DEBUG2 (d, ("ioctl: getdebug\n"));
1870                 s = splhigh ();
1871                 CX_LOCK (bd);
1872                 *(int*)data = c->debug;
1873                 CX_UNLOCK (bd);
1874                 splx (s);
1875                 return 0;
1876
1877         case SERIAL_SETDEBUG:
1878                 CX_DEBUG2 (d, ("ioctl: setdebug\n"));
1879                 /* Only for superuser! */
1880                 error = priv_check (td, PRIV_DRIVER);
1881                 if (error)
1882                         return error;
1883                 s = splhigh ();
1884                 CX_LOCK (bd);
1885 #ifndef NETGRAPH
1886                 if (c->mode == M_ASYNC) {
1887                         c->debug = *(int*)data;
1888                 } else {
1889                         /*
1890                          * The debug_shadow is always greater than zero for
1891                          * logic simplicity.  For switching debug off the
1892                          * IFF_DEBUG is responsible (for !M_ASYNC mode).
1893                          */
1894                         c->debug_shadow = (*(int*)data) ? (*(int*)data) : 1;
1895                         if (d->ifp->if_flags & IFF_DEBUG)
1896                                 c->debug = c->debug_shadow;
1897                 }
1898 #else
1899                 c->debug = *(int*)data;
1900 #endif
1901                 CX_UNLOCK (bd);
1902                 splx (s);
1903                 return 0;
1904         }
1905
1906         switch (cmd) {
1907         case TIOCSDTR:  /* Set DTR */
1908                 CX_DEBUG2 (d, ("ioctl: tiocsdtr\n"));
1909                 s = splhigh ();
1910                 CX_LOCK (bd);
1911                 cx_set_dtr (c, 1);
1912                 CX_UNLOCK (bd);
1913                 splx (s);
1914                 return 0;
1915
1916         case TIOCCDTR:  /* Clear DTR */
1917                 CX_DEBUG2 (d, ("ioctl: tioccdtr\n"));
1918                 s = splhigh ();
1919                 CX_LOCK (bd);
1920                 cx_set_dtr (c, 0);
1921                 CX_UNLOCK (bd);
1922                 splx (s);
1923                 return 0;
1924
1925         case TIOCMSET:  /* Set DTR/RTS */
1926                 CX_DEBUG2 (d, ("ioctl: tiocmset\n"));
1927                 s = splhigh ();
1928                 CX_LOCK (bd);
1929                 cx_set_dtr (c, (*(int*)data & TIOCM_DTR) ? 1 : 0);
1930                 cx_set_rts (c, (*(int*)data & TIOCM_RTS) ? 1 : 0);
1931                 CX_UNLOCK (bd);
1932                 splx (s);
1933                 return 0;
1934
1935         case TIOCMBIS:  /* Add DTR/RTS */
1936                 CX_DEBUG2 (d, ("ioctl: tiocmbis\n"));
1937                 s = splhigh ();
1938                 CX_LOCK (bd);
1939                 if (*(int*)data & TIOCM_DTR) cx_set_dtr (c, 1);
1940                 if (*(int*)data & TIOCM_RTS) cx_set_rts (c, 1);
1941                 CX_UNLOCK (bd);
1942                 splx (s);
1943                 return 0;
1944
1945         case TIOCMBIC:  /* Clear DTR/RTS */
1946                 CX_DEBUG2 (d, ("ioctl: tiocmbic\n"));
1947                 s = splhigh ();
1948                 CX_LOCK (bd);
1949                 if (*(int*)data & TIOCM_DTR) cx_set_dtr (c, 0);
1950                 if (*(int*)data & TIOCM_RTS) cx_set_rts (c, 0);
1951                 CX_UNLOCK (bd);
1952                 splx (s);
1953                 return 0;
1954
1955         case TIOCMGET:  /* Get modem status */
1956                 CX_DEBUG2 (d, ("ioctl: tiocmget\n"));
1957                 *(int*)data = cx_modem_status (d);
1958                 return 0;
1959
1960         }
1961
1962         CX_DEBUG2 (d, ("ioctl: 0x%lx\n", cmd));
1963         return ENOTTY;
1964 }
1965
1966 void cx_softintr (void *unused)
1967 {
1968         drv_t *d;
1969         bdrv_t *bd;
1970         async_q *q;
1971         int i, s, ic, k;
1972         while (MY_SOFT_INTR) {
1973                 MY_SOFT_INTR = 0;
1974                 for (i=0; i<NCX*NCHAN; ++i) {
1975                         d = channel [i];
1976                         if (!d || !d->chan || d->chan->type == T_NONE
1977                             || d->chan->mode != M_ASYNC || !d->tty
1978                             || !d->tty->t_dev)
1979                                 continue;
1980                         bd = d->board->sys;
1981                         s = splhigh ();
1982                         CX_LOCK (bd);
1983                         if (d->intr_action & CX_READ) {
1984                                 q = &(d->aqueue);
1985                                 if (d->tty->t_state & TS_CAN_BYPASS_L_RINT) {
1986                                         k = AQ_GSZ(q);
1987                                         if (d->tty->t_rawq.c_cc + k >
1988                                                 d->tty->t_ihiwat
1989                                             && (d->tty->t_cflag & CRTS_IFLOW
1990                                                 || d->tty->t_iflag & IXOFF)
1991                                             && !(d->tty->t_state & TS_TBLOCK))
1992                                                 ttyblock(d->tty);
1993                                         d->tty->t_rawcc += k;
1994                                         while (k>0) {
1995                                                 k--;
1996                                                 AQ_POP (q, ic);
1997                                                 CX_UNLOCK (bd);
1998                                                 splx (s);
1999                                                 putc (ic, &d->tty->t_rawq);
2000                                                 s = splhigh ();
2001                                                 CX_LOCK (bd);
2002                                         }
2003                                         ttwakeup(d->tty);
2004                                         if (d->tty->t_state & TS_TTSTOP
2005                                             && (d->tty->t_iflag & IXANY
2006                                                 || d->tty->t_cc[VSTART] ==
2007                                                 d->tty->t_cc[VSTOP])) {
2008                                                 d->tty->t_state &= ~TS_TTSTOP;
2009                                                 d->tty->t_lflag &= ~FLUSHO;
2010                                                 d->intr_action |= CX_WRITE;
2011                                         }
2012                                 } else {
2013                                         while (q->end != q->beg) {
2014                                                 AQ_POP (q, ic);
2015                                                 CX_UNLOCK (bd);
2016                                                 splx (s);
2017                                                 ttyld_rint (d->tty, ic);
2018                                                 s = splhigh ();
2019                                                 CX_LOCK (bd);
2020                                         }
2021                                 }
2022                                 d->intr_action &= ~CX_READ;
2023                         }
2024                         splx (s);
2025                         CX_UNLOCK (bd);
2026
2027                         s = splhigh ();
2028                         CX_LOCK (bd);
2029                         if (d->intr_action & CX_WRITE) {
2030                                 if (d->tty->t_line)
2031                                         ttyld_start (d->tty);
2032                                 else
2033                                         cx_oproc (d->tty);
2034                                 d->intr_action &= ~CX_WRITE;
2035                         }
2036                         CX_UNLOCK (bd);
2037                         splx (s);
2038
2039                 }
2040         }
2041 }
2042
2043 /*
2044  * Fill transmitter buffer with data.
2045  */
2046 static void cx_oproc (struct tty *tp)
2047 {
2048         int s, k;
2049         drv_t *d;
2050         bdrv_t *bd;
2051         static u_char buf[DMABUFSZ];
2052         u_char *p;
2053         u_short len = 0, sublen = 0;
2054
2055         d = tp->t_sc;
2056         bd = d->board->sys;
2057
2058         CX_DEBUG2 (d, ("cx_oproc\n"));
2059
2060         s = splhigh ();
2061         CX_LOCK (bd);
2062
2063         if (tp->t_cflag & CRTSCTS && (tp->t_state & TS_TBLOCK) && d->chan->rts)
2064                 cx_set_rts (d->chan, 0);
2065         else if (tp->t_cflag & CRTSCTS && ! (tp->t_state & TS_TBLOCK) && ! d->chan->rts)
2066                 cx_set_rts (d->chan, 1);
2067
2068         if (! (tp->t_state & (TS_TIMEOUT | TS_TTSTOP))) {
2069                 /* Start transmitter. */
2070                 cx_enable_transmit (d->chan, 1);
2071
2072                 /* Is it busy? */
2073                 if (! cx_buf_free (d->chan)) {
2074                         tp->t_state |= TS_BUSY;
2075                         CX_UNLOCK (bd);
2076                         splx (s);
2077                         return;
2078                 }
2079                 if (tp->t_iflag & IXOFF) {
2080                         p = (buf + (DMABUFSZ/2));
2081                         sublen = q_to_b (&tp->t_outq, p, (DMABUFSZ/2));
2082                         k = sublen;
2083                         while (k--) {
2084                                 /* Send XON/XOFF out of band. */
2085                                 if (*p == tp->t_cc[VSTOP]) {
2086                                         cx_xflow_ctl (d->chan, 0);
2087                                         p++;
2088                                         continue;
2089                                 }
2090                                 if (*p == tp->t_cc[VSTART]) {
2091                                         cx_xflow_ctl (d->chan, 1);
2092                                         p++;
2093                                         continue;
2094                                 }
2095                                 buf[len] = *p;
2096                                 len++;
2097                                 p++;
2098                         }
2099                 } else {
2100                         p = buf;
2101                         len = q_to_b (&tp->t_outq, p, (DMABUFSZ/2));
2102                 }
2103                 if (len) {
2104                         cx_send_packet (d->chan, buf, len, 0);
2105                         tp->t_state |= TS_BUSY;
2106                         d->atimeout = 10;
2107                         CX_DEBUG2 (d, ("out %d bytes\n", len));
2108                 }
2109         }
2110         ttwwakeup (tp);
2111         CX_UNLOCK (bd);
2112         splx (s);
2113 }
2114
2115 static int cx_param (struct tty *tp, struct termios *t)
2116 {
2117         drv_t *d;
2118         bdrv_t *bd;
2119         int s, bits, parity;
2120
2121         d = tp->t_sc;
2122         bd = d->board->sys;
2123
2124         s = splhigh ();
2125         CX_LOCK (bd);
2126         if (t->c_ospeed == 0) {
2127                 /* Clear DTR and RTS. */
2128                 cx_set_dtr (d->chan, 0);
2129                 CX_UNLOCK (bd);
2130                 splx (s);
2131                 CX_DEBUG2 (d, ("cx_param (hangup)\n"));
2132                 return 0;
2133         }
2134         CX_DEBUG2 (d, ("cx_param\n"));
2135
2136         /* Check requested parameters. */
2137         if (t->c_ospeed < 300 || t->c_ospeed > 256*1024) {
2138                 CX_UNLOCK (bd);
2139                 splx (s);
2140                 return EINVAL;
2141         }
2142         if (t->c_ispeed && (t->c_ispeed < 300 || t->c_ispeed > 256*1024)) {
2143                 CX_UNLOCK (bd);
2144                 splx (s);
2145                 return EINVAL;
2146         }
2147
2148         /* And copy them to tty and channel structures. */
2149         tp->t_ispeed = t->c_ispeed = tp->t_ospeed = t->c_ospeed;
2150         tp->t_cflag = t->c_cflag;
2151
2152         /* Set character length and parity mode. */
2153         switch (t->c_cflag & CSIZE) {
2154         default:
2155         case CS8: bits = 8; break;
2156         case CS7: bits = 7; break;
2157         case CS6: bits = 6; break;
2158         case CS5: bits = 5; break;
2159         }
2160
2161         parity = ((t->c_cflag & PARENB) ? 1 : 0) *
2162                  (1 + ((t->c_cflag & PARODD) ? 0 : 1));
2163
2164         /* Set current channel number. */
2165         if (! d->chan->dtr)
2166                 cx_set_dtr (d->chan, 1);
2167
2168         ttyldoptim (tp);
2169         cx_set_async_param (d->chan, t->c_ospeed, bits, parity, (t->c_cflag & CSTOPB),
2170                 !(t->c_cflag & PARENB), (t->c_cflag & CRTSCTS),
2171                 (t->c_iflag & IXON), (t->c_iflag & IXANY),
2172                 t->c_cc[VSTART], t->c_cc[VSTOP]);
2173         CX_UNLOCK (bd);
2174         splx (s);
2175         return 0;
2176 }
2177
2178 /*
2179  * Stop output on a line
2180  */
2181 static void cx_stop (struct tty *tp, int flag)
2182 {
2183         drv_t *d;
2184         bdrv_t *bd;
2185         int s;
2186
2187         d = tp->t_sc;
2188         bd = d->board->sys;
2189
2190         s = splhigh ();
2191         CX_LOCK (bd);
2192         if (tp->t_state & TS_BUSY) {
2193                 /* Stop transmitter */
2194                 CX_DEBUG2 (d, ("cx_stop\n"));
2195                 cx_transmitter_ctl (d->chan, 0);
2196         }
2197         CX_UNLOCK (bd);
2198         splx (s);
2199 }
2200
2201 /*
2202  * Process the (delayed) carrier signal setup.
2203  */
2204 static void cx_carrier (void *arg)
2205 {
2206         drv_t *d = arg;
2207         bdrv_t *bd = d->board->sys;
2208         cx_chan_t *c = d->chan;
2209         int s, cd;
2210
2211         s = splhigh ();
2212         CX_LOCK (bd);
2213         cd = cx_get_cd (c);
2214         if (d->cd != cd) {
2215                 if (cd) {
2216                         CX_DEBUG (d, ("carrier on\n"));
2217                         d->cd = 1;
2218                         CX_UNLOCK (bd);
2219                         splx (s);
2220                         if (d->tty)
2221                                 ttyld_modem(d->tty, 1);
2222                 } else {
2223                         CX_DEBUG (d, ("carrier loss\n"));
2224                         d->cd = 0;
2225                         CX_UNLOCK (bd);
2226                         splx (s);
2227                         if (d->tty)
2228                                 ttyld_modem(d->tty, 0);
2229                 }
2230         } else {
2231                 CX_UNLOCK (bd);
2232                 splx (s);
2233         }
2234 }
2235
2236 /*
2237  * Modem signal callback function.
2238  */
2239 static void cx_modem (cx_chan_t *c)
2240 {
2241         drv_t *d = c->sys;
2242
2243         if (!d || c->mode != M_ASYNC)
2244                 return;
2245         /* Handle carrier detect/loss. */
2246         /* Carrier changed - delay processing DCD for a while
2247          * to give both sides some time to initialize. */
2248         callout_reset (&d->dcd_timeout_handle, hz/2, cx_carrier, d);
2249 }
2250
2251 #ifdef NETGRAPH
2252 static int ng_cx_constructor (node_p node)
2253 {
2254         drv_t *d = NG_NODE_PRIVATE (node);
2255         CX_DEBUG (d, ("Constructor\n"));
2256         return EINVAL;
2257 }
2258
2259 static int ng_cx_newhook (node_p node, hook_p hook, const char *name)
2260 {
2261         int s;
2262         drv_t *d = NG_NODE_PRIVATE (node);
2263         bdrv_t *bd = d->board->sys;
2264
2265         if (d->chan->mode == M_ASYNC)
2266                 return EINVAL;
2267
2268         /* Attach debug hook */
2269         if (strcmp (name, NG_CX_HOOK_DEBUG) == 0) {
2270                 NG_HOOK_SET_PRIVATE (hook, NULL);
2271                 d->debug_hook = hook;
2272                 return 0;
2273         }
2274
2275         /* Check for raw hook */
2276         if (strcmp (name, NG_CX_HOOK_RAW) != 0)
2277                 return EINVAL;
2278
2279         NG_HOOK_SET_PRIVATE (hook, d);
2280         d->hook = hook;
2281         s = splhigh ();
2282         CX_LOCK (bd);
2283         cx_up (d);
2284         CX_UNLOCK (bd);
2285         splx (s);
2286         return 0;
2287 }
2288
2289 static int print_modems (char *s, cx_chan_t *c, int need_header)
2290 {
2291         int status = cx_modem_status (c->sys);
2292         int length = 0;
2293
2294         if (need_header)
2295                 length += sprintf (s + length, "  LE   DTR  DSR  RTS  CTS  CD\n");
2296         length += sprintf (s + length, "%4s %4s %4s %4s %4s %4s\n",
2297                 status & TIOCM_LE  ? "On" : "-",
2298                 status & TIOCM_DTR ? "On" : "-",
2299                 status & TIOCM_DSR ? "On" : "-",
2300                 status & TIOCM_RTS ? "On" : "-",
2301                 status & TIOCM_CTS ? "On" : "-",
2302                 status & TIOCM_CD  ? "On" : "-");
2303         return length;
2304 }
2305
2306 static int print_stats (char *s, cx_chan_t *c, int need_header)
2307 {
2308         int length = 0;
2309
2310         if (need_header)
2311                 length += sprintf (s + length, "  Rintr   Tintr   Mintr   Ibytes   Ipkts   Ierrs   Obytes   Opkts   Oerrs\n");
2312         length += sprintf (s + length, "%7ld %7ld %7ld %8ld %7ld %7ld %8ld %7ld %7ld\n",
2313                 c->rintr, c->tintr, c->mintr, c->ibytes, c->ipkts,
2314                 c->ierrs, c->obytes, c->opkts, c->oerrs);
2315         return length;
2316 }
2317
2318 static int print_chan (char *s, cx_chan_t *c)
2319 {
2320         drv_t *d = c->sys;
2321         int length = 0;
2322
2323         length += sprintf (s + length, "cx%d", c->board->num * NCHAN + c->num);
2324         if (d->chan->debug)
2325                 length += sprintf (s + length, " debug=%d", d->chan->debug);
2326
2327         if (cx_get_baud (c))
2328                 length += sprintf (s + length, " %ld", cx_get_baud (c));
2329         else
2330                 length += sprintf (s + length, " extclock");
2331
2332         if (c->mode == M_HDLC) {
2333                 length += sprintf (s + length, " dpll=%s", cx_get_dpll (c) ? "on" : "off");
2334                 length += sprintf (s + length, " nrzi=%s", cx_get_nrzi (c) ? "on" : "off");
2335         }
2336
2337         length += sprintf (s + length, " loop=%s", cx_get_loop (c) ? "on\n" : "off\n");
2338         return length;
2339 }
2340
2341 static int ng_cx_rcvmsg (node_p node, item_p item, hook_p lasthook)
2342 {
2343         drv_t *d = NG_NODE_PRIVATE (node);
2344         struct ng_mesg *msg;
2345         struct ng_mesg *resp = NULL;
2346         int error = 0;
2347
2348         if (!d)
2349                 return EINVAL;
2350
2351         CX_DEBUG (d, ("Rcvmsg\n"));
2352         NGI_GET_MSG (item, msg);
2353         switch (msg->header.typecookie) {
2354         default:
2355                 error = EINVAL;
2356                 break;
2357
2358         case NGM_CX_COOKIE:
2359                 printf ("Don't forget to implement\n");
2360                 error = EINVAL;
2361                 break;
2362
2363         case NGM_GENERIC_COOKIE:
2364                 switch (msg->header.cmd) {
2365                 default:
2366                         error = EINVAL;
2367                         break;
2368
2369                 case NGM_TEXT_STATUS: {
2370                         char *s;
2371                         int l = 0;
2372                         int dl = sizeof (struct ng_mesg) + 730;
2373
2374                         NG_MKRESPONSE (resp, msg, dl, M_NOWAIT);
2375                         if (! resp) {
2376                                 error = ENOMEM;
2377                                 break;
2378                         }
2379                         bzero (resp, dl);
2380                         s = (resp)->data;
2381                         l += print_chan (s + l, d->chan);
2382                         l += print_stats (s + l, d->chan, 1);
2383                         l += print_modems (s + l, d->chan, 1);
2384                         strncpy ((resp)->header.cmdstr, "status", NG_CMDSTRSIZ);
2385                         }
2386                         break;
2387                 }
2388                 break;
2389         }
2390         NG_RESPOND_MSG (error, node, item, resp);
2391         NG_FREE_MSG (msg);
2392         return error;
2393 }
2394
2395 static int ng_cx_rcvdata (hook_p hook, item_p item)
2396 {
2397         drv_t *d = NG_NODE_PRIVATE (NG_HOOK_NODE(hook));
2398         struct mbuf *m;
2399         struct ng_tag_prio *ptag;
2400         bdrv_t *bd;
2401         struct ifqueue *q;
2402         int s;
2403
2404         NGI_GET_M (item, m);
2405         NG_FREE_ITEM (item);
2406         if (! NG_HOOK_PRIVATE (hook) || ! d) {
2407                 NG_FREE_M (m);
2408                 return ENETDOWN;
2409         }
2410
2411         bd = d->board->sys;
2412         /* Check for high priority data */
2413         if ((ptag = (struct ng_tag_prio *)m_tag_locate(m, NGM_GENERIC_COOKIE,
2414             NG_TAG_PRIO, NULL)) != NULL && (ptag->priority > NG_PRIO_CUTOFF) )
2415                 q = &d->hi_queue;
2416         else
2417                 q = &d->lo_queue;
2418
2419         s = splhigh ();
2420         CX_LOCK (bd);
2421         IF_LOCK (q);
2422         if (_IF_QFULL (q)) {
2423                 IF_UNLOCK (q);
2424                 CX_UNLOCK (bd);
2425                 splx (s);
2426                 NG_FREE_M (m);
2427                 return ENOBUFS;
2428         }
2429         _IF_ENQUEUE (q, m);
2430         IF_UNLOCK (q);
2431         cx_start (d);
2432         CX_UNLOCK (bd);
2433         splx (s);
2434         return 0;
2435 }
2436
2437 static int ng_cx_rmnode (node_p node)
2438 {
2439         drv_t *d = NG_NODE_PRIVATE (node);
2440         bdrv_t *bd;
2441
2442         CX_DEBUG (d, ("Rmnode\n"));
2443         if (d && d->running) {
2444                 int s = splhigh ();
2445                 bd = d->board->sys;
2446                 CX_LOCK (bd);
2447                 cx_down (d);
2448                 CX_UNLOCK (bd);
2449                 splx (s);
2450         }
2451 #ifdef  KLD_MODULE
2452         if (node->nd_flags & NGF_REALLY_DIE) {
2453                 NG_NODE_SET_PRIVATE (node, NULL);
2454                 NG_NODE_UNREF (node);
2455         }
2456         NG_NODE_REVIVE(node);           /* Persistent node */
2457 #endif
2458         return 0;
2459 }
2460
2461 static int ng_cx_connect (hook_p hook)
2462 {
2463         drv_t *d = NG_NODE_PRIVATE (NG_HOOK_NODE (hook));
2464
2465         callout_reset (&d->timeout_handle, hz, cx_watchdog_timer, d);
2466         return 0;
2467 }
2468
2469 static int ng_cx_disconnect (hook_p hook)
2470 {
2471         drv_t *d = NG_NODE_PRIVATE (NG_HOOK_NODE (hook));
2472         bdrv_t *bd = d->board->sys;
2473         int s;
2474
2475         s = splhigh ();
2476         CX_LOCK (bd);
2477         if (NG_HOOK_PRIVATE (hook))
2478                 cx_down (d);
2479         CX_UNLOCK (bd);
2480         splx (s);
2481         /* If we were wait it than it reasserted now, just stop it. */
2482         if (!callout_drain (&d->timeout_handle))
2483                 callout_stop (&d->timeout_handle);
2484         return 0;
2485 }
2486 #endif /*NETGRAPH*/
2487
2488 static int cx_modevent (module_t mod, int type, void *unused)
2489 {
2490         static int load_count = 0;
2491
2492         switch (type) {
2493         case MOD_LOAD:
2494 #ifdef NETGRAPH
2495                 if (ng_newtype (&typestruct))
2496                         printf ("Failed to register ng_cx\n");
2497 #endif
2498                 ++load_count;
2499
2500                 callout_init (&timeout_handle, 1);
2501                 callout_reset (&timeout_handle, hz*5, cx_timeout, 0);
2502                 /* Software interrupt. */
2503                 swi_add(&tty_intr_event, "cx", cx_softintr, NULL, SWI_TTY,
2504                     INTR_MPSAFE, &cx_fast_ih);
2505                 break;
2506         case MOD_UNLOAD:
2507                 if (load_count == 1) {
2508                         printf ("Removing device entry for Sigma\n");
2509 #ifdef NETGRAPH
2510                         ng_rmtype (&typestruct);
2511 #endif
2512                 }
2513                 /* If we were wait it than it reasserted now, just stop it. */
2514                 if (!callout_drain (&timeout_handle))
2515                         callout_stop (&timeout_handle);
2516                 swi_remove (cx_fast_ih);
2517                 --load_count;
2518                 break;
2519         case MOD_SHUTDOWN:
2520                 break;
2521         }
2522         return 0;
2523 }
2524
2525 #ifdef NETGRAPH
2526 static struct ng_type typestruct = {
2527         .version        = NG_ABI_VERSION,
2528         .name           = NG_CX_NODE_TYPE,
2529         .constructor    = ng_cx_constructor,
2530         .rcvmsg         = ng_cx_rcvmsg,
2531         .shutdown       = ng_cx_rmnode,
2532         .newhook        = ng_cx_newhook,
2533         .connect        = ng_cx_connect,
2534         .rcvdata        = ng_cx_rcvdata,
2535         .disconnect     = ng_cx_disconnect,
2536 };
2537 #endif /*NETGRAPH*/
2538
2539 #ifdef NETGRAPH
2540 MODULE_DEPEND (ng_cx, netgraph, NG_ABI_VERSION, NG_ABI_VERSION, NG_ABI_VERSION);
2541 #else
2542 MODULE_DEPEND (isa_cx, sppp, 1, 1, 1);
2543 #endif
2544 DRIVER_MODULE (cx, isa, cx_isa_driver, cx_devclass, cx_modevent, NULL);
2545 MODULE_VERSION (cx, 1);