sys/dev/ce/if_ce.c

   1 /*
   2  * Cronyx-Tau32-PCI adapter driver for FreeBSD.
   3  *
   4  * Copyright (C) 2003-2005 Cronyx Engineering.
   5  * Copyright (C) 2003-2005 Kurakin Roman, <rik@FreeBSD.org>
   6  *
   7  * This software is distributed with NO WARRANTIES, not even the implied
   8  * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   9  *
  10  * Authors grant any other persons or organisations a permission to use,
  11  * modify and redistribute this software in source and binary forms,
  12  * as long as this message is kept with the software, all derivative
  13  * works or modified versions.
  14  *
  15  * $Cronyx: if_ce.c,v 1.9.2.8 2005/11/21 14:17:44 rik Exp $
  16  */
  17
  18 #include <sys/cdefs.h>
  19 __FBSDID("$FreeBSD$");
  20
  21 #include <sys/param.h>
  22
  23 #if __FreeBSD_version >= 500000
  24 #   define NPCI 1
  25 #else
  26 #   include "pci.h"
  27 #endif
  28
  29 #if NPCI > 0
  30
  31 #include <sys/ucred.h>
  32 #include <sys/priv.h>
  33 #include <sys/proc.h>
  34 #include <sys/systm.h>
  35 #include <sys/mbuf.h>
  36 #include <sys/kernel.h>
  37 #include <sys/module.h>
  38 #include <sys/conf.h>
  39 #include <sys/malloc.h>
  40 #include <sys/socket.h>
  41 #include <sys/sockio.h>
  42 #if __FreeBSD_version >= 504000
  43 #include <sys/sysctl.h>
  44 #endif
  45 #include <sys/tty.h>
  46 #include <sys/bus.h>
  47 #include <vm/vm.h>
  48 #include <vm/pmap.h>
  49 #include <net/if.h>
  50 #include <net/if_var.h>
  51 #if __FreeBSD_version > 501000
  52 #   include <dev/pci/pcivar.h>
  53 #   include <dev/pci/pcireg.h>
  54 #else
  55 #   include <pci/pcivar.h>
  56 #   include <pci/pcireg.h>
  57 #endif
  58 #include <machine/bus.h>
  59 #include <sys/rman.h>
  60 #include "opt_ng_cronyx.h"
  61 #ifdef NETGRAPH_CRONYX
  62 #   include "opt_netgraph.h"
  63 #   ifndef NETGRAPH
  64 #       error #option   NETGRAPH missed from configuration
  65 #   endif
  66 #   include <netgraph/ng_message.h>
  67 #   include <netgraph/netgraph.h>
  68 #   include <dev/ce/ng_ce.h>
  69 #else
  70 #   include <net/if_types.h>
  71 #   include <net/if_sppp.h>
  72 #   define PP_CISCO IFF_LINK2
  73 #   include <net/bpf.h>
  74 #endif
  75 #include <dev/cx/machdep.h>
  76 #include <dev/ce/ceddk.h>
  77 #include <machine/cserial.h>
  78 #include <machine/resource.h>
  79 #include <machine/pmap.h>
  80
  81 /* If we don't have Cronyx's sppp version, we don't have fr support via sppp */
  82 #ifndef PP_FR
  83 #define PP_FR 0
  84 #endif
  85
  86 #ifndef IFP2SP
  87 #define IFP2SP(ifp)     ((struct sppp*)ifp)
  88 #endif
  89 #ifndef SP2IFP
  90 #define SP2IFP(sp)      ((struct ifnet*)sp)
  91 #endif
  92
  93 #ifndef PCIR_BAR
  94 #define PCIR_BAR(x)     (PCIR_MAPS + (x) * 4)
  95 #endif
  96
  97 /* define as our previous return value */
  98 #ifndef BUS_PROBE_DEFAULT
  99 #define BUS_PROBE_DEFAULT 0
 100 #endif
 101
 102 #define CE_DEBUG(d,s)   ({if (d->chan->debug) {\
 103                                 printf ("%s: ", d->name); printf s;}})
 104 #define CE_DEBUG2(d,s)  ({if (d->chan->debug>1) {\
 105                                 printf ("%s: ", d->name); printf s;}})
 106
 107 #ifndef CALLOUT_MPSAFE
 108 #define CALLOUT_MPSAFE          0
 109 #endif
 110
 111 #ifndef IF_DRAIN
 112 #define IF_DRAIN(ifq) do {              \
 113         struct mbuf *m;                 \
 114         for (;;) {                      \
 115                 IF_DEQUEUE(ifq, m);     \
 116                 if (m == NULL)          \
 117                         break;          \
 118                 m_freem(m);             \
 119         }                               \
 120 } while (0)
 121 #endif
 122
 123 #ifndef _IF_QLEN
 124 #define _IF_QLEN(ifq)   ((ifq)->ifq_len)
 125 #endif
 126
 127 #ifndef callout_drain
 128 #define callout_drain callout_stop
 129 #endif
 130
 131 #define CE_LOCK_NAME            "ceX"
 132
 133 #define CE_LOCK(_bd)            mtx_lock (&(_bd)->ce_mtx)
 134 #define CE_UNLOCK(_bd)          mtx_unlock (&(_bd)->ce_mtx)
 135 #define CE_LOCK_ASSERT(_bd)     mtx_assert (&(_bd)->ce_mtx, MA_OWNED)
 136
 137 #define CDEV_MAJOR      185
 138
 139 static  int ce_probe            __P((device_t));
 140 static  int ce_attach           __P((device_t));
 141 static  int ce_detach           __P((device_t));
 142
 143 static  device_method_t ce_methods[] = {
 144         /* Device interface */
 145         DEVMETHOD(device_probe,         ce_probe),
 146         DEVMETHOD(device_attach,        ce_attach),
 147         DEVMETHOD(device_detach,        ce_detach),
 148
 149         DEVMETHOD_END
 150 };
 151
 152 typedef struct _ce_dma_mem_t {
 153         unsigned long   phys;
 154         void            *virt;
 155         size_t          size;
 156 #if __FreeBSD_version >= 500000
 157         bus_dma_tag_t   dmat;
 158         bus_dmamap_t    mapp;
 159 #endif
 160 } ce_dma_mem_t;
 161
 162 typedef struct _drv_t {
 163         char    name [8];
 164         int     running;
 165         ce_board_t      *board;
 166         ce_chan_t       *chan;
 167         struct ifqueue  rqueue;
 168 #ifdef NETGRAPH
 169         char    nodename [NG_NODESIZE];
 170         hook_p  hook;
 171         hook_p  debug_hook;
 172         node_p  node;
 173         struct  ifqueue queue;
 174         struct  ifqueue hi_queue;
 175 #else
 176         struct  ifnet *ifp;
 177 #endif
 178         short   timeout;
 179         struct  callout timeout_handle;
 180 #if __FreeBSD_version >= 500000
 181         struct  cdev *devt;
 182 #else /* __FreeBSD_version < 500000 */
 183         dev_t   devt;
 184 #endif
 185         ce_dma_mem_t dmamem;
 186 } drv_t;
 187
 188 typedef struct _bdrv_t {
 189         ce_board_t      *board;
 190         struct resource *ce_res;
 191         struct resource *ce_irq;
 192         void            *ce_intrhand;
 193         ce_dma_mem_t    dmamem;
 194         drv_t           channel [NCHAN];
 195 #if __FreeBSD_version >= 504000
 196         struct mtx      ce_mtx;
 197 #endif
 198 } bdrv_t;
 199
 200 static  driver_t ce_driver = {
 201         "ce",
 202         ce_methods,
 203         sizeof(bdrv_t),
 204 };
 205
 206 static  devclass_t ce_devclass;
 207
 208 static void ce_receive (ce_chan_t *c, unsigned char *data, int len);
 209 static void ce_transmit (ce_chan_t *c, void *attachment, int len);
 210 static void ce_error (ce_chan_t *c, int data);
 211 static void ce_up (drv_t *d);
 212 static void ce_start (drv_t *d);
 213 static void ce_down (drv_t *d);
 214 static void ce_watchdog (drv_t *d);
 215 static void ce_watchdog_timer (void *arg);
 216 #ifdef NETGRAPH
 217 extern struct ng_type typestruct;
 218 #else
 219 static void ce_ifstart (struct ifnet *ifp);
 220 static void ce_tlf (struct sppp *sp);
 221 static void ce_tls (struct sppp *sp);
 222 static int ce_sioctl (struct ifnet *ifp, u_long cmd, caddr_t data);
 223 static void ce_initialize (void *softc);
 224 #endif
 225
 226 static ce_board_t *adapter [NBRD];
 227 static drv_t *channel [NBRD*NCHAN];
 228 static struct callout led_timo [NBRD];
 229 static struct callout timeout_handle;
 230
 231 static int ce_destroy = 0;
 232
 233 #if __FreeBSD_version < 500000
 234 static int ce_open (dev_t dev, int oflags, int devtype, struct proc *p);
 235 static int ce_close (dev_t dev, int fflag, int devtype, struct proc *p);
 236 static int ce_ioctl (dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p);
 237 #else
 238 static int ce_open (struct cdev *dev, int oflags, int devtype, struct thread *td);
 239 static int ce_close (struct cdev *dev, int fflag, int devtype, struct thread *td);
 240 static int ce_ioctl (struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td);
 241 #endif
 242 #if __FreeBSD_version < 500000
 243 static struct cdevsw ce_cdevsw = {
 244         ce_open,        ce_close,       noread,         nowrite,
 245         ce_ioctl,       nopoll,         nommap,         nostrategy,
 246         "ce",           CDEV_MAJOR,     nodump,         nopsize,
 247         D_NAGGED,       -1
 248         };
 249 #elif __FreeBSD_version == 500000
 250 static struct cdevsw ce_cdevsw = {
 251         ce_open,        ce_close,       noread,         nowrite,
 252         ce_ioctl,       nopoll,         nommap,         nostrategy,
 253         "ce",           CDEV_MAJOR,     nodump,         nopsize,
 254         D_NAGGED,
 255         };
 256 #elif __FreeBSD_version <= 501000
 257 static struct cdevsw ce_cdevsw = {
 258         .d_open     = ce_open,
 259         .d_close    = ce_close,
 260         .d_read     = noread,
 261         .d_write    = nowrite,
 262         .d_ioctl    = ce_ioctl,
 263         .d_poll     = nopoll,
 264         .d_mmap     = nommap,
 265         .d_strategy = nostrategy,
 266         .d_name     = "ce",
 267         .d_maj      = CDEV_MAJOR,
 268         .d_dump     = nodump,
 269         .d_flags    = D_NAGGED,
 270 };
 271 #elif __FreeBSD_version < 502103
 272 static struct cdevsw ce_cdevsw = {
 273         .d_open     = ce_open,
 274         .d_close    = ce_close,
 275         .d_ioctl    = ce_ioctl,
 276         .d_name     = "ce",
 277         .d_maj      = CDEV_MAJOR,
 278         .d_flags    = D_NAGGED,
 279 };
 280 #elif __FreeBSD_version < 600000
 281 static struct cdevsw ce_cdevsw = {
 282         .d_version  = D_VERSION,
 283         .d_open     = ce_open,
 284         .d_close    = ce_close,
 285         .d_ioctl    = ce_ioctl,
 286         .d_name     = "ce",
 287         .d_maj      = CDEV_MAJOR,
 288         .d_flags    = D_NEEDGIANT,
 289 };
 290 #else /* __FreeBSD_version >= 600000 */
 291 static struct cdevsw ce_cdevsw = {
 292         .d_version  = D_VERSION,
 293         .d_open     = ce_open,
 294         .d_close    = ce_close,
 295         .d_ioctl    = ce_ioctl,
 296         .d_name     = "ce",
 297 };
 298 #endif
 299
 300 /*
 301  * Make an mbuf from data.
 302  */
 303 static struct mbuf *makembuf (void *buf, unsigned len)
 304 {
 305         struct mbuf *m;
 306
 307         MGETHDR (m, M_NOWAIT, MT_DATA);
 308         if (! m)
 309                 return 0;
 310         MCLGET (m, M_NOWAIT);
 311         if (! (m->m_flags & M_EXT)) {
 312                 m_freem (m);
 313                 return 0;
 314         }
 315         m->m_pkthdr.len = m->m_len = len;
 316         bcopy (buf, mtod (m, caddr_t), len);
 317         return m;
 318 }
 319
 320 static int ce_probe (device_t dev)
 321 {
 322         if ((pci_get_vendor (dev) == TAU32_PCI_VENDOR_ID) &&
 323             (pci_get_device (dev) == TAU32_PCI_DEVICE_ID)) {
 324                 device_set_desc (dev, "Cronyx-Tau32-PCI serial adapter");
 325                 return BUS_PROBE_DEFAULT;
 326         }
 327         return ENXIO;
 328 }
 329
 330 static void ce_timeout (void *arg)
 331 {
 332         drv_t *d;
 333         int s, i, k;
 334
 335         for (i = 0; i < NBRD; ++i) {
 336                 if (adapter[i] == NULL)
 337                         continue;
 338                 for (k = 0; k < NCHAN; ++k) {
 339                         s = splimp ();
 340                         if (ce_destroy) {
 341                                 splx (s);
 342                                 return;
 343                         }
 344                         d = channel[i * NCHAN + k];
 345                         if (!d) {
 346                                 splx (s);
 347                                 continue;
 348                         }
 349                         CE_LOCK ((bdrv_t *)d->board->sys);
 350                         switch (d->chan->type) {
 351                         case T_E1:
 352                                 ce_e1_timer (d->chan);
 353                                 break;
 354                         default:
 355                                 break;
 356                         }
 357                         CE_UNLOCK ((bdrv_t *)d->board->sys);
 358                         splx (s);
 359                 }
 360         }
 361         s = splimp ();
 362         if (!ce_destroy)
 363                 callout_reset (&timeout_handle, hz, ce_timeout, 0);
 364         splx (s);
 365 }
 366
 367 static void ce_led_off (void *arg)
 368 {
 369         ce_board_t *b = arg;
 370         bdrv_t *bd = (bdrv_t *) b->sys;
 371         int s;
 372         s = splimp ();
 373         if (ce_destroy) {
 374                 splx (s);
 375                 return;
 376         }
 377         CE_LOCK (bd);
 378         TAU32_LedSet (b->ddk.pControllerObject, 0);
 379         CE_UNLOCK (bd);
 380         splx (s);
 381 }
 382
 383 static void ce_intr (void *arg)
 384 {
 385         bdrv_t *bd = arg;
 386         ce_board_t *b = bd->board;
 387         int s;
 388         int i;
 389 #if __FreeBSD_version >= 500000 && defined NETGRAPH
 390         int error;
 391 #endif
 392         s = splimp ();
 393         if (ce_destroy) {
 394                 splx (s);
 395                 return;
 396         }
 397         CE_LOCK (bd);
 398         /* Turn LED on. */
 399         TAU32_LedSet (b->ddk.pControllerObject, 1);
 400
 401         TAU32_HandleInterrupt (b->ddk.pControllerObject);
 402
 403         /* Turn LED off 50 msec later. */
 404         callout_reset (&led_timo[b->num], hz/20, ce_led_off, b);
 405         CE_UNLOCK (bd);
 406         splx (s);
 407
 408         /* Pass packets in a lock-free state */
 409         for (i = 0; i < NCHAN && b->chan[i].type; i++) {
 410                 drv_t *d = b->chan[i].sys;
 411                 struct mbuf *m;
 412                 if (!d || !d->running)
 413                         continue;
 414                 while (_IF_QLEN(&d->rqueue)) {
 415                         IF_DEQUEUE (&d->rqueue,m);
 416                         if (!m)
 417                                 continue;
 418 #ifdef NETGRAPH
 419                         if (d->hook) {
 420 #if __FreeBSD_version >= 500000
 421                                 NG_SEND_DATA_ONLY (error, d->hook, m);
 422 #else
 423                                 ng_queue_data (d->hook, m, 0);
 424 #endif
 425                         } else {
 426                                 IF_DRAIN (&d->rqueue);
 427                         }
 428 #else
 429                         sppp_input (d->ifp, m);
 430 #endif
 431                 }
 432         }
 433 }
 434
 435 #if __FreeBSD_version >= 500000
 436 static void
 437 ce_bus_dmamap_addr (void *arg, bus_dma_segment_t *segs, int nseg, int error)
 438 {
 439         unsigned long *addr;
 440
 441         if (error)
 442                 return;
 443
 444         KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg));
 445         addr = arg;
 446         *addr = segs->ds_addr;
 447 }
 448
 449 #ifndef BUS_DMA_ZERO
 450 #define BUS_DMA_ZERO 0
 451 #endif
 452
 453 static int
 454 ce_bus_dma_mem_alloc (int bnum, int cnum, ce_dma_mem_t *dmem)
 455 {
 456         int error;
 457
 458         error = bus_dma_tag_create (NULL, 16, 0, BUS_SPACE_MAXADDR_32BIT,
 459                 BUS_SPACE_MAXADDR, NULL, NULL, dmem->size, 1,
 460                 dmem->size, 0,
 461 #if __FreeBSD_version >= 502000
 462                 NULL, NULL,
 463 #endif
 464                 &dmem->dmat);
 465         if (error) {
 466                 if (cnum >= 0)  printf ("ce%d-%d: ", bnum, cnum);
 467                 else            printf ("ce%d: ", bnum);
 468                 printf ("couldn't allocate tag for dma memory\n");
 469                 return 0;
 470         }
 471         error = bus_dmamem_alloc (dmem->dmat, (void **)&dmem->virt,
 472                 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &dmem->mapp);
 473         if (error) {
 474                 if (cnum >= 0)  printf ("ce%d-%d: ", bnum, cnum);
 475                 else            printf ("ce%d: ", bnum);
 476                 printf ("couldn't allocate mem for dma memory\n");
 477                 bus_dma_tag_destroy (dmem->dmat);
 478                 return 0;
 479         }
 480         error = bus_dmamap_load (dmem->dmat, dmem->mapp, dmem->virt,
 481                 dmem->size, ce_bus_dmamap_addr, &dmem->phys, 0);
 482         if (error) {
 483                 if (cnum >= 0)  printf ("ce%d-%d: ", bnum, cnum);
 484                 else            printf ("ce%d: ", bnum);
 485                 printf ("couldn't load mem map for dma memory\n");
 486                 bus_dmamem_free (dmem->dmat, dmem->virt, dmem->mapp);
 487                 bus_dma_tag_destroy (dmem->dmat);
 488                 return 0;
 489         }
 490 #if __FreeBSD_version >= 502000
 491         bzero (dmem->virt, dmem->size);
 492 #endif
 493         return 1;
 494 }
 495
 496 static void
 497 ce_bus_dma_mem_free (ce_dma_mem_t *dmem)
 498 {
 499         bus_dmamap_unload (dmem->dmat, dmem->mapp);
 500         bus_dmamem_free (dmem->dmat, dmem->virt, dmem->mapp);
 501         bus_dma_tag_destroy (dmem->dmat);
 502 }
 503 #else
 504 static int
 505 ce_bus_dma_mem_alloc (int bnum, int cnum, ce_dma_mem_t *dmem)
 506 {
 507         dmem->virt = contigmalloc (dmem->size, M_DEVBUF, M_WAITOK,
 508                                    0x100000, 0xffffffff, 16, 0);
 509         if (dmem->virt == NULL) {
 510                 if (cnum >= 0)  printf ("ce%d-%d: ", bnum, cnum);
 511                 else            printf ("ce%d: ", bnum);
 512                 printf ("couldn't allocate dma memory\n");
 513                 return 0;
 514         }
 515         dmem->phys = vtophys (dmem->virt);
 516         bzero (dmem->virt, dmem->size);
 517         return 1;
 518 }
 519
 520 static void
 521 ce_bus_dma_mem_free (ce_dma_mem_t *dmem)
 522 {
 523         contigfree (dmem->virt, dmem->size, M_DEVBUF);
 524 }
 525 #endif
 526
 527 /*
 528  * Called if the probe succeeded.
 529  */
 530 static int ce_attach (device_t dev)
 531 {
 532         bdrv_t *bd = device_get_softc (dev);
 533         int unit = device_get_unit (dev);
 534 #if __FreeBSD_version >= 504000
 535         char *ce_ln = CE_LOCK_NAME;
 536 #endif
 537         vm_offset_t vbase;
 538         int rid, error;
 539         ce_board_t *b;
 540         ce_chan_t *c;
 541         drv_t *d;
 542         int s;
 543
 544         b = malloc (sizeof(ce_board_t), M_DEVBUF, M_WAITOK);
 545         if (!b) {
 546                 printf ("ce%d: couldn't allocate memory\n", unit);
 547                 return (ENXIO);
 548         }
 549         bzero (b, sizeof(ce_board_t));
 550
 551         b->ddk.sys = &b;
 552
 553 #if __FreeBSD_version >= 440000
 554         pci_enable_busmaster (dev);
 555 #endif
 556
 557         bd->dmamem.size = TAU32_ControllerObjectSize;
 558         if (! ce_bus_dma_mem_alloc (unit, -1, &bd->dmamem)) {
 559                 free (b, M_DEVBUF);
 560                 return (ENXIO);
 561         }
 562         b->ddk.pControllerObject = bd->dmamem.virt;
 563
 564         bd->board = b;
 565         b->sys = bd;
 566         rid = PCIR_BAR(0);
 567         bd->ce_res = bus_alloc_resource (dev, SYS_RES_MEMORY, &rid,
 568                         0, ~0, 1, RF_ACTIVE);
 569         if (! bd->ce_res) {
 570                 printf ("ce%d: cannot map memory\n", unit);
 571                 ce_bus_dma_mem_free (&bd->dmamem);
 572                 free (b, M_DEVBUF);
 573                 return (ENXIO);
 574         }
 575         vbase = (vm_offset_t) rman_get_virtual (bd->ce_res);
 576
 577         b->ddk.PciBar1VirtualAddress = (void *)vbase;
 578         b->ddk.ControllerObjectPhysicalAddress = bd->dmamem.phys;
 579         b->ddk.pErrorNotifyCallback = ce_error_callback;
 580         b->ddk.pStatusNotifyCallback = ce_status_callback;
 581         b->num = unit;
 582
 583         TAU32_BeforeReset(&b->ddk);
 584         pci_write_config (dev, TAU32_PCI_RESET_ADDRESS, TAU32_PCI_RESET_ON, 4);
 585         pci_write_config (dev, TAU32_PCI_RESET_ADDRESS, TAU32_PCI_RESET_OFF, 4);
 586
 587         if(!TAU32_Initialize(&b->ddk, 0))
 588         {
 589                 printf ("ce%d: init adapter error 0x%08x, bus dead bits 0x%08lx\n",
 590                         unit, b->ddk.InitErrors, b->ddk.DeadBits);
 591                 bus_release_resource (dev, SYS_RES_MEMORY, PCIR_BAR(0), bd->ce_res);
 592                 ce_bus_dma_mem_free (&bd->dmamem);
 593                 free (b, M_DEVBUF);
 594                 return (ENXIO);
 595         }
 596
 597         s = splimp ();
 598
 599         ce_init_board (b);
 600
 601         rid = 0;
 602         bd->ce_irq = bus_alloc_resource (dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
 603                         RF_SHAREABLE | RF_ACTIVE);
 604         if (! bd->ce_irq) {
 605                 printf ("ce%d: cannot map interrupt\n", unit);
 606                 bus_release_resource (dev, SYS_RES_MEMORY, PCIR_BAR(0), bd->ce_res);
 607                 ce_bus_dma_mem_free (&bd->dmamem);
 608                 free (b, M_DEVBUF);
 609                 splx (s);
 610                 return (ENXIO);
 611         }
 612 #if __FreeBSD_version >= 500000
 613         callout_init (&led_timo[unit], CALLOUT_MPSAFE);
 614 #else
 615         callout_init (&led_timo[unit]);
 616 #endif
 617         error  = bus_setup_intr (dev, bd->ce_irq,
 618 #if __FreeBSD_version >= 500013
 619                                 INTR_TYPE_NET|INTR_MPSAFE,
 620 #else
 621                                 INTR_TYPE_NET,
 622 #endif
 623                                 NULL, ce_intr, bd, &bd->ce_intrhand);
 624         if (error) {
 625                 printf ("ce%d: cannot set up irq\n", unit);
 626                 bus_release_resource (dev, SYS_RES_IRQ, 0, bd->ce_irq);
 627                 bus_release_resource (dev, SYS_RES_MEMORY,
 628                                 PCIR_BAR(0), bd->ce_res);
 629                 ce_bus_dma_mem_free (&bd->dmamem);
 630                 free (b, M_DEVBUF);
 631                 splx (s);
 632                 return (ENXIO);
 633         }
 634
 635         switch (b->ddk.Model) {
 636         case 1:         strcpy (b->name, TAU32_BASE_NAME);      break;
 637         case 2:         strcpy (b->name, TAU32_LITE_NAME);      break;
 638         case 3:         strcpy (b->name, TAU32_ADPCM_NAME);     break;
 639         default:        strcpy (b->name, TAU32_UNKNOWN_NAME);   break;
 640         }
 641
 642         printf ("ce%d: %s\n", unit, b->name);
 643
 644         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 645                 c->num = (c - b->chan);
 646                 c->board = b;
 647
 648                 d = &bd->channel[c->num];
 649                 d->dmamem.size = sizeof(ce_buf_t);
 650                 if (! ce_bus_dma_mem_alloc (unit, c->num, &d->dmamem))
 651                         continue;
 652
 653                 channel [b->num * NCHAN + c->num] = d;
 654                 sprintf (d->name, "ce%d.%d", b->num, c->num);
 655                 d->board = b;
 656                 d->chan = c;
 657                 c->sys = d;
 658         }
 659
 660         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 661                 if (c->sys == NULL)
 662                         continue;
 663                 d = c->sys;
 664
 665                 callout_init (&d->timeout_handle, CALLOUT_MPSAFE);
 666 #ifdef NETGRAPH
 667                 if (ng_make_node_common (&typestruct, &d->node) != 0) {
 668                         printf ("%s: cannot make common node\n", d->name);
 669                         d->node = NULL;
 670                         continue;
 671                 }
 672 #if __FreeBSD_version >= 500000
 673                 NG_NODE_SET_PRIVATE (d->node, d);
 674 #else
 675                 d->node->private = d;
 676 #endif
 677                 sprintf (d->nodename, "%s%d", NG_CE_NODE_TYPE,
 678                          c->board->num * NCHAN + c->num);
 679                 if (ng_name_node (d->node, d->nodename)) {
 680                         printf ("%s: cannot name node\n", d->nodename);
 681 #if __FreeBSD_version >= 500000
 682                         NG_NODE_UNREF (d->node);
 683 #else
 684                         ng_rmnode (d->node);
 685                         ng_unref (d->node);
 686 #endif
 687                         continue;
 688                 }
 689                 d->queue.ifq_maxlen     = ifqmaxlen;
 690                 d->hi_queue.ifq_maxlen  = ifqmaxlen;
 691                 d->rqueue.ifq_maxlen    = ifqmaxlen;
 692 #if __FreeBSD_version >= 500000
 693                 mtx_init (&d->queue.ifq_mtx, "ce_queue", NULL, MTX_DEF);
 694                 mtx_init (&d->hi_queue.ifq_mtx, "ce_queue_hi", NULL, MTX_DEF);
 695                 mtx_init (&d->rqueue.ifq_mtx, "ce_rqueue", NULL, MTX_DEF);
 696 #endif
 697 #else /*NETGRAPH*/
 698 #if __FreeBSD_version >= 600031
 699                 d->ifp = if_alloc(IFT_PPP);
 700 #else
 701                 d->ifp = malloc (sizeof(struct sppp), M_DEVBUF, M_WAITOK);
 702                 bzero (d->ifp, sizeof(struct sppp));
 703 #endif
 704                 if (!d->ifp) {
 705                         printf ("%s: cannot if_alloc() interface\n", d->name);
 706                         continue;
 707                 }
 708                 d->ifp->if_softc        = d;
 709 #if __FreeBSD_version > 501000
 710                 if_initname (d->ifp, "ce", b->num * NCHAN + c->num);
 711 #else
 712                 d->ifp->if_unit         = b->num * NCHAN + c->num;
 713                 d->ifp->if_name         = "ce";
 714 #endif
 715                 d->ifp->if_mtu          = PP_MTU;
 716                 d->ifp->if_flags        = IFF_POINTOPOINT | IFF_MULTICAST;
 717                 d->ifp->if_ioctl        = ce_sioctl;
 718                 d->ifp->if_start        = ce_ifstart;
 719                 d->ifp->if_init         = ce_initialize;
 720                 d->rqueue.ifq_maxlen    = ifqmaxlen;
 721 #if __FreeBSD_version >= 500000
 722                 mtx_init (&d->rqueue.ifq_mtx, "ce_rqueue", NULL, MTX_DEF);
 723 #endif
 724                 sppp_attach (d->ifp);
 725                 if_attach (d->ifp);
 726                 IFP2SP(d->ifp)->pp_tlf  = ce_tlf;
 727                 IFP2SP(d->ifp)->pp_tls  = ce_tls;
 728                 /* If BPF is in the kernel, call the attach for it.
 729                  * The header size of PPP or Cisco/HDLC is 4 bytes. */
 730                 bpfattach (d->ifp, DLT_PPP, 4);
 731 #endif /*NETGRAPH*/
 732                 ce_start_chan (c, 1, 1, d->dmamem.virt, d->dmamem.phys);
 733
 734                 /* Register callback functions. */
 735                 ce_register_transmit (c, &ce_transmit);
 736                 ce_register_receive (c, &ce_receive);
 737                 ce_register_error (c, &ce_error);
 738                 d->devt = make_dev (&ce_cdevsw, b->num*NCHAN+c->num, UID_ROOT,
 739                                 GID_WHEEL, 0600, "ce%d", b->num*NCHAN+c->num);
 740         }
 741
 742 #if __FreeBSD_version >= 504000
 743         ce_ln[2] = '0' + unit;
 744         mtx_init (&bd->ce_mtx, ce_ln, MTX_NETWORK_LOCK, MTX_DEF|MTX_RECURSE);
 745 #endif
 746         CE_LOCK (bd);
 747         TAU32_EnableInterrupts(b->ddk.pControllerObject);
 748         adapter[unit] = b;
 749         CE_UNLOCK (bd);
 750         splx (s);
 751
 752         return 0;
 753 }
 754
 755 static int ce_detach (device_t dev)
 756 {
 757         bdrv_t *bd = device_get_softc (dev);
 758         ce_board_t *b = bd->board;
 759         ce_chan_t *c;
 760         int s;
 761
 762 #if __FreeBSD_version >= 504000
 763         KASSERT (mtx_initialized (&bd->ce_mtx), ("ce mutex not initialized"));
 764 #endif
 765         s = splimp ();
 766         CE_LOCK (bd);
 767         /* Check if the device is busy (open). */
 768         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 769                 drv_t *d = (drv_t*) c->sys;
 770
 771                 /* XXX Non existen chan! */
 772                 if (! d || ! d->chan)
 773                         continue;
 774                 if (d->running) {
 775                         CE_UNLOCK (bd);
 776                         splx (s);
 777                         return EBUSY;
 778                 }
 779         }
 780
 781         /* Ok, we can unload driver */
 782         /* At first we should disable interrupts */
 783         ce_destroy = 1;
 784         TAU32_DisableInterrupts(b->ddk.pControllerObject);
 785
 786         callout_stop (&led_timo[b->num]);
 787
 788         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 789                 drv_t *d = (drv_t*) c->sys;
 790
 791                 if (! d || ! d->chan)
 792                         continue;
 793                 callout_stop (&d->timeout_handle);
 794 #ifndef NETGRAPH
 795                 /* Detach from the packet filter list of interfaces. */
 796                 bpfdetach (d->ifp);
 797
 798                 /* Detach from the sync PPP list. */
 799                 sppp_detach (d->ifp);
 800
 801                 /* Detach from the system list of interfaces. */
 802                 if_detach (d->ifp);
 803 #if __FreeBSD_version > 600031
 804                 if_free(d->ifp);
 805 #else
 806                 free (d->ifp, M_DEVBUF);
 807 #endif
 808
 809                 IF_DRAIN (&d->rqueue);
 810 #if __FreeBSD_version >= 500000
 811                 mtx_destroy (&d->rqueue.ifq_mtx);
 812 #endif
 813 #else
 814 #if __FreeBSD_version >= 500000
 815                 if (d->node) {
 816                         ng_rmnode_self (d->node);
 817                         NG_NODE_UNREF (d->node);
 818                         d->node = NULL;
 819                 }
 820                 IF_DRAIN (&d->rqueue);
 821                 mtx_destroy (&d->queue.ifq_mtx);
 822                 mtx_destroy (&d->hi_queue.ifq_mtx);
 823                 mtx_destroy (&d->rqueue.ifq_mtx);
 824 #else
 825                 ng_rmnode (d->node);
 826                 d->node = 0;
 827 #endif
 828 #endif
 829                 destroy_dev (d->devt);
 830         }
 831
 832         CE_UNLOCK (bd);
 833         splx (s);
 834
 835         callout_drain (&led_timo[b->num]);
 836
 837         /* Disable the interrupt request. */
 838         bus_teardown_intr (dev, bd->ce_irq, bd->ce_intrhand);
 839         bus_release_resource (dev, SYS_RES_IRQ, 0, bd->ce_irq);
 840         TAU32_DestructiveHalt (b->ddk.pControllerObject, 0);
 841         bus_release_resource (dev, SYS_RES_MEMORY, PCIR_BAR(0), bd->ce_res);
 842
 843         for (c = b->chan; c < b->chan + NCHAN; ++c) {
 844                 drv_t *d = (drv_t*) c->sys;
 845
 846                 if (! d || ! d->chan)
 847                         continue;
 848                 callout_drain (&d->timeout_handle);
 849                 channel [b->num * NCHAN + c->num] = 0;
 850                 /* Deallocate buffers. */
 851                 ce_bus_dma_mem_free (&d->dmamem);
 852         }
 853         adapter [b->num] = 0;
 854         ce_bus_dma_mem_free (&bd->dmamem);
 855         free (b, M_DEVBUF);
 856 #if __FreeBSD_version >= 504000
 857         mtx_destroy (&bd->ce_mtx);
 858 #endif
 859         return 0;
 860 }
 861
 862 #ifndef NETGRAPH
 863 static void ce_ifstart (struct ifnet *ifp)
 864 {
 865         drv_t *d = ifp->if_softc;
 866         bdrv_t *bd = d->board->sys;
 867
 868         CE_LOCK (bd);
 869         ce_start (d);
 870         CE_UNLOCK (bd);
 871 }
 872
 873 static void ce_tlf (struct sppp *sp)
 874 {
 875         drv_t *d = SP2IFP(sp)->if_softc;
 876
 877         CE_DEBUG2 (d, ("ce_tlf\n"));
 878         sp->pp_down (sp);
 879 }
 880
 881 static void ce_tls (struct sppp *sp)
 882 {
 883         drv_t *d = SP2IFP(sp)->if_softc;
 884
 885         CE_DEBUG2 (d, ("ce_tls\n"));
 886         sp->pp_up (sp);
 887 }
 888
 889 /*
 890  * Process an ioctl request.
 891  */
 892 static int ce_sioctl (struct ifnet *ifp, u_long cmd, caddr_t data)
 893 {
 894         drv_t *d = ifp->if_softc;
 895         bdrv_t *bd = d->board->sys;
 896         int error, s, was_up, should_be_up;
 897
 898 #if __FreeBSD_version >= 600034
 899         was_up = (ifp->if_drv_flags & IFF_DRV_RUNNING) != 0;
 900 #else
 901         was_up = (ifp->if_flags & IFF_RUNNING) != 0;
 902 #endif
 903         error = sppp_ioctl (ifp, cmd, data);
 904
 905         if (error)
 906                 return error;
 907
 908         if (! (ifp->if_flags & IFF_DEBUG))
 909                 d->chan->debug = 0;
 910         else
 911                 d->chan->debug = d->chan->debug_shadow;
 912
 913         switch (cmd) {
 914         default:           CE_DEBUG2 (d, ("ioctl 0x%lx\n", cmd));   return 0;
 915         case SIOCADDMULTI: CE_DEBUG2 (d, ("ioctl SIOCADDMULTI\n")); return 0;
 916         case SIOCDELMULTI: CE_DEBUG2 (d, ("ioctl SIOCDELMULTI\n")); return 0;
 917         case SIOCSIFFLAGS: CE_DEBUG2 (d, ("ioctl SIOCSIFFLAGS\n")); break;
 918         case SIOCSIFADDR:  CE_DEBUG2 (d, ("ioctl SIOCSIFADDR\n"));  break;
 919         }
 920
 921         /* We get here only in case of SIFFLAGS or SIFADDR. */
 922         s = splimp ();
 923         CE_LOCK (bd);
 924 #if __FreeBSD_version >= 600034
 925         should_be_up = (ifp->if_drv_flags & IFF_DRV_RUNNING) != 0;
 926 #else
 927         should_be_up = (ifp->if_flags & IFF_RUNNING) != 0;
 928 #endif
 929         if (! was_up && should_be_up) {
 930                 /* Interface goes up -- start it. */
 931                 ce_up (d);
 932                 ce_start (d);
 933         } else if (was_up && ! should_be_up) {
 934                 /* Interface is going down -- stop it. */
 935 /*              if ((IFP2SP(ifp)->pp_flags & PP_FR) || (ifp->if_flags & PP_CISCO))*/
 936                 ce_down (d);
 937         }
 938         CE_DEBUG (d, ("ioctl 0x%lx p4\n", cmd));
 939         CE_UNLOCK (bd);
 940         splx (s);
 941         return 0;
 942 }
 943
 944 /*
 945  * Initialization of interface.
 946  * It seems to be never called by upper level?
 947  */
 948 static void ce_initialize (void *softc)
 949 {
 950         drv_t *d = softc;
 951
 952         CE_DEBUG (d, ("ce_initialize\n"));
 953 }
 954 #endif /*NETGRAPH*/
 955
 956 /*
 957  * Stop the interface.  Called on splimp().
 958  */
 959 static void ce_down (drv_t *d)
 960 {
 961         CE_DEBUG (d, ("ce_down\n"));
 962         /* Interface is going down -- stop it. */
 963         ce_set_dtr (d->chan, 0);
 964         ce_set_rts (d->chan, 0);
 965
 966         d->running = 0;
 967         callout_stop (&d->timeout_handle);
 968 }
 969
 970 /*
 971  * Start the interface.  Called on splimp().
 972  */
 973 static void ce_up (drv_t *d)
 974 {
 975         CE_DEBUG (d, ("ce_up\n"));
 976         ce_set_dtr (d->chan, 1);
 977         ce_set_rts (d->chan, 1);
 978
 979         d->running = 1;
 980 }
 981
 982 /*
 983  * Start output on the interface.  Get another datagram to send
 984  * off of the interface queue, and copy it to the interface
 985  * before starting the output.
 986  */
 987 static void ce_send (drv_t *d)
 988 {
 989         struct mbuf *m;
 990         u_short len;
 991
 992         CE_DEBUG2 (d, ("ce_send\n"));
 993
 994         /* No output if the interface is down. */
 995         if (! d->running)
 996                 return;
 997
 998         while (ce_transmit_space (d->chan)) {
 999                 /* Get the packet to send. */
1000 #ifdef NETGRAPH
1001                 IF_DEQUEUE (&d->hi_queue, m);
1002                 if (! m)
1003                         IF_DEQUEUE (&d->queue, m);
1004 #else
1005                 m = sppp_dequeue (d->ifp);
1006 #endif
1007                 if (! m)
1008                         return;
1009 #ifndef NETGRAPH
1010 #if __FreeBSD_version >= 500000
1011                 BPF_MTAP (d->ifp, m);
1012 #else
1013                 if (d->ifp->if_bpf)
1014                         bpf_mtap (d->ifp, m);
1015 #endif
1016 #endif
1017 #if __FreeBSD_version >= 490000
1018                 len = m_length (m, NULL);
1019 #else
1020                 len = m->m_pkthdr.len;
1021 #endif
1022                 if (len >= BUFSZ)
1023                         printf ("%s: too long packet: %d bytes: ",
1024                                 d->name, len);
1025                 else if (! m->m_next)
1026                         ce_send_packet (d->chan, (u_char*) mtod (m, caddr_t), len, 0);
1027                 else {
1028                         ce_buf_item_t *item = (ce_buf_item_t*)d->chan->tx_queue;
1029                         m_copydata (m, 0, len, item->buf);
1030                         ce_send_packet (d->chan, item->buf, len, 0);
1031                 }
1032                 m_freem (m);
1033                 /* Set up transmit timeout, if the transmit ring is not empty.*/
1034                 d->timeout = 10;
1035         }
1036 #ifndef NETGRAPH
1037 #if __FreeBSD_version >= 600034
1038         d->ifp->if_flags |= IFF_DRV_OACTIVE;
1039 #else
1040         d->ifp->if_flags |= IFF_OACTIVE;
1041 #endif
1042 #endif
1043 }
1044
1045 /*
1046  * Start output on the interface.
1047  * Always called on splimp().
1048  */
1049 static void ce_start (drv_t *d)
1050 {
1051         if (d->running) {
1052                 if (! d->chan->dtr)
1053                         ce_set_dtr (d->chan, 1);
1054                 if (! d->chan->rts)
1055                         ce_set_rts (d->chan, 1);
1056                 ce_send (d);
1057                 callout_reset (&d->timeout_handle, hz, ce_watchdog_timer, d);
1058         }
1059 }
1060
1061 /*
1062  * Handle transmit timeouts.
1063  * Recover after lost transmit interrupts.
1064  * Always called on splimp().
1065  */
1066 static void ce_watchdog (drv_t *d)
1067 {
1068         CE_DEBUG (d, ("device timeout\n"));
1069         if (d->running) {
1070                 ce_set_dtr (d->chan, 0);
1071                 ce_set_rts (d->chan, 0);
1072 /*              ce_stop_chan (d->chan);*/
1073 /*              ce_start_chan (d->chan, 1, 1, 0, 0);*/
1074                 ce_set_dtr (d->chan, 1);
1075                 ce_set_rts (d->chan, 1);
1076                 ce_start (d);
1077         }
1078 }
1079
1080 static void ce_watchdog_timer (void *arg)
1081 {
1082         drv_t *d = arg;
1083         bdrv_t *bd = d->board->sys;
1084
1085         CE_LOCK(bd);
1086         if (d->timeout == 1)
1087                 ce_watchdog (d);
1088         if (d->timeout)
1089                 d->timeout--;
1090         callout_reset (&d->timeout_handle, hz, ce_watchdog_timer, d);
1091         CE_UNLOCK(bd);
1092 }
1093
1094 static void ce_transmit (ce_chan_t *c, void *attachment, int len)
1095 {
1096         drv_t *d = c->sys;
1097
1098         d->timeout = 0;
1099 #ifndef NETGRAPH
1100         if_inc_counter(d->ifp, IFCOUNTER_OPACKETS, 1);
1101 #if __FreeBSD_version >=  600034
1102         d->ifp->if_flags &= ~IFF_DRV_OACTIVE;
1103 #else
1104         d->ifp->if_flags &= ~IFF_OACTIVE;
1105 #endif
1106 #endif
1107         ce_start (d);
1108 }
1109
1110 static void ce_receive (ce_chan_t *c, unsigned char *data, int len)
1111 {
1112         drv_t *d = c->sys;
1113         struct mbuf *m;
1114
1115         if (! d->running)
1116                 return;
1117
1118         m = makembuf (data, len);
1119         if (! m) {
1120                 CE_DEBUG (d, ("no memory for packet\n"));
1121 #ifndef NETGRAPH
1122                 if_inc_counter(d->ifp, IFCOUNTER_IQDROPS, 1);
1123 #endif
1124                 return;
1125         }
1126         if (c->debug > 1)
1127                 m_print (m, 0);
1128 #ifdef NETGRAPH
1129         m->m_pkthdr.rcvif = 0;
1130         IF_ENQUEUE(&d->rqueue, m);
1131 #else
1132         if_inc_counter(d->ifp, IFCOUNTER_IPACKETS, 1);
1133         m->m_pkthdr.rcvif = d->ifp;
1134         /* Check if there's a BPF listener on this interface.
1135          * If so, hand off the raw packet to bpf. */
1136         BPF_MTAP(d->ifp, m);
1137         IF_ENQUEUE(&d->rqueue, m);
1138 #endif
1139 }
1140
1141 static void ce_error (ce_chan_t *c, int data)
1142 {
1143         drv_t *d = c->sys;
1144
1145         switch (data) {
1146         case CE_FRAME:
1147                 CE_DEBUG (d, ("frame error\n"));
1148 #ifndef NETGRAPH
1149                 if_inc_counter(d->ifp, IFCOUNTER_IERRORS, 1);
1150 #endif
1151                 break;
1152         case CE_CRC:
1153                 CE_DEBUG (d, ("crc error\n"));
1154 #ifndef NETGRAPH
1155                 if_inc_counter(d->ifp, IFCOUNTER_IERRORS, 1);
1156 #endif
1157                 break;
1158         case CE_OVERRUN:
1159                 CE_DEBUG (d, ("overrun error\n"));
1160 #ifndef NETGRAPH
1161                 if_inc_counter(d->ifp, IFCOUNTER_COLLISIONS, 1);
1162                 if_inc_counter(d->ifp, IFCOUNTER_IERRORS, 1);
1163 #endif
1164                 break;
1165         case CE_OVERFLOW:
1166                 CE_DEBUG (d, ("overflow error\n"));
1167 #ifndef NETGRAPH
1168                 if_inc_counter(d->ifp, IFCOUNTER_IERRORS, 1);
1169 #endif
1170                 break;
1171         case CE_UNDERRUN:
1172                 CE_DEBUG (d, ("underrun error\n"));
1173                 d->timeout = 0;
1174 #ifndef NETGRAPH
1175                 if_inc_counter(d->ifp, IFCOUNTER_OERRORS, 1);
1176 #if __FreeBSD_version >= 600034
1177                 d->ifp->if_flags &= ~IFF_DRV_OACTIVE;
1178 #else
1179                 d->ifp->if_flags &= ~IFF_OACTIVE;
1180 #endif
1181 #endif
1182                 ce_start (d);
1183                 break;
1184         default:
1185                 CE_DEBUG (d, ("error #%d\n", data));
1186                 break;
1187         }
1188 }
1189
1190 /*
1191  * You also need read, write, open, close routines.
1192  * This should get you started
1193  */
1194 #if __FreeBSD_version < 500000
1195 static int ce_open (dev_t dev, int oflags, int devtype, struct proc *p)
1196 #else
1197 static int ce_open (struct cdev *dev, int oflags, int devtype, struct thread *td)
1198 #endif
1199 {
1200         int unit = dev2unit (dev);
1201         drv_t *d;
1202
1203         if (unit >= NBRD*NCHAN || ! (d = channel[unit]))
1204                 return ENXIO;
1205         CE_DEBUG2 (d, ("ce_open\n"));
1206         return 0;
1207 }
1208
1209 /*
1210  * Only called on the LAST close.
1211  */
1212 #if __FreeBSD_version < 500000
1213 static int ce_close (dev_t dev, int fflag, int devtype, struct proc *p)
1214 #else
1215 static int ce_close (struct cdev *dev, int fflag, int devtype, struct thread *td)
1216 #endif
1217 {
1218         drv_t *d = channel [dev2unit (dev)];
1219
1220         CE_DEBUG2 (d, ("ce_close\n"));
1221         return 0;
1222 }
1223
1224 static int ce_modem_status (ce_chan_t *c)
1225 {
1226         drv_t *d = c->sys;
1227         bdrv_t *bd = d->board->sys;
1228         int status, s;
1229
1230         status = d->running ? TIOCM_LE : 0;
1231         s = splimp ();
1232         CE_LOCK (bd);
1233         if (ce_get_cd  (c)) status |= TIOCM_CD;
1234         if (ce_get_cts (c)) status |= TIOCM_CTS;
1235         if (ce_get_dsr (c)) status |= TIOCM_DSR;
1236         if (c->dtr)         status |= TIOCM_DTR;
1237         if (c->rts)         status |= TIOCM_RTS;
1238         CE_UNLOCK (bd);
1239         splx (s);
1240         return status;
1241 }
1242
1243 #if __FreeBSD_version < 500000
1244 static int ce_ioctl (dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
1245 #else
1246 static int ce_ioctl (struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
1247 #endif
1248 {
1249         drv_t *d = channel [dev2unit (dev)];
1250         bdrv_t *bd = d->board->sys;
1251         ce_chan_t *c = d->chan;
1252         struct serial_statistics *st;
1253         struct e1_statistics *opte1;
1254         int error, s;
1255         char mask[16];
1256
1257         switch (cmd) {
1258         case SERIAL_GETREGISTERED:
1259                 CE_DEBUG2 (d, ("ioctl: getregistered\n"));
1260                 bzero (mask, sizeof(mask));
1261                 for (s=0; s<NBRD*NCHAN; ++s)
1262                         if (channel [s])
1263                                 mask [s/8] |= 1 << (s & 7);
1264                 bcopy (mask, data, sizeof (mask));
1265                 return 0;
1266
1267 #ifndef NETGRAPH
1268         case SERIAL_GETPROTO:
1269                 CE_DEBUG2 (d, ("ioctl: getproto\n"));
1270                 strcpy ((char*)data, (IFP2SP(d->ifp)->pp_flags & PP_FR) ? "fr" :
1271                         (d->ifp->if_flags & PP_CISCO) ? "cisco" : "ppp");
1272                 return 0;
1273
1274         case SERIAL_SETPROTO:
1275                 CE_DEBUG2 (d, ("ioctl: setproto\n"));
1276                 /* Only for superuser! */
1277 #if __FreeBSD_version < 500000
1278                 error = suser (p);
1279 #elif __FreeBSD_version < 700000
1280                 error = suser (td);
1281 #else
1282                 error = priv_check (td, PRIV_DRIVER);
1283 #endif
1284                 if (error)
1285                         return error;
1286 #if __FreeBSD_version >= 600034
1287                 if (d->ifp->if_flags & IFF_DRV_RUNNING)
1288 #else
1289                 if (d->ifp->if_flags & IFF_RUNNING)
1290 #endif
1291                         return EBUSY;
1292                 if (! strcmp ("cisco", (char*)data)) {
1293                         IFP2SP(d->ifp)->pp_flags &= ~(PP_FR);
1294                         IFP2SP(d->ifp)->pp_flags |= PP_KEEPALIVE;
1295                         d->ifp->if_flags |= PP_CISCO;
1296 #if PP_FR != 0
1297                 } else if (! strcmp ("fr", (char*)data)) {
1298                         d->ifp->if_flags &= ~(PP_CISCO);
1299                         IFP2SP(d->ifp)->pp_flags |= PP_FR | PP_KEEPALIVE;
1300 #endif
1301                 } else if (! strcmp ("ppp", (char*)data)) {
1302                         IFP2SP(d->ifp)->pp_flags &= ~PP_FR;
1303                         IFP2SP(d->ifp)->pp_flags &= ~PP_KEEPALIVE;
1304                         d->ifp->if_flags &= ~(PP_CISCO);
1305                 } else
1306                         return EINVAL;
1307                 return 0;
1308
1309         case SERIAL_GETKEEPALIVE:
1310                 CE_DEBUG2 (d, ("ioctl: getkeepalive\n"));
1311                 if ((IFP2SP(d->ifp)->pp_flags & PP_FR) ||
1312                         (d->ifp->if_flags & PP_CISCO))
1313                         return EINVAL;
1314                 *(int*)data = (IFP2SP(d->ifp)->pp_flags & PP_KEEPALIVE) ? 1 : 0;
1315                 return 0;
1316
1317         case SERIAL_SETKEEPALIVE:
1318                 CE_DEBUG2 (d, ("ioctl: setkeepalive\n"));
1319                 /* Only for superuser! */
1320 #if __FreeBSD_version < 500000
1321                 error = suser (p);
1322 #elif __FreeBSD_version < 700000
1323                 error = suser (td);
1324 #else
1325                 error = priv_check (td, PRIV_DRIVER);
1326 #endif
1327                 if (error)
1328                         return error;
1329                 if ((IFP2SP(d->ifp)->pp_flags & PP_FR) ||
1330                         (d->ifp->if_flags & PP_CISCO))
1331                         return EINVAL;
1332                 s = splimp ();
1333                 CE_LOCK (bd);
1334                 if (*(int*)data)
1335                         IFP2SP(d->ifp)->pp_flags |= PP_KEEPALIVE;
1336                 else
1337                         IFP2SP(d->ifp)->pp_flags &= ~PP_KEEPALIVE;
1338                 CE_UNLOCK (bd);
1339                 splx (s);
1340                 return 0;
1341 #endif /*NETGRAPH*/
1342
1343         case SERIAL_GETMODE:
1344                 CE_DEBUG2 (d, ("ioctl: getmode\n"));
1345                 *(int*)data = SERIAL_HDLC;
1346                 return 0;
1347
1348         case SERIAL_SETMODE:
1349                 /* Only for superuser! */
1350 #if __FreeBSD_version < 500000
1351                 error = suser (p);
1352 #elif __FreeBSD_version < 700000
1353                 error = suser (td);
1354 #else
1355                 error = priv_check (td, PRIV_DRIVER);
1356 #endif
1357                 if (error)
1358                         return error;
1359                 if (*(int*)data != SERIAL_HDLC)
1360                         return EINVAL;
1361                 return 0;
1362
1363         case SERIAL_GETCFG:
1364                 CE_DEBUG2 (d, ("ioctl: getcfg\n"));
1365                 *(char*)data = 'c';
1366                 return 0;
1367
1368         case SERIAL_SETCFG:
1369                 CE_DEBUG2 (d, ("ioctl: setcfg\n"));
1370 #if __FreeBSD_version < 500000
1371                 error = suser (p);
1372 #elif __FreeBSD_version < 700000
1373                 error = suser (td);
1374 #else
1375                 error = priv_check (td, PRIV_DRIVER);
1376 #endif
1377                 if (error)
1378                         return error;
1379                 if (*((char*)data) != 'c')
1380                         return EINVAL;
1381                 return 0;
1382
1383         case SERIAL_GETSTAT:
1384                 CE_DEBUG2 (d, ("ioctl: getstat\n"));
1385                 st = (struct serial_statistics*) data;
1386                 st->rintr  = c->rintr;
1387                 st->tintr  = c->tintr;
1388                 st->mintr  = 0;
1389                 st->ibytes = c->ibytes;
1390                 st->ipkts  = c->ipkts;
1391                 st->obytes = c->obytes;
1392                 st->opkts  = c->opkts;
1393                 st->ierrs  = c->overrun + c->frame + c->crc;
1394                 st->oerrs  = c->underrun;
1395                 return 0;
1396
1397         case SERIAL_GETESTAT:
1398                 CE_DEBUG2 (d, ("ioctl: getestat\n"));
1399                 if (c->type != T_E1)
1400                         return EINVAL;
1401                 opte1 = (struct e1_statistics*) data;
1402
1403                 opte1->status      = 0;
1404                 if (c->status & ESTS_NOALARM)
1405                         opte1->status |= E1_NOALARM;
1406                 if (c->status & ESTS_LOS)
1407                         opte1->status |= E1_LOS;
1408                 if (c->status & ESTS_LOF)
1409                         opte1->status |= E1_LOF;
1410                 if (c->status & ESTS_AIS)
1411                         opte1->status |= E1_AIS;
1412                 if (c->status & ESTS_LOMF)
1413                         opte1->status |= E1_LOMF;
1414                 if (c->status & ESTS_AIS16)
1415                         opte1->status |= E1_AIS16;
1416                 if (c->status & ESTS_FARLOF)
1417                         opte1->status |= E1_FARLOF;
1418                 if (c->status & ESTS_FARLOMF)
1419                         opte1->status |= E1_FARLOMF;
1420                 if (c->status & ESTS_TSTREQ)
1421                         opte1->status |= E1_TSTREQ;
1422                 if (c->status & ESTS_TSTERR)
1423                         opte1->status |= E1_TSTERR;
1424
1425                 opte1->cursec       = c->cursec;
1426                 opte1->totsec       = c->totsec + c->cursec;
1427
1428                 opte1->currnt.bpv   = c->currnt.bpv;
1429                 opte1->currnt.fse   = c->currnt.fse;
1430                 opte1->currnt.crce  = c->currnt.crce;
1431                 opte1->currnt.rcrce = c->currnt.rcrce;
1432                 opte1->currnt.uas   = c->currnt.uas;
1433                 opte1->currnt.les   = c->currnt.les;
1434                 opte1->currnt.es    = c->currnt.es;
1435                 opte1->currnt.bes   = c->currnt.bes;
1436                 opte1->currnt.ses   = c->currnt.ses;
1437                 opte1->currnt.oofs  = c->currnt.oofs;
1438                 opte1->currnt.css   = c->currnt.css;
1439                 opte1->currnt.dm    = c->currnt.dm;
1440
1441                 opte1->total.bpv    = c->total.bpv   + c->currnt.bpv;
1442                 opte1->total.fse    = c->total.fse   + c->currnt.fse;
1443                 opte1->total.crce   = c->total.crce  + c->currnt.crce;
1444                 opte1->total.rcrce  = c->total.rcrce + c->currnt.rcrce;
1445                 opte1->total.uas    = c->total.uas   + c->currnt.uas;
1446                 opte1->total.les    = c->total.les   + c->currnt.les;
1447                 opte1->total.es     = c->total.es    + c->currnt.es;
1448                 opte1->total.bes    = c->total.bes   + c->currnt.bes;
1449                 opte1->total.ses    = c->total.ses   + c->currnt.ses;
1450                 opte1->total.oofs   = c->total.oofs  + c->currnt.oofs;
1451                 opte1->total.css    = c->total.css   + c->currnt.css;
1452                 opte1->total.dm     = c->total.dm    + c->currnt.dm;
1453                 for (s=0; s<48; ++s) {
1454                         opte1->interval[s].bpv   = c->interval[s].bpv;
1455                         opte1->interval[s].fse   = c->interval[s].fse;
1456                         opte1->interval[s].crce  = c->interval[s].crce;
1457                         opte1->interval[s].rcrce = c->interval[s].rcrce;
1458                         opte1->interval[s].uas   = c->interval[s].uas;
1459                         opte1->interval[s].les   = c->interval[s].les;
1460                         opte1->interval[s].es    = c->interval[s].es;
1461                         opte1->interval[s].bes   = c->interval[s].bes;
1462                         opte1->interval[s].ses   = c->interval[s].ses;
1463                         opte1->interval[s].oofs  = c->interval[s].oofs;
1464                         opte1->interval[s].css   = c->interval[s].css;
1465                         opte1->interval[s].dm    = c->interval[s].dm;
1466                 }
1467                 return 0;
1468
1469         case SERIAL_CLRSTAT:
1470                 CE_DEBUG2 (d, ("ioctl: clrstat\n"));
1471                 /* Only for superuser! */
1472 #if __FreeBSD_version < 500000
1473                 error = suser (p);
1474 #elif __FreeBSD_version < 700000
1475                 error = suser (td);
1476 #else
1477                 error = priv_check (td, PRIV_DRIVER);
1478 #endif
1479                 if (error)
1480                         return error;
1481                 c->rintr    = 0;
1482                 c->tintr    = 0;
1483                 c->ibytes   = 0;
1484                 c->obytes   = 0;
1485                 c->ipkts    = 0;
1486                 c->opkts    = 0;
1487                 c->overrun  = 0;
1488                 c->frame    = 0;
1489                 c->crc      = 0;
1490                 c->underrun = 0;
1491                 bzero (&c->currnt, sizeof (c->currnt));
1492                 bzero (&c->total, sizeof (c->total));
1493                 bzero (c->interval, sizeof (c->interval));
1494                 return 0;
1495
1496         case SERIAL_GETLOOP:
1497                 CE_DEBUG2 (d, ("ioctl: getloop\n"));
1498                 if (c->type != T_E1)
1499                         return EINVAL;
1500                 *(int*)data = c->lloop;
1501                 return 0;
1502
1503         case SERIAL_SETLOOP:
1504                 CE_DEBUG2 (d, ("ioctl: setloop\n"));
1505                 if (c->type != T_E1)
1506                         return EINVAL;
1507                 /* Only for superuser! */
1508 #if __FreeBSD_version < 500000
1509                 error = suser (p);
1510 #elif __FreeBSD_version < 700000
1511                 error = suser (td);
1512 #else
1513                 error = priv_check (td, PRIV_DRIVER);
1514 #endif
1515                 if (error)
1516                         return error;
1517                 s = splimp ();
1518                 CE_LOCK (bd);
1519                 ce_set_lloop (c, *(int*)data);
1520                 CE_UNLOCK (bd);
1521                 splx (s);
1522                 return 0;
1523
1524         case SERIAL_GETRLOOP:
1525                 CE_DEBUG2 (d, ("ioctl: getrloop\n"));
1526                 if (c->type != T_E1)
1527                         return EINVAL;
1528                 *(int*)data = c->rloop;
1529                 return 0;
1530
1531         case SERIAL_SETRLOOP:
1532                 CE_DEBUG2 (d, ("ioctl: setloop\n"));
1533                 if (c->type != T_E1)
1534                         return EINVAL;
1535                 /* Only for superuser! */
1536 #if __FreeBSD_version < 500000
1537                 error = suser (p);
1538 #elif __FreeBSD_version < 700000
1539                 error = suser (td);
1540 #else
1541                 error = priv_check (td, PRIV_DRIVER);
1542 #endif
1543                 if (error)
1544                         return error;
1545                 s = splimp ();
1546                 CE_LOCK (bd);
1547                 ce_set_rloop (c, *(int*)data);
1548                 CE_UNLOCK (bd);
1549                 splx (s);
1550                 return 0;
1551
1552         case SERIAL_GETDEBUG:
1553                 CE_DEBUG2 (d, ("ioctl: getdebug\n"));
1554                 *(int*)data = d->chan->debug;
1555                 return 0;
1556
1557         case SERIAL_SETDEBUG:
1558                 CE_DEBUG2 (d, ("ioctl: setdebug\n"));
1559                 /* Only for superuser! */
1560 #if __FreeBSD_version < 500000
1561                 error = suser (p);
1562 #elif __FreeBSD_version < 700000
1563                 error = suser (td);
1564 #else
1565                 error = priv_check (td, PRIV_DRIVER);
1566 #endif
1567                 if (error)
1568                         return error;
1569 #ifndef NETGRAPH
1570                 /*
1571                  * The debug_shadow is always greater than zero for logic
1572                  * simplicity.  For switching debug off the IFF_DEBUG is
1573                  * responsible.
1574                  */
1575                 d->chan->debug_shadow = (*(int*)data) ? (*(int*)data) : 1;
1576                 if (d->ifp->if_flags & IFF_DEBUG)
1577                         d->chan->debug = d->chan->debug_shadow;
1578 #else
1579                 d->chan->debug = *(int*)data;
1580 #endif
1581                 return 0;
1582
1583         case SERIAL_GETBAUD:
1584                 CE_DEBUG2 (d, ("ioctl: getbaud\n"));
1585                 *(long*)data = c->baud;
1586                 return 0;
1587
1588         case SERIAL_SETBAUD:
1589                 CE_DEBUG2 (d, ("ioctl: setbaud\n"));
1590                 if (c->type != T_E1 || !c->unfram)
1591                         return EINVAL;
1592                 /* Only for superuser! */
1593 #if __FreeBSD_version < 500000
1594                 error = suser (p);
1595 #elif __FreeBSD_version < 700000
1596                 error = suser (td);
1597 #else
1598                 error = priv_check (td, PRIV_DRIVER);
1599 #endif
1600                 if (error)
1601                         return error;
1602                 s = splimp ();
1603                 CE_LOCK (bd);
1604                 ce_set_baud (c, *(long*)data);
1605                 CE_UNLOCK (bd);
1606                 splx (s);
1607                 return 0;
1608
1609         case SERIAL_GETTIMESLOTS:
1610                 CE_DEBUG2 (d, ("ioctl: gettimeslots\n"));
1611                 if ((c->type != T_E1 || c->unfram) && c->type != T_DATA)
1612                         return EINVAL;
1613                 *(u_long*)data = c->ts;
1614                 return 0;
1615
1616         case SERIAL_SETTIMESLOTS:
1617                 CE_DEBUG2 (d, ("ioctl: settimeslots\n"));
1618                 /* Only for superuser! */
1619 #if __FreeBSD_version < 500000
1620                 error = suser (p);
1621 #elif __FreeBSD_version < 700000
1622                 error = suser (td);
1623 #else
1624                 error = priv_check (td, PRIV_DRIVER);
1625 #endif
1626                 if (error)
1627                         return error;
1628                 if ((c->type != T_E1 || c->unfram) && c->type != T_DATA)
1629                         return EINVAL;
1630                 s = splimp ();
1631                 CE_LOCK (bd);
1632                 ce_set_ts (c, *(u_long*)data);
1633                 CE_UNLOCK (bd);
1634                 splx (s);
1635                 return 0;
1636
1637         case SERIAL_GETHIGAIN:
1638                 CE_DEBUG2 (d, ("ioctl: gethigain\n"));
1639                 if (c->type != T_E1)
1640                         return EINVAL;
1641                 *(int*)data = c->higain;
1642                 return 0;
1643
1644         case SERIAL_SETHIGAIN:
1645                 CE_DEBUG2 (d, ("ioctl: sethigain\n"));
1646                 if (c->type != T_E1)
1647                         return EINVAL;
1648                 /* Only for superuser! */
1649 #if __FreeBSD_version < 500000
1650                 error = suser (p);
1651 #elif __FreeBSD_version < 700000
1652                 error = suser (td);
1653 #else
1654                 error = priv_check (td, PRIV_DRIVER);
1655 #endif
1656                 if (error)
1657                         return error;
1658                 s = splimp ();
1659                 CE_LOCK (bd);
1660                 ce_set_higain (c, *(int*)data);
1661                 CE_UNLOCK (bd);
1662                 splx (s);
1663                 return 0;
1664
1665         case SERIAL_GETPHONY:
1666                 CE_DEBUG2 (d, ("ioctl: getphony\n"));
1667                 *(int*)data = c->phony;
1668                 return 0;
1669
1670         case SERIAL_SETPHONY:
1671                 CE_DEBUG2 (d, ("ioctl: setphony\n"));
1672                 /* Only for superuser! */
1673 #if __FreeBSD_version < 500000
1674                 error = suser (p);
1675 #elif __FreeBSD_version < 700000
1676                 error = suser (td);
1677 #else
1678                 error = priv_check (td, PRIV_DRIVER);
1679 #endif
1680                 if (error)
1681                         return error;
1682                 s = splimp ();
1683                 CE_LOCK (bd);
1684                 ce_set_phony (c, *(int*)data);
1685                 CE_UNLOCK (bd);
1686                 splx (s);
1687                 return 0;
1688
1689         case SERIAL_GETUNFRAM:
1690                 CE_DEBUG2 (d, ("ioctl: getunfram\n"));
1691                 if (c->type != T_E1 || c->num != 0)
1692                         return EINVAL;
1693                 *(int*)data = c->unfram;
1694                 return 0;
1695
1696         case SERIAL_SETUNFRAM:
1697                 CE_DEBUG2 (d, ("ioctl: setunfram\n"));
1698                 if (c->type != T_E1 || c->num != 0)
1699                         return EINVAL;
1700                 /* Only for superuser! */
1701 #if __FreeBSD_version < 500000
1702                 error = suser (p);
1703 #elif __FreeBSD_version < 700000
1704                 error = suser (td);
1705 #else
1706                 error = priv_check (td, PRIV_DRIVER);
1707 #endif
1708                 if (error)
1709                         return error;
1710                 s = splimp ();
1711                 CE_LOCK (bd);
1712                 ce_set_unfram (c, *(int*)data);
1713                 CE_UNLOCK (bd);
1714                 splx (s);
1715                 return 0;
1716
1717         case SERIAL_GETSCRAMBLER:
1718                 CE_DEBUG2 (d, ("ioctl: getscrambler\n"));
1719                 if (!c->unfram)
1720                         return EINVAL;
1721                 *(int*)data = c->scrambler;
1722                 return 0;
1723
1724         case SERIAL_SETSCRAMBLER:
1725                 CE_DEBUG2 (d, ("ioctl: setscrambler\n"));
1726                 /* Only for superuser! */
1727 #if __FreeBSD_version < 500000
1728                 error = suser (p);
1729 #elif __FreeBSD_version < 700000
1730                 error = suser (td);
1731 #else
1732                 error = priv_check (td, PRIV_DRIVER);
1733 #endif
1734                 if (error)
1735                         return error;
1736                 if (!c->unfram)
1737                         return EINVAL;
1738                 s = splimp ();
1739                 CE_LOCK (bd);
1740                 ce_set_scrambler (c, *(int*)data);
1741                 CE_UNLOCK (bd);
1742                 splx (s);
1743                 return 0;
1744
1745         case SERIAL_GETMONITOR:
1746                 CE_DEBUG2 (d, ("ioctl: getmonitor\n"));
1747                 if (c->type != T_E1)
1748                         return EINVAL;
1749                 *(int*)data = c->monitor;
1750                 return 0;
1751
1752         case SERIAL_SETMONITOR:
1753                 CE_DEBUG2 (d, ("ioctl: setmonitor\n"));
1754                 /* Only for superuser! */
1755 #if __FreeBSD_version < 500000
1756                 error = suser (p);
1757 #elif __FreeBSD_version < 700000
1758                 error = suser (td);
1759 #else
1760                 error = priv_check (td, PRIV_DRIVER);
1761 #endif
1762                 if (error)
1763                         return error;
1764                 if (c->type != T_E1)
1765                         return EINVAL;
1766                 s = splimp ();
1767                 CE_LOCK (bd);
1768                 ce_set_monitor (c, *(int*)data);
1769                 CE_UNLOCK (bd);
1770                 splx (s);
1771                 return 0;
1772
1773         case SERIAL_GETUSE16:
1774                 CE_DEBUG2 (d, ("ioctl: getuse16\n"));
1775                 if (c->type != T_E1 || c->unfram)
1776                         return EINVAL;
1777                 *(int*)data = c->use16;
1778                 return 0;
1779
1780         case SERIAL_SETUSE16:
1781                 CE_DEBUG2 (d, ("ioctl: setuse16\n"));
1782                 /* Only for superuser! */
1783 #if __FreeBSD_version < 500000
1784                 error = suser (p);
1785 #elif __FreeBSD_version < 700000
1786                 error = suser (td);
1787 #else
1788                 error = priv_check (td, PRIV_DRIVER);
1789 #endif
1790                 if (error)
1791                         return error;
1792                 if (c->type != T_E1)
1793                         return EINVAL;
1794                 s = splimp ();
1795                 CE_LOCK (bd);
1796                 ce_set_use16 (c, *(int*)data);
1797                 CE_UNLOCK (bd);
1798                 splx (s);
1799                 return 0;
1800
1801         case SERIAL_GETCRC4:
1802                 CE_DEBUG2 (d, ("ioctl: getcrc4\n"));
1803                 if (c->type != T_E1 || c->unfram)
1804                         return EINVAL;
1805                 *(int*)data = c->crc4;
1806                 return 0;
1807
1808         case SERIAL_SETCRC4:
1809                 CE_DEBUG2 (d, ("ioctl: setcrc4\n"));
1810                 /* Only for superuser! */
1811 #if __FreeBSD_version < 500000
1812                 error = suser (p);
1813 #elif __FreeBSD_version < 700000
1814                 error = suser (td);
1815 #else
1816                 error = priv_check (td, PRIV_DRIVER);
1817 #endif
1818                 if (error)
1819                         return error;
1820                 if (c->type != T_E1 || c->unfram)
1821                         return EINVAL;
1822                 s = splimp ();
1823                 CE_LOCK (bd);
1824                 ce_set_crc4 (c, *(int*)data);
1825                 CE_UNLOCK (bd);
1826                 splx (s);
1827                 return 0;
1828
1829         case SERIAL_GETCLK:
1830                 CE_DEBUG2 (d, ("ioctl: getclk\n"));
1831                 if (c->type != T_E1)
1832                         return EINVAL;
1833                 switch (c->gsyn) {
1834                 default:        *(int*)data = E1CLK_INTERNAL;           break;
1835                 case GSYN_RCV:  *(int*)data = E1CLK_RECEIVE;            break;
1836                 case GSYN_RCV0: *(int*)data = E1CLK_RECEIVE_CHAN0;      break;
1837                 case GSYN_RCV1: *(int*)data = E1CLK_RECEIVE_CHAN1;      break;
1838                 }
1839                 return 0;
1840
1841         case SERIAL_SETCLK:
1842                 CE_DEBUG2 (d, ("ioctl: setclk\n"));
1843                 /* Only for superuser! */
1844 #if __FreeBSD_version < 500000
1845                 error = suser (p);
1846 #elif __FreeBSD_version < 700000
1847                 error = suser (td);
1848 #else
1849                 error = priv_check (td, PRIV_DRIVER);
1850 #endif
1851                 if (error)
1852                         return error;
1853                 if (c->type != T_E1)
1854                         return EINVAL;
1855                 s = splimp ();
1856                 CE_LOCK (bd);
1857                 switch (*(int*)data) {
1858                 default:                  ce_set_gsyn (c, GSYN_INT);  break;
1859                 case E1CLK_RECEIVE:       ce_set_gsyn (c, GSYN_RCV);  break;
1860                 case E1CLK_RECEIVE_CHAN0: ce_set_gsyn (c, GSYN_RCV0); break;
1861                 case E1CLK_RECEIVE_CHAN1: ce_set_gsyn (c, GSYN_RCV1); break;
1862                 }
1863                 CE_UNLOCK (bd);
1864                 splx (s);
1865                 return 0;
1866
1867 #if 0
1868         case SERIAL_RESET:
1869                 CE_DEBUG2 (d, ("ioctl: reset\n"));
1870                 /* Only for superuser! */
1871 #if __FreeBSD_version < 500000
1872                 error = suser (p);
1873 #elif __FreeBSD_version < 700000
1874                 error = suser (td);
1875 #else
1876                 error = priv_check (td, PRIV_DRIVER);
1877 #endif
1878                 if (error)
1879                         return error;
1880                 s = splimp ();
1881                 CE_LOCK (bd);
1882 /*              ce_reset (c->board, 0, 0);*/
1883                 CE_UNLOCK (bd);
1884                 splx (s);
1885                 return 0;
1886
1887         case SERIAL_HARDRESET:
1888                 CE_DEBUG2 (d, ("ioctl: hardreset\n"));
1889                 /* Only for superuser! */
1890 #if __FreeBSD_version < 500000
1891                 error = suser (p);
1892 #elif __FreeBSD_version < 700000
1893                 error = suser (td);
1894 #else
1895                 error = priv_check (td, PRIV_DRIVER);
1896 #endif
1897                 if (error)
1898                         return error;
1899                 s = splimp ();
1900                 CE_LOCK (bd);
1901                 /* hard_reset (c->board); */
1902                 CE_UNLOCK (bd);
1903                 splx (s);
1904                 return 0;
1905 #endif
1906
1907         case SERIAL_GETCABLE:
1908                 CE_DEBUG2 (d, ("ioctl: getcable\n"));
1909                 if (c->type != T_E1)
1910                         return EINVAL;
1911                 s = splimp ();
1912                 CE_LOCK (bd);
1913                 *(int*)data = CABLE_TP;
1914                 CE_UNLOCK (bd);
1915                 splx (s);
1916                 return 0;
1917
1918         case SERIAL_GETDIR:
1919                 CE_DEBUG2 (d, ("ioctl: getdir\n"));
1920                 if (c->type != T_E1 && c->type != T_DATA)
1921                         return EINVAL;
1922                 *(int*)data = c->dir;
1923                 return 0;
1924
1925         case SERIAL_SETDIR:
1926                 CE_DEBUG2 (d, ("ioctl: setdir\n"));
1927                 /* Only for superuser! */
1928 #if __FreeBSD_version < 500000
1929                 error = suser (p);
1930 #elif __FreeBSD_version < 700000
1931                 error = suser (td);
1932 #else
1933                 error = priv_check (td, PRIV_DRIVER);
1934 #endif
1935                 if (error)
1936                         return error;
1937                 s = splimp ();
1938                 CE_LOCK (bd);
1939                 ce_set_dir (c, *(int*)data);
1940                 CE_UNLOCK (bd);
1941                 splx (s);
1942                 return 0;
1943
1944         case TIOCSDTR:          /* Set DTR */
1945                 s = splimp ();
1946                 CE_LOCK (bd);
1947                 ce_set_dtr (c, 1);
1948                 CE_UNLOCK (bd);
1949                 splx (s);
1950                 return 0;
1951
1952         case TIOCCDTR:          /* Clear DTR */
1953                 s = splimp ();
1954                 CE_LOCK (bd);
1955                 ce_set_dtr (c, 0);
1956                 CE_UNLOCK (bd);
1957                 splx (s);
1958                 return 0;
1959
1960         case TIOCMSET:          /* Set DTR/RTS */
1961                 s = splimp ();
1962                 CE_LOCK (bd);
1963                 ce_set_dtr (c, (*(int*)data & TIOCM_DTR) ? 1 : 0);
1964                 ce_set_rts (c, (*(int*)data & TIOCM_RTS) ? 1 : 0);
1965                 CE_UNLOCK (bd);
1966                 splx (s);
1967                 return 0;
1968
1969         case TIOCMBIS:          /* Add DTR/RTS */
1970                 s = splimp ();
1971                 CE_LOCK (bd);
1972                 if (*(int*)data & TIOCM_DTR) ce_set_dtr (c, 1);
1973                 if (*(int*)data & TIOCM_RTS) ce_set_rts (c, 1);
1974                 CE_UNLOCK (bd);
1975                 splx (s);
1976                 return 0;
1977
1978         case TIOCMBIC:          /* Clear DTR/RTS */
1979                 s = splimp ();
1980                 CE_LOCK (bd);
1981                 if (*(int*)data & TIOCM_DTR) ce_set_dtr (c, 0);
1982                 if (*(int*)data & TIOCM_RTS) ce_set_rts (c, 0);
1983                 CE_UNLOCK (bd);
1984                 splx (s);
1985                 return 0;
1986
1987         case TIOCMGET:          /* Get modem status */
1988                 *(int*)data = ce_modem_status (c);
1989                 return 0;
1990         }
1991         return ENOTTY;
1992 }
1993
1994 #ifdef NETGRAPH
1995 #if __FreeBSD_version >= 500000
1996 static int ng_ce_constructor (node_p node)
1997 {
1998         drv_t *d = NG_NODE_PRIVATE (node);
1999 #else
2000 static int ng_ce_constructor (node_p *node)
2001 {
2002         drv_t *d = (*node)->private;
2003 #endif
2004         CE_DEBUG (d, ("Constructor\n"));
2005         return EINVAL;
2006 }
2007
2008 static int ng_ce_newhook (node_p node, hook_p hook, const char *name)
2009 {
2010         int s;
2011 #if __FreeBSD_version >= 500000
2012         drv_t *d = NG_NODE_PRIVATE (node);
2013 #else
2014         drv_t *d = node->private;
2015 #endif
2016         bdrv_t *bd = d->board->sys;
2017
2018         CE_DEBUG (d, ("Newhook\n"));
2019         /* Attach debug hook */
2020         if (strcmp (name, NG_CE_HOOK_DEBUG) == 0) {
2021 #if __FreeBSD_version >= 500000
2022                 NG_HOOK_SET_PRIVATE (hook, NULL);
2023 #else
2024                 hook->private = 0;
2025 #endif
2026                 d->debug_hook = hook;
2027                 return 0;
2028         }
2029
2030         /* Check for raw hook */
2031         if (strcmp (name, NG_CE_HOOK_RAW) != 0)
2032                 return EINVAL;
2033
2034 #if __FreeBSD_version >= 500000
2035         NG_HOOK_SET_PRIVATE (hook, d);
2036 #else
2037         hook->private = d;
2038 #endif
2039         d->hook = hook;
2040         s = splimp ();
2041         CE_LOCK (bd);
2042         ce_up (d);
2043         CE_UNLOCK (bd);
2044         splx (s);
2045         return 0;
2046 }
2047
2048 static char *format_timeslots (u_long s)
2049 {
2050         static char buf [100];
2051         char *p = buf;
2052         int i;
2053
2054         for (i=1; i<32; ++i)
2055                 if ((s >> i) & 1) {
2056                         int prev = (i > 1)  & (s >> (i-1));
2057                         int next = (i < 31) & (s >> (i+1));
2058
2059                         if (prev) {
2060                                 if (next)
2061                                         continue;
2062                                 *p++ = '-';
2063                         } else if (p > buf)
2064                                 *p++ = ',';
2065
2066                         if (i >= 10)
2067                                 *p++ = '0' + i / 10;
2068                         *p++ = '0' + i % 10;
2069                 }
2070         *p = 0;
2071         return buf;
2072 }
2073
2074 static int print_modems (char *s, ce_chan_t *c, int need_header)
2075 {
2076         int status = ce_modem_status (c);
2077         int length = 0;
2078
2079         if (need_header)
2080                 length += sprintf (s + length, "  LE   DTR  DSR  RTS  CTS  CD\n");
2081         length += sprintf (s + length, "%4s %4s %4s %4s %4s %4s\n",
2082                 status & TIOCM_LE  ? "On" : "-",
2083                 status & TIOCM_DTR ? "On" : "-",
2084                 status & TIOCM_DSR ? "On" : "-",
2085                 status & TIOCM_RTS ? "On" : "-",
2086                 status & TIOCM_CTS ? "On" : "-",
2087                 status & TIOCM_CD  ? "On" : "-");
2088         return length;
2089 }
2090
2091 static int print_stats (char *s, ce_chan_t *c, int need_header)
2092 {
2093         int length = 0;
2094
2095         if (need_header)
2096                 length += sprintf (s + length, "  Rintr   Tintr   Mintr   Ibytes   Ipkts   Ierrs   Obytes   Opkts   Oerrs\n");
2097         length += sprintf (s + length, "%7ld %7ld %7ld %8lu %7ld %7ld %8lu %7ld %7ld\n",
2098                 c->rintr, c->tintr, 0l, (unsigned long) c->ibytes,
2099                 c->ipkts, c->overrun + c->frame + c->crc,
2100                 (unsigned long) c->obytes, c->opkts, c->underrun);
2101         return length;
2102 }
2103
2104 static char *format_e1_status (u_char status)
2105 {
2106         static char buf [80];
2107
2108         if (status & E1_NOALARM)
2109                 return "Ok";
2110         buf[0] = 0;
2111         if (status & E1_LOS)     strcat (buf, ",LOS");
2112         if (status & E1_AIS)     strcat (buf, ",AIS");
2113         if (status & E1_LOF)     strcat (buf, ",LOF");
2114         if (status & E1_LOMF)    strcat (buf, ",LOMF");
2115         if (status & E1_FARLOF)  strcat (buf, ",FARLOF");
2116         if (status & E1_AIS16)   strcat (buf, ",AIS16");
2117         if (status & E1_FARLOMF) strcat (buf, ",FARLOMF");
2118         if (status & E1_TSTREQ)  strcat (buf, ",TSTREQ");
2119         if (status & E1_TSTERR)  strcat (buf, ",TSTERR");
2120         if (buf[0] == ',')
2121                 return buf+1;
2122         return "Unknown";
2123 }
2124
2125 static int print_frac (char *s, int leftalign, u_long numerator, u_long divider)
2126 {
2127         int n, length = 0;
2128
2129         if (numerator < 1 || divider < 1) {
2130                 length += sprintf (s+length, leftalign ? "/-   " : "    -");
2131                 return length;
2132         }
2133         n = (int) (0.5 + 1000.0 * numerator / divider);
2134         if (n < 1000) {
2135                 length += sprintf (s+length, leftalign ? "/.%-3d" : " .%03d", n);
2136                 return length;
2137         }
2138         *(s + length) = leftalign ? '/' : ' ';
2139         length ++;
2140
2141         if      (n >= 1000000) n = (n+500) / 1000 * 1000;
2142         else if (n >= 100000)  n = (n+50)  / 100 * 100;
2143         else if (n >= 10000)   n = (n+5)   / 10 * 10;
2144
2145         switch (n) {
2146         case 1000:    length += printf (s+length, ".999"); return length;
2147         case 10000:   n = 9990;   break;
2148         case 100000:  n = 99900;  break;
2149         case 1000000: n = 999000; break;
2150         }
2151         if (n < 10000)        length += sprintf (s+length, "%d.%d", n/1000, n/10%100);
2152         else if (n < 100000)  length += sprintf (s+length, "%d.%d", n/1000, n/100%10);
2153         else if (n < 1000000) length += sprintf (s+length, "%d.", n/1000);
2154         else                  length += sprintf (s+length, "%d", n/1000);
2155
2156         return length;
2157 }
2158
2159 static int print_e1_stats (char *s, ce_chan_t *c)
2160 {
2161         struct e1_counters total;
2162         u_long totsec;
2163         int length = 0;
2164
2165         totsec          = c->totsec + c->cursec;
2166         total.bpv       = c->total.bpv   + c->currnt.bpv;
2167         total.fse       = c->total.fse   + c->currnt.fse;
2168         total.crce      = c->total.crce  + c->currnt.crce;
2169         total.rcrce     = c->total.rcrce + c->currnt.rcrce;
2170         total.uas       = c->total.uas   + c->currnt.uas;
2171         total.les       = c->total.les   + c->currnt.les;
2172         total.es        = c->total.es    + c->currnt.es;
2173         total.bes       = c->total.bes   + c->currnt.bes;
2174         total.ses       = c->total.ses   + c->currnt.ses;
2175         total.oofs      = c->total.oofs  + c->currnt.oofs;
2176         total.css       = c->total.css   + c->currnt.css;
2177         total.dm        = c->total.dm    + c->currnt.dm;
2178
2179         length += sprintf (s + length, " Unav/Degr  Bpv/Fsyn  CRC/RCRC  Err/Lerr  Sev/Bur   Oof/Slp  Status\n");
2180
2181         /* Unavailable seconds, degraded minutes */
2182         length += print_frac (s + length, 0, c->currnt.uas, c->cursec);
2183         length += print_frac (s + length, 1, 60 * c->currnt.dm, c->cursec);
2184
2185         /* Bipolar violations, frame sync errors */
2186         length += print_frac (s + length, 0, c->currnt.bpv, c->cursec);
2187         length += print_frac (s + length, 1, c->currnt.fse, c->cursec);
2188
2189         /* CRC errors, remote CRC errors (E-bit) */
2190         length += print_frac (s + length, 0, c->currnt.crce, c->cursec);
2191         length += print_frac (s + length, 1, c->currnt.rcrce, c->cursec);
2192
2193         /* Errored seconds, line errored seconds */
2194         length += print_frac (s + length, 0, c->currnt.es, c->cursec);
2195         length += print_frac (s + length, 1, c->currnt.les, c->cursec);
2196
2197         /* Severely errored seconds, burst errored seconds */
2198         length += print_frac (s + length, 0, c->currnt.ses, c->cursec);
2199         length += print_frac (s + length, 1, c->currnt.bes, c->cursec);
2200
2201         /* Out of frame seconds, controlled slip seconds */
2202         length += print_frac (s + length, 0, c->currnt.oofs, c->cursec);
2203         length += print_frac (s + length, 1, c->currnt.css, c->cursec);
2204
2205         length += sprintf (s + length, " %s\n", format_e1_status (c->status));
2206
2207         /* Print total statistics. */
2208         length += print_frac (s + length, 0, total.uas, totsec);
2209         length += print_frac (s + length, 1, 60 * total.dm, totsec);
2210
2211         length += print_frac (s + length, 0, total.bpv, totsec);
2212         length += print_frac (s + length, 1, total.fse, totsec);
2213
2214         length += print_frac (s + length, 0, total.crce, totsec);
2215         length += print_frac (s + length, 1, total.rcrce, totsec);
2216
2217         length += print_frac (s + length, 0, total.es, totsec);
2218         length += print_frac (s + length, 1, total.les, totsec);
2219
2220         length += print_frac (s + length, 0, total.ses, totsec);
2221         length += print_frac (s + length, 1, total.bes, totsec);
2222
2223         length += print_frac (s + length, 0, total.oofs, totsec);
2224         length += print_frac (s + length, 1, total.css, totsec);
2225
2226         length += sprintf (s + length, " -- Total\n");
2227         return length;
2228 }
2229
2230 static int print_chan (char *s, ce_chan_t *c)
2231 {
2232         drv_t *d = c->sys;
2233         int length = 0;
2234
2235         length += sprintf (s + length, "ce%d", c->board->num * NCHAN + c->num);
2236         if (d->chan->debug)
2237                 length += sprintf (s + length, " debug=%d", d->chan->debug);
2238
2239         if (c->board->mux) {
2240                 length += sprintf (s + length, " cfg=C");
2241         } else {
2242                 length += sprintf (s + length, " cfg=A");
2243         }
2244
2245         if (c->baud)
2246                 length += sprintf (s + length, " %ld", c->baud);
2247         else
2248                 length += sprintf (s + length, " extclock");
2249
2250         if (c->type == T_E1)
2251                 switch (c->gsyn) {
2252                 case GSYN_INT   : length += sprintf (s + length, " syn=int");     break;
2253                 case GSYN_RCV   : length += sprintf (s + length, " syn=rcv");     break;
2254                 case GSYN_RCV0  : length += sprintf (s + length, " syn=rcv0");    break;
2255                 case GSYN_RCV1  : length += sprintf (s + length, " syn=rcv1");    break;
2256                 }
2257         if (c->type == T_E1)
2258                 length += sprintf (s + length, " higain=%s", c->higain ? "on" : "off");
2259
2260         length += sprintf (s + length, " loop=%s", c->lloop ? "on" : "off");
2261
2262         if (c->type == T_E1)
2263                 length += sprintf (s + length, " ts=%s", format_timeslots (c->ts));
2264         length += sprintf (s + length, "\n");
2265         return length;
2266 }
2267
2268 #if __FreeBSD_version >= 500000
2269 static int ng_ce_rcvmsg (node_p node, item_p item, hook_p lasthook)
2270 {
2271         drv_t *d = NG_NODE_PRIVATE (node);
2272         struct ng_mesg *msg;
2273 #else
2274 static int ng_ce_rcvmsg (node_p node, struct ng_mesg *msg,
2275         const char *retaddr, struct ng_mesg **rptr)
2276 {
2277         drv_t *d = node->private;
2278 #endif
2279         struct ng_mesg *resp = NULL;
2280         int error = 0;
2281
2282         CE_DEBUG (d, ("Rcvmsg\n"));
2283 #if __FreeBSD_version >= 500000
2284         NGI_GET_MSG (item, msg);
2285 #endif
2286         switch (msg->header.typecookie) {
2287         default:
2288                 error = EINVAL;
2289                 break;
2290
2291         case NGM_CE_COOKIE:
2292                 printf ("Not implemented yet\n");
2293                 error = EINVAL;
2294                 break;
2295
2296         case NGM_GENERIC_COOKIE:
2297                 switch (msg->header.cmd) {
2298                 default:
2299                         error = EINVAL;
2300                         break;
2301
2302                 case NGM_TEXT_STATUS: {
2303                         char *s;
2304                         int l = 0;
2305                         int dl = sizeof (struct ng_mesg) + 730;
2306
2307 #if __FreeBSD_version >= 500000
2308                         NG_MKRESPONSE (resp, msg, dl, M_NOWAIT);
2309                         if (! resp) {
2310                                 error = ENOMEM;
2311                                 break;
2312                         }
2313 #else
2314                         resp = malloc (M_NETGRAPH, M_NOWAIT);
2315                         if (! resp) {
2316                                 error = ENOMEM;
2317                                 break;
2318                         }
2319                         bzero (resp, dl);
2320 #endif
2321                         s = (resp)->data;
2322                         if (d) {
2323                         l += print_chan (s + l, d->chan);
2324                         l += print_stats (s + l, d->chan, 1);
2325                         l += print_modems (s + l, d->chan, 1);
2326                         l += print_e1_stats (s + l, d->chan);
2327                         } else
2328                                 l += sprintf (s + l, "Error: node not connect to channel");
2329 #if __FreeBSD_version < 500000
2330                         (resp)->header.version = NG_VERSION;
2331                         (resp)->header.arglen = strlen (s) + 1;
2332                         (resp)->header.token = msg->header.token;
2333                         (resp)->header.typecookie = NGM_CE_COOKIE;
2334                         (resp)->header.cmd = msg->header.cmd;
2335 #endif
2336                         strncpy ((resp)->header.cmdstr, "status", NG_CMDSTRSIZ);
2337                         }
2338                         break;
2339                 }
2340                 break;
2341         }
2342 #if __FreeBSD_version >= 500000
2343         NG_RESPOND_MSG (error, node, item, resp);
2344         NG_FREE_MSG (msg);
2345 #else
2346         *rptr = resp;
2347         free (msg, M_NETGRAPH);
2348 #endif
2349         return error;
2350 }
2351
2352 #if __FreeBSD_version >= 500000
2353 static int ng_ce_rcvdata (hook_p hook, item_p item)
2354 {
2355         drv_t *d = NG_NODE_PRIVATE (NG_HOOK_NODE(hook));
2356         struct mbuf *m;
2357 #if __FreeBSD_version < 502120
2358         meta_p meta;
2359 #else
2360         struct ng_tag_prio *ptag;
2361 #endif
2362 #else
2363 static int ng_ce_rcvdata (hook_p hook, struct mbuf *m, meta_p meta)
2364 {
2365         drv_t *d = hook->node->private;
2366 #endif
2367         bdrv_t *bd = d->board->sys;
2368         struct ifqueue *q;
2369         int s;
2370
2371         CE_DEBUG2 (d, ("Rcvdata\n"));
2372 #if __FreeBSD_version >= 500000
2373         NGI_GET_M (item, m);
2374 #if __FreeBSD_version < 502120
2375         NGI_GET_META (item, meta);
2376 #endif
2377         NG_FREE_ITEM (item);
2378         if (! NG_HOOK_PRIVATE (hook) || ! d) {
2379                 NG_FREE_M (m);
2380 #if __FreeBSD_version < 502120
2381                 NG_FREE_META (meta);
2382 #endif
2383 #else
2384         if (! hook->private || ! d) {
2385                 NG_FREE_DATA (m,meta);
2386 #endif
2387                 return ENETDOWN;
2388         }
2389
2390 #if __FreeBSD_version >= 502120
2391         /* Check for high priority data */
2392         if ((ptag = (struct ng_tag_prio *)m_tag_locate(m, NGM_GENERIC_COOKIE,
2393             NG_TAG_PRIO, NULL)) != NULL && (ptag->priority > NG_PRIO_CUTOFF) )
2394                 q = &d->hi_queue;
2395         else
2396                 q = &d->queue;
2397 #else
2398         q = (meta && meta->priority > 0) ? &d->hi_queue : &d->queue;
2399 #endif
2400
2401         s = splimp ();
2402         CE_LOCK (bd);
2403 #if __FreeBSD_version >= 500000
2404         IF_LOCK (q);
2405         if (_IF_QFULL (q)) {
2406                 IF_UNLOCK (q);
2407                 CE_UNLOCK (bd);
2408                 splx (s);
2409                 NG_FREE_M (m);
2410 #if __FreeBSD_version < 502120
2411                 NG_FREE_META (meta);
2412 #endif
2413                 return ENOBUFS;
2414         }
2415         _IF_ENQUEUE (q, m);
2416         IF_UNLOCK (q);
2417 #else
2418         if (IF_QFULL (q)) {
2419                 IF_DROP (q);
2420                 CE_UNLOCK (bd);
2421                 splx (s);
2422                 NG_FREE_DATA (m, meta);
2423                 return ENOBUFS;
2424         }
2425         IF_ENQUEUE (q, m);
2426 #endif
2427         ce_start (d);
2428         CE_UNLOCK (bd);
2429         splx (s);
2430         return 0;
2431 }
2432
2433 static int ng_ce_rmnode (node_p node)
2434 {
2435 #if __FreeBSD_version >= 500000
2436         drv_t *d = NG_NODE_PRIVATE (node);
2437
2438         CE_DEBUG (d, ("Rmnode\n"));
2439         if (d && d->running) {
2440                 bdrv_t *bd = d->board->sys;
2441                 int s = splimp ();
2442                 CE_LOCK (bd);
2443                 ce_down (d);
2444                 CE_UNLOCK (bd);
2445                 splx (s);
2446         }
2447 #ifdef  KLD_MODULE
2448 #if __FreeBSD_version >= 502120
2449         if (node->nd_flags & NGF_REALLY_DIE) {
2450 #else
2451         if (node->nd_flags & NG_REALLY_DIE) {
2452 #endif
2453                 NG_NODE_SET_PRIVATE (node, NULL);
2454                 NG_NODE_UNREF (node);
2455         }
2456 #if __FreeBSD_version >= 502120
2457         NG_NODE_REVIVE(node);           /* Persistant node */
2458 #else
2459         node->nd_flags &= ~NG_INVALID;
2460 #endif
2461 #endif
2462 #else /* __FreeBSD_version < 500000 */
2463         drv_t *d = node->private;
2464
2465         if (d && d->running) {
2466                 bdrv_t *bd = d->board->sys;
2467                 int s = splimp ();
2468                 CE_LOCK (bd);
2469                 ce_down (d);
2470                 CE_UNLOCK (bd);
2471                 splx (s);
2472         }
2473
2474         node->flags |= NG_INVALID;
2475         ng_cutlinks (node);
2476 #ifdef  KLD_MODULE
2477         ng_unname (node);
2478         ng_unref (node);
2479 #endif
2480 #endif
2481         return 0;
2482 }
2483
2484 static int ng_ce_connect (hook_p hook)
2485 {
2486 #if __FreeBSD_version >= 500000
2487         drv_t *d = NG_NODE_PRIVATE (NG_HOOK_NODE (hook));
2488 #else
2489         drv_t *d = hook->node->private;
2490 #endif
2491
2492         if (d) {
2493                 CE_DEBUG (d, ("Connect\n"));
2494                 callout_reset (&d->timeout_handle, hz, ce_watchdog_timer, d);
2495         }
2496
2497         return 0;
2498 }
2499
2500 static int ng_ce_disconnect (hook_p hook)
2501 {
2502 #if __FreeBSD_version >= 500000
2503         drv_t *d = NG_NODE_PRIVATE (NG_HOOK_NODE (hook));
2504 #else
2505         drv_t *d = hook->node->private;
2506 #endif
2507
2508         if (d) {
2509                 CE_DEBUG (d, ("Disconnect\n"));
2510 #if __FreeBSD_version >= 500000
2511                 if (NG_HOOK_PRIVATE (hook))
2512 #else
2513                 if (hook->private)
2514 #endif
2515                 {
2516                         bdrv_t *bd = d->board->sys;
2517                         int s = splimp ();
2518                         CE_LOCK (bd);
2519                         ce_down (d);
2520                         CE_UNLOCK (bd);
2521                         splx (s);
2522                 }
2523                 /* If we were wait it than it reasserted now, just stop it. */
2524                 if (!callout_drain (&d->timeout_handle))
2525                         callout_stop (&d->timeout_handle);
2526         }
2527         return 0;
2528 }
2529 #endif
2530
2531 static int ce_modevent (module_t mod, int type, void *unused)
2532 {
2533 #if __FreeBSD_version < 500000
2534         dev_t dev;
2535         struct cdevsw *cdsw;
2536 #endif
2537         static int load_count = 0;
2538
2539 #if __FreeBSD_version < 500000
2540         dev = makedev (CDEV_MAJOR, 0);
2541 #endif
2542
2543         switch (type) {
2544         case MOD_LOAD:
2545 #if __FreeBSD_version < 500000
2546                 if (dev != NODEV &&
2547                     (cdsw = devsw (dev)) &&
2548                     cdsw->d_maj == CDEV_MAJOR) {
2549                         printf ("Tau32-PCI driver is already in system\n");
2550                         return (ENXIO);
2551                 }
2552 #endif
2553 #if __FreeBSD_version >= 500000 && defined NETGRAPH
2554                 if (ng_newtype (&typestruct))
2555                         printf ("Failed to register ng_ce\n");
2556 #endif
2557                 ++load_count;
2558 #if __FreeBSD_version <= 500000
2559                 cdevsw_add (&ce_cdevsw);
2560 #endif
2561 #if __FreeBSD_version >= 500000
2562                 callout_init (&timeout_handle, CALLOUT_MPSAFE);
2563 #else
2564                 callout_init (&timeout_handle);
2565 #endif
2566                 callout_reset (&timeout_handle, hz*5, ce_timeout, 0);
2567                 break;
2568         case MOD_UNLOAD:
2569                 if (load_count == 1) {
2570                         printf ("Removing device entry for Tau32-PCI\n");
2571 #if __FreeBSD_version <= 500000
2572                         cdevsw_remove (&ce_cdevsw);
2573 #endif
2574 #if __FreeBSD_version >= 500000 && defined NETGRAPH
2575                         ng_rmtype (&typestruct);
2576 #endif
2577                 }
2578                 /* If we were wait it than it reasserted now, just stop it.
2579                  * Actually we shouldn't get this condition. But code could be
2580                  * changed in the future, so just be a litle paranoid.
2581                  */
2582                 if (!callout_drain (&timeout_handle))
2583                         callout_stop (&timeout_handle);
2584                 --load_count;
2585                 break;
2586         case MOD_SHUTDOWN:
2587                 break;
2588         }
2589         return 0;
2590 }
2591
2592 #ifdef NETGRAPH
2593 #if __FreeBSD_version >= 502100
2594 static struct ng_type typestruct = {
2595         .version        = NG_ABI_VERSION,
2596         .name           = NG_CE_NODE_TYPE,
2597         .constructor    = ng_ce_constructor,
2598         .rcvmsg         = ng_ce_rcvmsg,
2599         .shutdown       = ng_ce_rmnode,
2600         .newhook        = ng_ce_newhook,
2601         .connect        = ng_ce_connect,
2602         .rcvdata        = ng_ce_rcvdata,
2603         .disconnect     = ng_ce_disconnect,
2604 };
2605 #else /* __FreeBSD_version < 502100 */
2606 static struct ng_type typestruct = {
2607 #if __FreeBSD_version >= 500000
2608         NG_ABI_VERSION,
2609 #else
2610         NG_VERSION,
2611 #endif
2612         NG_CE_NODE_TYPE,
2613         ce_modevent,
2614         ng_ce_constructor,
2615         ng_ce_rcvmsg,
2616         ng_ce_rmnode,
2617         ng_ce_newhook,
2618         NULL,
2619         ng_ce_connect,
2620         ng_ce_rcvdata,
2621 #if __FreeBSD_version < 500000
2622         NULL,
2623 #endif
2624         ng_ce_disconnect,
2625         NULL
2626 };
2627 #endif /* __FreeBSD_version < 502100 */
2628
2629 #endif /*NETGRAPH*/
2630
2631 #if __FreeBSD_version >= 500000
2632 #ifdef NETGRAPH
2633 MODULE_DEPEND (ng_ce, netgraph, NG_ABI_VERSION, NG_ABI_VERSION, NG_ABI_VERSION);
2634 #else
2635 MODULE_DEPEND (ce, sppp, 1, 1, 1);
2636 #endif
2637 #ifdef KLD_MODULE
2638 DRIVER_MODULE (cemod, pci, ce_driver, ce_devclass, ce_modevent, NULL);
2639 #else
2640 DRIVER_MODULE (ce, pci, ce_driver, ce_devclass, ce_modevent, NULL);
2641 #endif
2642 #else /* if __FreeBSD_version < 500000*/
2643 #ifdef NETGRAPH
2644 DRIVER_MODULE (ce, pci, ce_driver, ce_devclass, ng_mod_event, &typestruct);
2645 #else
2646 DRIVER_MODULE (ce, pci, ce_driver, ce_devclass, ce_modevent, NULL);
2647 #endif
2648 #endif /* __FreeBSD_version < 500000 */
2649 #endif /* NPCI */