sys/net/i4b/driver/i4b_rbch.c

   1 /*
   2  * Copyright (c) 1997, 2001 Hellmuth Michaelis. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  *---------------------------------------------------------------------------
  26  *
  27  *      i4b_rbch.c - device driver for raw B channel data
  28  *      ---------------------------------------------------
  29  *
  30  * $FreeBSD: src/sys/i4b/driver/i4b_rbch.c,v 1.10.2.3 2001/08/12 16:22:48 hm Exp $
  31  * $DragonFly: src/sys/net/i4b/driver/i4b_rbch.c,v 1.19 2006/06/14 21:07:09 swildner Exp $
  32  *
  33  *      last edit-date: [Sat Aug 11 18:06:57 2001]
  34  *
  35  *---------------------------------------------------------------------------*/
  36
  37 #include "use_i4brbch.h"
  38
  39 #if NI4BRBCH > 0
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43
  44 #include <sys/conf.h>
  45 #include <sys/uio.h>
  46 #include <sys/kernel.h>
  47 #include <sys/mbuf.h>
  48 #include <sys/socket.h>
  49 #include <net/if.h>
  50 #include <sys/tty.h>
  51 #include <sys/thread2.h>
  52 #include <sys/vnode.h>
  53
  54 #include <net/i4b/include/machine/i4b_ioctl.h>
  55 #include <net/i4b/include/machine/i4b_rbch_ioctl.h>
  56 #include <net/i4b/include/machine/i4b_debug.h>
  57
  58 #include "../include/i4b_global.h"
  59 #include "../include/i4b_mbuf.h"
  60 #include "../include/i4b_l3l4.h"
  61 #include "../layer4/i4b_l4.h"
  62
  63 #include <sys/ioccom.h>
  64 #include <sys/poll.h>
  65 #include <sys/filio.h>
  66
  67 static drvr_link_t rbch_drvr_linktab[NI4BRBCH];
  68 static isdn_link_t *isdn_linktab[NI4BRBCH];
  69
  70 #define I4BRBCHACCT             1       /* enable accounting messages */
  71 #define I4BRBCHACCTINTVL        2       /* accounting msg interval in secs */
  72
  73 static struct rbch_softc {
  74
  75         int sc_unit;                    /* unit number          */
  76
  77         int sc_devstate;                /* state of driver      */
  78 #define ST_IDLE         0x00
  79 #define ST_CONNECTED    0x01
  80 #define ST_ISOPEN       0x02
  81 #define ST_RDWAITDATA   0x04
  82 #define ST_WRWAITEMPTY  0x08
  83 #define ST_NOBLOCK      0x10
  84
  85         int sc_bprot;                   /* B-ch protocol used   */
  86
  87         call_desc_t *sc_cd;             /* Call Descriptor */
  88
  89         struct termios it_in;
  90
  91         struct ifqueue sc_hdlcq;        /* hdlc read queue      */
  92 #define I4BRBCHMAXQLEN  10
  93
  94         struct selinfo selp;            /* select / poll        */
  95
  96 #if I4BRBCHACCT
  97         struct callout  sc_timeout;
  98
  99         int             sc_iinb;        /* isdn driver # of inbytes     */
 100         int             sc_ioutb;       /* isdn driver # of outbytes    */
 101         int             sc_linb;        /* last # of bytes rx'd         */
 102         int             sc_loutb;       /* last # of bytes tx'd         */
 103         int             sc_fn;          /* flag, first null acct        */
 104 #endif
 105 } rbch_softc[NI4BRBCH];
 106
 107 static void rbch_rx_data_rdy(int unit);
 108 static void rbch_tx_queue_empty(int unit);
 109 static void rbch_connect(int unit, void *cdp);
 110 static void rbch_disconnect(int unit, void *cdp);
 111 static void rbch_init_linktab(int unit);
 112 static void rbch_clrq(int unit);
 113
 114 #define PDEVSTATIC      static
 115 #define IOCTL_CMD_T     u_long
 116
 117 PDEVSTATIC d_open_t i4brbchopen;
 118 PDEVSTATIC d_close_t i4brbchclose;
 119 PDEVSTATIC d_read_t i4brbchread;
 120 PDEVSTATIC d_read_t i4brbchwrite;
 121 PDEVSTATIC d_ioctl_t i4brbchioctl;
 122
 123 PDEVSTATIC d_poll_t i4brbchpoll;
 124 #define POLLFIELD       i4brbchpoll
 125
 126 #define CDEV_MAJOR 57
 127
 128 static struct cdevsw i4brbch_cdevsw = {
 129         /* name */      "i4brbch",
 130         /* maj */       CDEV_MAJOR,
 131         /* flags */     0,
 132         /* port */      NULL,
 133         /* clone */     NULL,
 134
 135         /* open */      i4brbchopen,
 136         /* close */     i4brbchclose,
 137         /* read */      i4brbchread,
 138         /* write */     i4brbchwrite,
 139         /* ioctl */     i4brbchioctl,
 140         /* poll */      POLLFIELD,
 141         /* mmap */      nommap,
 142         /* strategy */  nostrategy,
 143         /* dump */      nodump,
 144         /* psize */     nopsize
 145 };
 146
 147 static void i4brbchattach(void *);
 148 PSEUDO_SET(i4brbchattach, i4b_rbch);
 149
 150 /*===========================================================================*
 151  *                      DEVICE DRIVER ROUTINES
 152  *===========================================================================*/
 153
 154 /*---------------------------------------------------------------------------*
 155  *      initialization at kernel load time
 156  *---------------------------------------------------------------------------*/
 157 static void
 158 i4brbchinit(void *unused)
 159 {
 160         cdevsw_add(&i4brbch_cdevsw, 0, 0);
 161 }
 162
 163 SYSINIT(i4brbchdev, SI_SUB_DRIVERS,
 164         SI_ORDER_MIDDLE+CDEV_MAJOR, &i4brbchinit, NULL);
 165
 166 /*---------------------------------------------------------------------------*
 167  *      interface attach routine
 168  *---------------------------------------------------------------------------*/
 169 PDEVSTATIC void
 170 i4brbchattach(void *dummy)
 171 {
 172         int i;
 173
 174 #ifndef HACK_NO_PSEUDO_ATTACH_MSG
 175         printf("i4brbch: %d raw B channel access device(s) attached\n", NI4BRBCH);
 176 #endif
 177
 178         for(i=0; i < NI4BRBCH; i++)
 179         {
 180                 make_dev(&i4brbch_cdevsw, i,
 181                         UID_ROOT, GID_WHEEL, 0600, "i4brbch%d", i);
 182
 183 #if I4BRBCHACCT
 184                 callout_init(&rbch_softc[i].sc_timeout);
 185                 rbch_softc[i].sc_fn = 1;
 186 #endif
 187                 rbch_softc[i].sc_unit = i;
 188                 rbch_softc[i].sc_devstate = ST_IDLE;
 189                 rbch_softc[i].sc_hdlcq.ifq_maxlen = I4BRBCHMAXQLEN;
 190                 rbch_softc[i].it_in.c_ispeed = rbch_softc[i].it_in.c_ospeed = 64000;
 191                 termioschars(&rbch_softc[i].it_in);
 192                 rbch_init_linktab(i);
 193         }
 194 }
 195
 196 /*---------------------------------------------------------------------------*
 197  *      open rbch device
 198  *---------------------------------------------------------------------------*/
 199 PDEVSTATIC int
 200 i4brbchopen(dev_t dev, int flag, int fmt, struct thread *td)
 201 {
 202         int unit = minor(dev);
 203
 204         if(unit >= NI4BRBCH)
 205                 return(ENXIO);
 206
 207         if(rbch_softc[unit].sc_devstate & ST_ISOPEN)
 208                 return(EBUSY);
 209
 210 #if 0
 211         rbch_clrq(unit);
 212 #endif
 213
 214         rbch_softc[unit].sc_devstate |= ST_ISOPEN;
 215
 216         NDBGL4(L4_RBCHDBG, "unit %d, open", unit);
 217
 218         return(0);
 219 }
 220
 221 /*---------------------------------------------------------------------------*
 222  *      close rbch device
 223  *---------------------------------------------------------------------------*/
 224 PDEVSTATIC int
 225 i4brbchclose(dev_t dev, int flag, int fmt, struct thread *td)
 226 {
 227         int unit = minor(dev);
 228         struct rbch_softc *sc = &rbch_softc[unit];
 229
 230         if(sc->sc_devstate & ST_CONNECTED)
 231                 i4b_l4_drvrdisc(BDRV_RBCH, unit);
 232
 233         sc->sc_devstate &= ~ST_ISOPEN;
 234
 235         rbch_clrq(unit);
 236
 237         NDBGL4(L4_RBCHDBG, "unit %d, closed", unit);
 238
 239         return(0);
 240 }
 241
 242 /*---------------------------------------------------------------------------*
 243  *      read from rbch device
 244  *---------------------------------------------------------------------------*/
 245 PDEVSTATIC int
 246 i4brbchread(dev_t dev, struct uio *uio, int ioflag)
 247 {
 248         struct mbuf *m;
 249         int error = 0;
 250         int unit = minor(dev);
 251         struct ifqueue *iqp;
 252         struct rbch_softc *sc = &rbch_softc[unit];
 253
 254         CRIT_VAR;
 255
 256         NDBGL4(L4_RBCHDBG, "unit %d, enter read", unit);
 257
 258         CRIT_BEG;
 259         if(!(sc->sc_devstate & ST_ISOPEN))
 260         {
 261                 CRIT_END;
 262                 NDBGL4(L4_RBCHDBG, "unit %d, read while not open", unit);
 263                 return(EIO);
 264         }
 265
 266         if((sc->sc_devstate & ST_NOBLOCK) || (ioflag & IO_NDELAY))
 267         {
 268                 if(!(sc->sc_devstate & ST_CONNECTED)) {
 269                         CRIT_END;
 270                         return(EWOULDBLOCK);
 271                 }
 272
 273                 if(sc->sc_bprot == BPROT_RHDLC)
 274                         iqp = &sc->sc_hdlcq;
 275                 else
 276                         iqp = isdn_linktab[unit]->rx_queue;
 277
 278                 if(IF_QEMPTY(iqp) && (sc->sc_devstate & ST_ISOPEN)) {
 279                         CRIT_END;
 280                         return(EWOULDBLOCK);
 281         }
 282         }
 283         else
 284         {
 285                 while(!(sc->sc_devstate & ST_CONNECTED))
 286                 {
 287                         NDBGL4(L4_RBCHDBG, "unit %d, wait read init", unit);
 288
 289                         if((error = tsleep((caddr_t) &rbch_softc[unit],
 290                                                PCATCH, "rrrbch", 0 )) != 0)
 291                         {
 292                                 CRIT_END;
 293                                 NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep", unit, error);
 294                                 return(error);
 295                         }
 296                 }
 297
 298                 if(sc->sc_bprot == BPROT_RHDLC)
 299                         iqp = &sc->sc_hdlcq;
 300                 else
 301                         iqp = isdn_linktab[unit]->rx_queue;
 302
 303                 while(IF_QEMPTY(iqp) && (sc->sc_devstate & ST_ISOPEN))
 304                 {
 305                         sc->sc_devstate |= ST_RDWAITDATA;
 306
 307                         NDBGL4(L4_RBCHDBG, "unit %d, wait read data", unit);
 308
 309                         if((error = tsleep((caddr_t) &isdn_linktab[unit]->rx_queue,
 310                                            PCATCH, "rrbch", 0 )) != 0)
 311                         {
 312                                 CRIT_END;
 313                                 NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep read", unit, error);
 314                                 sc->sc_devstate &= ~ST_RDWAITDATA;
 315                                 return(error);
 316                         }
 317                 }
 318         }
 319
 320         IF_DEQUEUE(iqp, m);
 321
 322         NDBGL4(L4_RBCHDBG, "unit %d, read %d bytes", unit, m->m_len);
 323
 324         if(m && m->m_len)
 325         {
 326                 error = uiomove(m->m_data, m->m_len, uio);
 327         }
 328         else
 329         {
 330                 NDBGL4(L4_RBCHDBG, "unit %d, error %d uiomove", unit, error);
 331                 error = EIO;
 332         }
 333
 334         if(m)
 335                 i4b_Bfreembuf(m);
 336
 337         CRIT_END;
 338
 339         return(error);
 340 }
 341
 342 /*---------------------------------------------------------------------------*
 343  *      write to rbch device
 344  *---------------------------------------------------------------------------*/
 345 PDEVSTATIC int
 346 i4brbchwrite(dev_t dev, struct uio * uio, int ioflag)
 347 {
 348         struct mbuf *m;
 349         int error = 0;
 350         int unit = minor(dev);
 351         struct rbch_softc *sc = &rbch_softc[unit];
 352
 353         CRIT_VAR;
 354
 355         NDBGL4(L4_RBCHDBG, "unit %d, write", unit);
 356
 357         CRIT_BEG;
 358         if(!(sc->sc_devstate & ST_ISOPEN))
 359         {
 360                 NDBGL4(L4_RBCHDBG, "unit %d, write while not open", unit);
 361                 CRIT_END;
 362                 return(EIO);
 363         }
 364
 365         if((sc->sc_devstate & ST_NOBLOCK) || (ioflag & IO_NDELAY))
 366         {
 367                 if(!(sc->sc_devstate & ST_CONNECTED)) {
 368                         CRIT_END;
 369                         return(EWOULDBLOCK);
 370                 }
 371                 if(IF_QFULL(isdn_linktab[unit]->tx_queue) && (sc->sc_devstate & ST_ISOPEN)) {
 372                         CRIT_END;
 373                         return(EWOULDBLOCK);
 374         }
 375         }
 376         else
 377         {
 378                 while(!(sc->sc_devstate & ST_CONNECTED))
 379                 {
 380                         NDBGL4(L4_RBCHDBG, "unit %d, write wait init", unit);
 381
 382                         error = tsleep((caddr_t) &rbch_softc[unit],
 383                                                    PCATCH, "wrrbch", 0 );
 384                         if(error == ERESTART) {
 385                                 CRIT_END;
 386                                 return (ERESTART);
 387                         }
 388                         else if(error == EINTR)
 389                         {
 390                                 CRIT_END;
 391                                 NDBGL4(L4_RBCHDBG, "unit %d, EINTR during wait init", unit);
 392                                 return(EINTR);
 393                         }
 394                         else if(error)
 395                         {
 396                                 CRIT_END;
 397                                 NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep init", unit, error);
 398                                 return(error);
 399                         }
 400                         tsleep((caddr_t) &rbch_softc[unit], PCATCH, "xrbch", (hz*1));
 401                 }
 402
 403                 while(IF_QFULL(isdn_linktab[unit]->tx_queue) && (sc->sc_devstate & ST_ISOPEN))
 404                 {
 405                         sc->sc_devstate |= ST_WRWAITEMPTY;
 406
 407                         NDBGL4(L4_RBCHDBG, "unit %d, write queue full", unit);
 408
 409                         if ((error = tsleep((caddr_t) &isdn_linktab[unit]->tx_queue,
 410                                             PCATCH, "wrbch", 0)) != 0) {
 411                                 sc->sc_devstate &= ~ST_WRWAITEMPTY;
 412                                 if(error == ERESTART)
 413                                 {
 414                                         CRIT_END;
 415                                         return(ERESTART);
 416                                 }
 417                                 else if(error == EINTR)
 418                                 {
 419                                         CRIT_END;
 420                                         NDBGL4(L4_RBCHDBG, "unit %d, EINTR during wait write", unit);
 421                                         return(error);
 422                                 }
 423                                 else if(error)
 424                                 {
 425                                         CRIT_END;
 426                                         NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep write", unit, error);
 427                                         return(error);
 428                                 }
 429                         }
 430                 }
 431         }
 432
 433         if(!(sc->sc_devstate & ST_ISOPEN))
 434         {
 435                 NDBGL4(L4_RBCHDBG, "unit %d, not open anymore", unit);
 436                 CRIT_END;
 437                 return(EIO);
 438         }
 439
 440         if((m = i4b_Bgetmbuf(BCH_MAX_DATALEN)) != NULL)
 441         {
 442                 m->m_len = min(BCH_MAX_DATALEN, uio->uio_resid);
 443
 444                 NDBGL4(L4_RBCHDBG, "unit %d, write %d bytes", unit, m->m_len);
 445
 446                 error = uiomove(m->m_data, m->m_len, uio);
 447
 448                 if(IF_QFULL(isdn_linktab[unit]->tx_queue))
 449                         m_freem(m);
 450                 else
 451                         IF_ENQUEUE(isdn_linktab[unit]->tx_queue, m);
 452                 (*isdn_linktab[unit]->bch_tx_start)(isdn_linktab[unit]->unit, isdn_linktab[unit]->channel);
 453         }
 454
 455         CRIT_END;
 456
 457         return(error);
 458 }
 459
 460 /*---------------------------------------------------------------------------*
 461  *      rbch device ioctl handlibg
 462  *---------------------------------------------------------------------------*/
 463 PDEVSTATIC int
 464 i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct thread *td)
 465 {
 466         int error = 0;
 467         int unit = minor(dev);
 468         struct rbch_softc *sc = &rbch_softc[unit];
 469
 470         switch(cmd)
 471         {
 472                 case FIOASYNC:  /* Set async mode */
 473                         if (*(int *)data)
 474                         {
 475                                 NDBGL4(L4_RBCHDBG, "unit %d, setting async mode", unit);
 476                         }
 477                         else
 478                         {
 479                                 NDBGL4(L4_RBCHDBG, "unit %d, clearing async mode", unit);
 480                         }
 481                         break;
 482
 483                 case TIOCCDTR:  /* Clear DTR */
 484                         if(sc->sc_devstate & ST_CONNECTED)
 485                         {
 486                                 NDBGL4(L4_RBCHDBG, "unit %d, disconnecting for DTR down", unit);
 487                                 i4b_l4_drvrdisc(BDRV_RBCH, unit);
 488                         }
 489                         break;
 490
 491                 case I4B_RBCH_DIALOUT:
 492                 {
 493                         size_t l;
 494
 495                         for (l = 0; l < TELNO_MAX && ((char *)data)[l]; l++)
 496                                 ;
 497                         if (l)
 498                         {
 499                                 NDBGL4(L4_RBCHDBG, "unit %d, attempting dialout to %s", unit, (char *)data);
 500                                 i4b_l4_dialoutnumber(BDRV_RBCH, unit, l, (char *)data);
 501                                 break;
 502                         }
 503                         /* fall through to SDTR */
 504                 }
 505
 506                 case TIOCSDTR:  /* Set DTR */
 507                         NDBGL4(L4_RBCHDBG, "unit %d, attempting dialout (DTR)", unit);
 508                         i4b_l4_dialout(BDRV_RBCH, unit);
 509                         break;
 510
 511                 case TIOCSETA:  /* Set termios struct */
 512                         break;
 513
 514                 case TIOCGETA:  /* Get termios struct */
 515                         *(struct termios *)data = sc->it_in;
 516                         break;
 517
 518                 case TIOCMGET:
 519                         *(int *)data = TIOCM_LE|TIOCM_DTR|TIOCM_RTS|TIOCM_CTS|TIOCM_DSR;
 520                         if (sc->sc_devstate & ST_CONNECTED)
 521                                 *(int *)data |= TIOCM_CD;
 522                         break;
 523
 524                 case I4B_RBCH_VR_REQ:
 525                 {
 526                         msg_vr_req_t *mvr;
 527
 528                         mvr = (msg_vr_req_t *)data;
 529
 530                         mvr->version = VERSION;
 531                         mvr->release = REL;
 532                         mvr->step = STEP;
 533                         break;
 534                 }
 535
 536                 default:        /* Unknown stuff */
 537                         NDBGL4(L4_RBCHDBG, "unit %d, ioctl, unknown cmd %lx", unit, (u_long)cmd);
 538                         error = EINVAL;
 539                         break;
 540         }
 541         return(error);
 542 }
 543
 544 /*---------------------------------------------------------------------------*
 545  *      device driver poll
 546  *---------------------------------------------------------------------------*/
 547 PDEVSTATIC int
 548 i4brbchpoll(dev_t dev, int events, struct thread *td)
 549 {
 550         int revents = 0;        /* Events we found */
 551         int unit = minor(dev);
 552         struct rbch_softc *sc = &rbch_softc[unit];
 553
 554         /* We can't check for anything but IN or OUT */
 555         crit_enter();
 556
 557         if(!(sc->sc_devstate & ST_ISOPEN))
 558         {
 559                 crit_exit();
 560                 return(POLLNVAL);
 561         }
 562
 563         /*
 564          * Writes are OK if we are connected and the
 565          * transmit queue can take them
 566          */
 567
 568         if((events & (POLLOUT|POLLWRNORM)) &&
 569            (sc->sc_devstate & ST_CONNECTED) &&
 570            !IF_QFULL(isdn_linktab[unit]->tx_queue))
 571         {
 572                 revents |= (events & (POLLOUT|POLLWRNORM));
 573         }
 574
 575         /* ... while reads are OK if we have any data */
 576
 577         if((events & (POLLIN|POLLRDNORM)) &&
 578            (sc->sc_devstate & ST_CONNECTED))
 579         {
 580                 struct ifqueue *iqp;
 581
 582                 if(sc->sc_bprot == BPROT_RHDLC)
 583                         iqp = &sc->sc_hdlcq;
 584                 else
 585                         iqp = isdn_linktab[unit]->rx_queue;
 586
 587                 if(!IF_QEMPTY(iqp))
 588                         revents |= (events & (POLLIN|POLLRDNORM));
 589         }
 590
 591         if(revents == 0)
 592                 selrecord(td, &sc->selp);
 593
 594         crit_exit();
 595         return(revents);
 596 }
 597
 598 #if I4BRBCHACCT
 599 /*---------------------------------------------------------------------------*
 600  *      watchdog routine
 601  *---------------------------------------------------------------------------*/
 602 static void
 603 rbch_timeout(struct rbch_softc *sc)
 604 {
 605         bchan_statistics_t bs;
 606         int unit = sc->sc_unit;
 607
 608         /* get # of bytes in and out from the HSCX driver */
 609
 610         (*isdn_linktab[unit]->bch_stat)
 611                 (isdn_linktab[unit]->unit, isdn_linktab[unit]->channel, &bs);
 612
 613         sc->sc_ioutb += bs.outbytes;
 614         sc->sc_iinb += bs.inbytes;
 615
 616         if((sc->sc_iinb != sc->sc_linb) || (sc->sc_ioutb != sc->sc_loutb) || sc->sc_fn)
 617         {
 618                 int ri = (sc->sc_iinb - sc->sc_linb)/I4BRBCHACCTINTVL;
 619                 int ro = (sc->sc_ioutb - sc->sc_loutb)/I4BRBCHACCTINTVL;
 620
 621                 if((sc->sc_iinb == sc->sc_linb) && (sc->sc_ioutb == sc->sc_loutb))
 622                         sc->sc_fn = 0;
 623                 else
 624                         sc->sc_fn = 1;
 625
 626                 sc->sc_linb = sc->sc_iinb;
 627                 sc->sc_loutb = sc->sc_ioutb;
 628
 629                 i4b_l4_accounting(BDRV_RBCH, unit, ACCT_DURING,
 630                          sc->sc_ioutb, sc->sc_iinb, ro, ri, sc->sc_ioutb, sc->sc_iinb);
 631         }
 632         callout_reset(&sc->sc_timeout, I4BRBCHACCTINTVL * hz,
 633                         (void *)rbch_timeout, sc);
 634 }
 635 #endif /* I4BRBCHACCT */
 636
 637 /*===========================================================================*
 638  *                      ISDN INTERFACE ROUTINES
 639  *===========================================================================*/
 640
 641 /*---------------------------------------------------------------------------*
 642  *      this routine is called from L4 handler at connect time
 643  *---------------------------------------------------------------------------*/
 644 static void
 645 rbch_connect(int unit, void *cdp)
 646 {
 647         call_desc_t *cd = (call_desc_t *)cdp;
 648         struct rbch_softc *sc = &rbch_softc[unit];
 649
 650         sc->sc_bprot = cd->bprot;
 651
 652 #if I4BRBCHACCT
 653         if(sc->sc_bprot == BPROT_RHDLC)
 654         {
 655                 sc->sc_iinb = 0;
 656                 sc->sc_ioutb = 0;
 657                 sc->sc_linb = 0;
 658                 sc->sc_loutb = 0;
 659
 660                 callout_reset(&sc->sc_timeout, I4BRBCHACCTINTVL * hz,
 661                                 (void *)rbch_timeout, sc);
 662         }
 663 #endif
 664         if(!(sc->sc_devstate & ST_CONNECTED))
 665         {
 666                 NDBGL4(L4_RBCHDBG, "unit %d, wakeup", unit);
 667                 sc->sc_devstate |= ST_CONNECTED;
 668                 sc->sc_cd = cdp;
 669                 wakeup((caddr_t)sc);
 670         }
 671 }
 672
 673 /*---------------------------------------------------------------------------*
 674  *      this routine is called from L4 handler at disconnect time
 675  *---------------------------------------------------------------------------*/
 676 static void
 677 rbch_disconnect(int unit, void *cdp)
 678 {
 679         call_desc_t *cd = (call_desc_t *)cdp;
 680         struct rbch_softc *sc = &rbch_softc[unit];
 681
 682         CRIT_VAR;
 683
 684         if(cd != sc->sc_cd)
 685         {
 686                 NDBGL4(L4_RBCHDBG, "rbch%d: channel %d not active",
 687                         cd->driver_unit, cd->channelid);
 688                 return;
 689         }
 690
 691         CRIT_BEG;
 692
 693         NDBGL4(L4_RBCHDBG, "unit %d, disconnect", unit);
 694
 695         sc->sc_devstate &= ~ST_CONNECTED;
 696
 697         sc->sc_cd = NULL;
 698
 699 #if I4BRBCHACCT
 700         i4b_l4_accounting(BDRV_RBCH, unit, ACCT_FINAL,
 701                  sc->sc_ioutb, sc->sc_iinb, 0, 0, sc->sc_ioutb, sc->sc_iinb);
 702         callout_stop(&sc->sc_timeout);
 703 #endif
 704         CRIT_END;
 705 }
 706
 707 /*---------------------------------------------------------------------------*
 708  *      feedback from daemon in case of dial problems
 709  *---------------------------------------------------------------------------*/
 710 static void
 711 rbch_dialresponse(int unit, int status, cause_t cause)
 712 {
 713 }
 714
 715 /*---------------------------------------------------------------------------*
 716  *      interface up/down
 717  *---------------------------------------------------------------------------*/
 718 static void
 719 rbch_updown(int unit, int updown)
 720 {
 721 }
 722
 723 /*---------------------------------------------------------------------------*
 724  *      this routine is called from the HSCX interrupt handler
 725  *      when a new frame (mbuf) has been received and is to be put on
 726  *      the rx queue.
 727  *---------------------------------------------------------------------------*/
 728 static void
 729 rbch_rx_data_rdy(int unit)
 730 {
 731         if(rbch_softc[unit].sc_bprot == BPROT_RHDLC)
 732         {
 733                 struct mbuf *m;
 734
 735                 if((m = *isdn_linktab[unit]->rx_mbuf) == NULL)
 736                         return;
 737
 738                 m->m_pkthdr.len = m->m_len;
 739
 740                 if(IF_QFULL(&(rbch_softc[unit].sc_hdlcq)))
 741                 {
 742                         NDBGL4(L4_RBCHDBG, "unit %d: hdlc rx queue full!", unit);
 743                         m_freem(m);
 744                 }
 745                 else
 746                 {
 747                         IF_ENQUEUE(&(rbch_softc[unit].sc_hdlcq), m);
 748                 }
 749         }
 750
 751         if(rbch_softc[unit].sc_devstate & ST_RDWAITDATA)
 752         {
 753                 NDBGL4(L4_RBCHDBG, "unit %d, wakeup", unit);
 754                 rbch_softc[unit].sc_devstate &= ~ST_RDWAITDATA;
 755                 wakeup((caddr_t) &isdn_linktab[unit]->rx_queue);
 756         }
 757         else
 758         {
 759                 NDBGL4(L4_RBCHDBG, "unit %d, NO wakeup", unit);
 760         }
 761         selwakeup(&rbch_softc[unit].selp);
 762 }
 763
 764 /*---------------------------------------------------------------------------*
 765  *      this routine is called from the HSCX interrupt handler
 766  *      when the last frame has been sent out and there is no
 767  *      further frame (mbuf) in the tx queue.
 768  *---------------------------------------------------------------------------*/
 769 static void
 770 rbch_tx_queue_empty(int unit)
 771 {
 772         if(rbch_softc[unit].sc_devstate & ST_WRWAITEMPTY)
 773         {
 774                 NDBGL4(L4_RBCHDBG, "unit %d, wakeup", unit);
 775                 rbch_softc[unit].sc_devstate &= ~ST_WRWAITEMPTY;
 776                 wakeup((caddr_t) &isdn_linktab[unit]->tx_queue);
 777         }
 778         else
 779         {
 780                 NDBGL4(L4_RBCHDBG, "unit %d, NO wakeup", unit);
 781         }
 782         selwakeup(&rbch_softc[unit].selp);
 783 }
 784
 785 /*---------------------------------------------------------------------------*
 786  *      this routine is called from the HSCX interrupt handler
 787  *      each time a packet is received or transmitted
 788  *---------------------------------------------------------------------------*/
 789 static void
 790 rbch_activity(int unit, int rxtx)
 791 {
 792         if (rbch_softc[unit].sc_cd)
 793                 rbch_softc[unit].sc_cd->last_active_time = SECOND;
 794         selwakeup(&rbch_softc[unit].selp);
 795 }
 796
 797 /*---------------------------------------------------------------------------*
 798  *      clear an hdlc rx queue for a rbch unit
 799  *---------------------------------------------------------------------------*/
 800 static void
 801 rbch_clrq(int unit)
 802 {
 803         CRIT_VAR;
 804
 805         CRIT_BEG;
 806         IF_DRAIN(&rbch_softc[unit].sc_hdlcq);
 807         CRIT_END;
 808 }
 809
 810 /*---------------------------------------------------------------------------*
 811  *      return this drivers linktab address
 812  *---------------------------------------------------------------------------*/
 813 drvr_link_t *
 814 rbch_ret_linktab(int unit)
 815 {
 816         rbch_init_linktab(unit);
 817         return(&rbch_drvr_linktab[unit]);
 818 }
 819
 820 /*---------------------------------------------------------------------------*
 821  *      setup the isdn_linktab for this driver
 822  *---------------------------------------------------------------------------*/
 823 void
 824 rbch_set_linktab(int unit, isdn_link_t *ilt)
 825 {
 826         isdn_linktab[unit] = ilt;
 827 }
 828
 829 /*---------------------------------------------------------------------------*
 830  *      initialize this drivers linktab
 831  *---------------------------------------------------------------------------*/
 832 static void
 833 rbch_init_linktab(int unit)
 834 {
 835         rbch_drvr_linktab[unit].unit = unit;
 836         rbch_drvr_linktab[unit].bch_rx_data_ready = rbch_rx_data_rdy;
 837         rbch_drvr_linktab[unit].bch_tx_queue_empty = rbch_tx_queue_empty;
 838         rbch_drvr_linktab[unit].bch_activity = rbch_activity;
 839         rbch_drvr_linktab[unit].line_connected = rbch_connect;
 840         rbch_drvr_linktab[unit].line_disconnected = rbch_disconnect;
 841         rbch_drvr_linktab[unit].dial_response = rbch_dialresponse;
 842         rbch_drvr_linktab[unit].updown_ind = rbch_updown;
 843 }
 844
 845 /*===========================================================================*/
 846
 847 #endif /* NI4BRBCH > 0 */