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