sys/net/i4b/driver/i4b_isppp.c

   1 /*
   2  *   Copyright (c) 1997 Joerg Wunsch. All rights reserved.
   3  *
   4  *   Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *   1. Redistributions of source code must retain the above copyright
  11  *      notice, this list of conditions and the following disclaimer.
  12  *   2. Redistributions in binary form must reproduce the above copyright
  13  *      notice, this list of conditions and the following disclaimer in the
  14  *      documentation and/or other materials provided with the distribution.
  15  *
  16  *   THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  *   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  *   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  *   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  *   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  *   OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  *   OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  *   SUCH DAMAGE.
  27  *
  28  *---------------------------------------------------------------------------
  29  *
  30  *      i4b_isppp.c - isdn4bsd kernel SyncPPP driver
  31  *      --------------------------------------------
  32  *
  33  *      Uses Serge Vakulenko's sppp backend (originally contributed with
  34  *      the "cx" driver for Cronyx's HDLC-in-hardware device).  This driver
  35  *      is only the glue between sppp and i4b.
  36  *
  37  *      $Id: i4b_isppp.c,v 1.44 2000/08/31 07:07:26 hm Exp $
  38  *
  39  * $FreeBSD: src/sys/i4b/driver/i4b_isppp.c,v 1.7.2.3 2003/02/06 14:50:53 gj Exp $
  40  * $DragonFly: src/sys/net/i4b/driver/i4b_isppp.c,v 1.5 2004/01/06 03:17:26 dillon Exp $
  41  *
  42  *      last edit-date: [Thu Aug 31 09:02:27 2000]
  43  *
  44  *---------------------------------------------------------------------------*/
  45
  46
  47 #ifndef __NetBSD__
  48 #endif
  49 #include "use_i4bisppp.h"
  50
  51 #ifndef __NetBSD__
  52 #if NI4BISPPP == 0
  53 # error "You need to define `device sppp <N>' with options ISPPP"
  54 #endif
  55 #endif
  56
  57 #include <sys/param.h>
  58 #include <sys/systm.h>
  59 #include <sys/mbuf.h>
  60 #include <sys/socket.h>
  61 #include <sys/errno.h>
  62 #include <sys/ioccom.h>
  63 #include <sys/sockio.h>
  64 #include <sys/kernel.h>
  65
  66 #include <net/if.h>
  67 #include <net/if_types.h>
  68 #include <net/sppp/if_sppp.h>
  69
  70
  71 #if defined(__FreeBSD_version) &&  __FreeBSD_version >= 400008
  72 #include "use_bpf.h"
  73 #else
  74 #include "bpfilter.h"
  75 #endif
  76 #if NBPFILTER > 0 || NBPF > 0
  77 #include <sys/time.h>
  78 #include <net/bpf.h>
  79 #endif
  80
  81 #ifdef __FreeBSD__
  82 #include <net/i4b/include/machine/i4b_debug.h>
  83 #include <net/i4b/include/machine/i4b_ioctl.h>
  84 #else
  85 #include <i4b/i4b_ioctl.h>
  86 #include <i4b/i4b_cause.h>
  87 #include <i4b/i4b_debug.h>
  88 #endif
  89
  90 #include "../include/i4b_global.h"
  91 #include "../include/i4b_l3l4.h"
  92 #include "../layer4/i4b_l4.h"
  93
  94 #ifdef __FreeBSD__
  95 #define PDEVSTATIC      static
  96
  97 #ifdef __DragonFly__
  98 #define ISPPP_FMT       "%s: "
  99 #define ISPPP_ARG(sc)   ((sc)->sc_if.if_xname)
 100 #define IFP2UNIT(ifp)   ((struct i4bisppp_softc *)ifp->if_softc)->sc_unit
 101 #else
 102 #define ISPPP_FMT       "isp%d: "
 103 #define ISPPP_ARG(sc)   ((sc)->sc_if.if_unit)
 104 #define IFP2UNIT(ifp)   (ifp)->if_unit
 105 #endif
 106
 107 # if __FreeBSD_version >= 300001
 108 #  define CALLOUT_INIT(chan)            callout_handle_init(chan)
 109 #  define TIMEOUT(fun, arg, chan, tick) chan = timeout(fun, arg, tick)
 110 #  define UNTIMEOUT(fun, arg, chan)     untimeout(fun, arg, chan)
 111 #  define IOCTL_CMD_T u_long
 112 # else
 113 #  define CALLOUT_INIT(chan)            do {} while(0)
 114 #  define TIMEOUT(fun, arg, chan, tick) timeout(fun, arg, tick)
 115 #  define UNTIMEOUT(fun, arg, chan)     untimeout(fun, arg)
 116 #  define IOCTL_CMD_T int
 117 # endif
 118
 119 #elif defined __NetBSD__ || defined __OpenBSD__
 120 #define ISPPP_FMT       "%s: "
 121 #define ISPPP_ARG(sc)   ((sc)->sc_if.if_xname)
 122 #define PDEVSTATIC      /* not static */
 123 #define IOCTL_CMD_T     u_long
 124 #define IFP2UNIT(ifp)   ((struct i4bisppp_softc *)ifp->if_softc)->sc_unit
 125 #else
 126 # error "What system are you using?"
 127 #endif
 128
 129 #ifdef __FreeBSD__
 130 PDEVSTATIC void i4bispppattach(void *);
 131 PSEUDO_SET(i4bispppattach, i4b_isppp);
 132 #else
 133 PDEVSTATIC void i4bispppattach(void);
 134 #endif
 135
 136 #define I4BISPPPACCT            1       /* enable accounting messages */
 137 #define I4BISPPPACCTINTVL       2       /* accounting msg interval in secs */
 138 #define I4BISPPPDISCDEBUG       1
 139
 140 #define PPP_HDRLEN              4       /* 4 octetts PPP header length  */
 141
 142 struct i4bisppp_softc {
 143         /*
 144          * struct sppp starts with a struct ifnet, but we gotta allocate
 145          * more space for it.  NB: do not relocate this union, it must
 146          * be first in isppp_softc.  The tls and tlf hooks below want to
 147          * convert a ``struct sppp *'' into a ``struct isppp_softc *''.
 148          */
 149         union {
 150                 struct ifnet scu_if;
 151                 struct sppp scu_sp;
 152         } sc_if_un;
 153 #define sc_if sc_if_un.scu_if
 154
 155         int     sc_state;       /* state of the interface       */
 156
 157 #if !defined(__FreeBSD__) || defined(__DragonFly__)
 158         int     sc_unit;        /* unit number for Net/OpenBSD  */
 159 #endif
 160
 161         call_desc_t *sc_cdp;    /* ptr to call descriptor       */
 162
 163 #ifdef I4BISPPPACCT
 164         int sc_iinb;            /* isdn driver # of inbytes     */
 165         int sc_ioutb;           /* isdn driver # of outbytes    */
 166         int sc_inb;             /* # of bytes rx'd              */
 167         int sc_outb;            /* # of bytes tx'd              */
 168         int sc_linb;            /* last # of bytes rx'd         */
 169         int sc_loutb;           /* last # of bytes tx'd         */
 170         int sc_fn;              /* flag, first null acct        */
 171 #endif
 172
 173 #if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
 174         struct callout_handle sc_ch;
 175 #endif
 176
 177 } i4bisppp_softc[NI4BISPPP];
 178
 179 static void     i4bisppp_init_linktab(int unit);
 180 static int      i4bisppp_ioctl(struct ifnet *ifp, IOCTL_CMD_T cmd, caddr_t data);
 181
 182 #if 0
 183 static void     i4bisppp_send(struct ifnet *ifp);
 184 #endif
 185
 186 static void     i4bisppp_start(struct ifnet *ifp);
 187
 188 #if 0 /* never used ??? */
 189 static void     i4bisppp_timeout(void *cookie);
 190 #endif
 191
 192 static void     i4bisppp_tls(struct sppp *sp);
 193 static void     i4bisppp_tlf(struct sppp *sp);
 194 static void     i4bisppp_state_changed(struct sppp *sp, int new_state);
 195 static void     i4bisppp_negotiation_complete(struct sppp *sp);
 196 static void     i4bisppp_watchdog(struct ifnet *ifp);
 197 time_t          i4bisppp_idletime(int unit);
 198
 199 /* initialized by L4 */
 200
 201 static drvr_link_t i4bisppp_drvr_linktab[NI4BISPPP];
 202 static isdn_link_t *isdn_linktab[NI4BISPPP];
 203
 204 enum i4bisppp_states {
 205         ST_IDLE,                        /* initialized, ready, idle     */
 206         ST_DIALING,                     /* dialling out to remote       */
 207         ST_CONNECTED,                   /* connected to remote          */
 208 };
 209
 210 /*===========================================================================*
 211  *                      DEVICE DRIVER ROUTINES
 212  *===========================================================================*/
 213
 214 /*---------------------------------------------------------------------------*
 215  *      interface attach routine at kernel boot time
 216  *---------------------------------------------------------------------------*/
 217 PDEVSTATIC void
 218 #ifdef __FreeBSD__
 219 i4bispppattach(void *dummy)
 220 #else
 221 i4bispppattach()
 222 #endif
 223 {
 224         struct i4bisppp_softc *sc = i4bisppp_softc;
 225         int i;
 226
 227 #ifndef HACK_NO_PSEUDO_ATTACH_MSG
 228 #ifdef SPPP_VJ
 229         printf("i4bisppp: %d ISDN SyncPPP device(s) attached (VJ header compression)\n", NI4BISPPP);
 230 #else
 231         printf("i4bisppp: %d ISDN SyncPPP device(s) attached\n", NI4BISPPP);
 232 #endif
 233 #endif
 234
 235         for(i = 0; i < NI4BISPPP; sc++, i++) {
 236                 i4bisppp_init_linktab(i);
 237
 238                 sc->sc_if.if_softc = sc;
 239
 240 #ifdef __DragonFly__
 241                 if_initname(&(sc->sc_if), "isp", i);
 242 #elif defined__FreeBSD__)
 243                 sc->sc_if.if_name = "isp";
 244 #if defined(__FreeBSD_version) && __FreeBSD_version < 300001
 245                 sc->sc_if.if_next = NULL;
 246 #endif
 247                 sc->sc_if.if_unit = i;
 248 #else
 249                 sprintf(sc->sc_if.if_xname, "isp%d", i);
 250                 sc->sc_unit = i;
 251 #endif
 252
 253                 sc->sc_if.if_mtu = PP_MTU;
 254
 255 #ifdef __NetBSD__
 256                 sc->sc_if.if_flags = IFF_SIMPLEX | IFF_POINTOPOINT |
 257                                         IFF_MULTICAST;
 258 #else
 259                 sc->sc_if.if_flags = IFF_SIMPLEX | IFF_POINTOPOINT;
 260 #endif
 261
 262                 sc->sc_if.if_type = IFT_ISDNBASIC;
 263                 sc->sc_state = ST_IDLE;
 264
 265                 sc->sc_if.if_ioctl = i4bisppp_ioctl;
 266
 267                 /* actually initialized by sppp_attach() */
 268                 /* sc->sc_if.if_output = sppp_output; */
 269
 270                 sc->sc_if.if_start = i4bisppp_start;
 271
 272                 sc->sc_if.if_hdrlen = 0;
 273                 sc->sc_if.if_addrlen = 0;
 274                 sc->sc_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
 275
 276                 sc->sc_if.if_ipackets = 0;
 277                 sc->sc_if.if_ierrors = 0;
 278                 sc->sc_if.if_opackets = 0;
 279                 sc->sc_if.if_oerrors = 0;
 280                 sc->sc_if.if_collisions = 0;
 281                 sc->sc_if.if_ibytes = 0;
 282                 sc->sc_if.if_obytes = 0;
 283                 sc->sc_if.if_imcasts = 0;
 284                 sc->sc_if.if_omcasts = 0;
 285                 sc->sc_if.if_iqdrops = 0;
 286                 sc->sc_if.if_noproto = 0;
 287
 288 #if I4BISPPPACCT
 289                 sc->sc_if.if_timer = 0;
 290                 sc->sc_if.if_watchdog = i4bisppp_watchdog;
 291                 sc->sc_iinb = 0;
 292                 sc->sc_ioutb = 0;
 293                 sc->sc_inb = 0;
 294                 sc->sc_outb = 0;
 295                 sc->sc_linb = 0;
 296                 sc->sc_loutb = 0;
 297                 sc->sc_fn = 1;
 298 #endif
 299
 300                 sc->sc_if_un.scu_sp.pp_tls = i4bisppp_tls;
 301                 sc->sc_if_un.scu_sp.pp_tlf = i4bisppp_tlf;
 302                 sc->sc_if_un.scu_sp.pp_con = i4bisppp_negotiation_complete;
 303                 sc->sc_if_un.scu_sp.pp_chg = i4bisppp_state_changed;
 304
 305                 sppp_attach(&sc->sc_if);
 306 #if defined(__FreeBSD_version) && ((__FreeBSD_version >= 500009) || (410000 <= __FreeBSD_version && __FreeBSD_version < 500000))
 307                 /* do not call bpfattach in ether_ifattach */
 308                 ether_ifattach(&sc->sc_if, 0);
 309 #else
 310                 if_attach(&sc->sc_if);
 311 #endif
 312
 313 #if NBPFILTER > 0 || NBPF > 0
 314 #ifdef __FreeBSD__
 315                 bpfattach(&sc->sc_if, DLT_PPP, PPP_HDRLEN);
 316                 CALLOUT_INIT(&sc->sc_ch);
 317 #endif /* __FreeBSD__ */
 318 #ifdef __NetBSD__
 319                 bpfattach(&sc->sc_if.if_bpf, &sc->sc_if, DLT_PPP, sizeof(u_int));
 320 #endif
 321 #endif
 322         }
 323 }
 324
 325 /*---------------------------------------------------------------------------*
 326  *      process ioctl
 327  *---------------------------------------------------------------------------*/
 328 static int
 329 i4bisppp_ioctl(struct ifnet *ifp, IOCTL_CMD_T cmd, caddr_t data)
 330 {
 331         struct i4bisppp_softc *sc = ifp->if_softc;
 332 #if 0
 333         struct sppp *sp = (struct sppp *)sc;
 334         struct ifaddr *ifa = (struct ifaddr *) data;
 335         struct ifreq *ifr = (struct ifreq *) data;
 336 #endif
 337
 338         int error;
 339
 340         error = sppp_ioctl(&sc->sc_if, cmd, data);
 341         if (error)
 342                 return error;
 343
 344         switch(cmd) {
 345         case SIOCSIFFLAGS:
 346 #if 0 /* never used ??? */
 347                 x = splimp();
 348                 if ((ifp->if_flags & IFF_UP) == 0)
 349                         UNTIMEOUT(i4bisppp_timeout, (void *)sp, sc->sc_ch);
 350                 splx(x);
 351 #endif
 352                 break;
 353         }
 354
 355         return 0;
 356 }
 357
 358 /*---------------------------------------------------------------------------*
 359  *      start output to ISDN B-channel
 360  *---------------------------------------------------------------------------*/
 361 static void
 362 i4bisppp_start(struct ifnet *ifp)
 363 {
 364         struct i4bisppp_softc *sc = ifp->if_softc;
 365         struct mbuf *m;
 366         /* int s; */
 367         int unit = IFP2UNIT(ifp);
 368
 369         if (sppp_isempty(ifp))
 370                 return;
 371
 372         if(sc->sc_state != ST_CONNECTED)
 373                 return;
 374
 375         /*
 376          * s = splimp();
 377          * ifp->if_flags |= IFF_OACTIVE; // - need to clear this somewhere
 378          * splx(s);
 379          */
 380
 381         while ((m = sppp_dequeue(&sc->sc_if)) != NULL)
 382         {
 383
 384 #if NBPFILTER > 0 || NBPF > 0
 385 #ifdef __FreeBSD__
 386                 if (ifp->if_bpf)
 387                         bpf_mtap(ifp, m);
 388 #endif /* __FreeBSD__ */
 389
 390 #ifdef __NetBSD__
 391                 if (ifp->if_bpf)
 392                         bpf_mtap(ifp->if_bpf, m);
 393 #endif
 394 #endif /* NBPFILTER > 0 || NBPF > 0 */
 395
 396                 microtime(&ifp->if_lastchange);
 397
 398                 IF_LOCK(isdn_linktab[unit]->tx_queue);
 399                 if(_IF_QFULL(isdn_linktab[unit]->tx_queue))
 400                 {
 401                         NDBGL4(L4_ISPDBG, "isp%d, tx queue full!", unit);
 402                         m_freem(m);
 403                 }
 404                 else
 405                 {
 406 #if 0
 407                         sc->sc_if.if_obytes += m->m_pkthdr.len;
 408 #endif
 409                         sc->sc_outb += m->m_pkthdr.len;
 410                         sc->sc_if.if_opackets++;
 411
 412                         _IF_ENQUEUE(isdn_linktab[unit]->tx_queue, m);
 413                 }
 414                 IF_UNLOCK(isdn_linktab[unit]->tx_queue);
 415         }
 416         isdn_linktab[unit]->bch_tx_start(isdn_linktab[unit]->unit,
 417                                          isdn_linktab[unit]->channel);
 418 }
 419
 420 #ifdef I4BISPPPACCT
 421 /*---------------------------------------------------------------------------*
 422  *      watchdog routine
 423  *---------------------------------------------------------------------------*/
 424 static void
 425 i4bisppp_watchdog(struct ifnet *ifp)
 426 {
 427         struct i4bisppp_softc *sc = ifp->if_softc;
 428         int unit = IFP2UNIT(ifp);
 429         bchan_statistics_t bs;
 430
 431         (*isdn_linktab[unit]->bch_stat)
 432                 (isdn_linktab[unit]->unit, isdn_linktab[unit]->channel, &bs);
 433
 434         sc->sc_ioutb += bs.outbytes;
 435         sc->sc_iinb += bs.inbytes;
 436
 437         if((sc->sc_iinb != sc->sc_linb) || (sc->sc_ioutb != sc->sc_loutb) || sc->sc_fn)
 438         {
 439                 int ri = (sc->sc_iinb - sc->sc_linb)/I4BISPPPACCTINTVL;
 440                 int ro = (sc->sc_ioutb - sc->sc_loutb)/I4BISPPPACCTINTVL;
 441
 442                 if((sc->sc_iinb == sc->sc_linb) && (sc->sc_ioutb == sc->sc_loutb))
 443                         sc->sc_fn = 0;
 444                 else
 445                         sc->sc_fn = 1;
 446
 447                 sc->sc_linb = sc->sc_iinb;
 448                 sc->sc_loutb = sc->sc_ioutb;
 449
 450                 i4b_l4_accounting(BDRV_ISPPP, unit, ACCT_DURING,
 451                          sc->sc_ioutb, sc->sc_iinb, ro, ri, sc->sc_outb, sc->sc_inb);
 452         }
 453         sc->sc_if.if_timer = I4BISPPPACCTINTVL;
 454
 455 #if 0 /* old stuff, keep it around */
 456         printf(ISPPP_FMT "transmit timeout\n", ISPPP_ARG(sc));
 457         i4bisppp_start(ifp);
 458 #endif
 459 }
 460 #endif /* I4BISPPPACCT */
 461
 462 /*
 463  *===========================================================================*
 464  *                      SyncPPP layer interface routines
 465  *===========================================================================*
 466  */
 467
 468 #if 0 /* never used ??? */
 469 /*---------------------------------------------------------------------------*
 470  *      just an alias for i4bisppp_tls, but of type timeout_t
 471  *---------------------------------------------------------------------------*/
 472 static void
 473 i4bisppp_timeout(void *cookie)
 474 {
 475         i4bisppp_tls((struct sppp *)cookie);
 476 }
 477 #endif
 478
 479 /*---------------------------------------------------------------------------*
 480  *      PPP this-layer-started action
 481  *---------------------------------------------------------------------------*
 482  */
 483 static void
 484 i4bisppp_tls(struct sppp *sp)
 485 {
 486         struct i4bisppp_softc *sc = (struct i4bisppp_softc *)sp;
 487         struct ifnet *ifp = (struct ifnet *)sp;
 488
 489         if(sc->sc_state == ST_CONNECTED)
 490                 return;
 491
 492         i4b_l4_dialout(BDRV_ISPPP, IFP2UNIT(ifp));
 493 }
 494
 495 /*---------------------------------------------------------------------------*
 496  *      PPP this-layer-finished action
 497  *---------------------------------------------------------------------------*
 498  */
 499 static void
 500 i4bisppp_tlf(struct sppp *sp)
 501 {
 502         struct i4bisppp_softc *sc = (struct i4bisppp_softc *)sp;
 503 /*      call_desc_t *cd = sc->sc_cdp;   */
 504         struct ifnet *ifp = (struct ifnet *)sp;
 505
 506         if(sc->sc_state != ST_CONNECTED)
 507                 return;
 508
 509 #if 0 /* never used ??? */
 510         UNTIMEOUT(i4bisppp_timeout, (void *)sp, sc->sc_ch);
 511 #endif
 512
 513         i4b_l4_drvrdisc(BDRV_ISPPP, IFP2UNIT(ifp));
 514 }
 515 /*---------------------------------------------------------------------------*
 516  *      PPP interface phase change
 517  *---------------------------------------------------------------------------*
 518  */
 519 static void
 520 i4bisppp_state_changed(struct sppp *sp, int new_state)
 521 {
 522         struct i4bisppp_softc *sc = (struct i4bisppp_softc *)sp;
 523
 524         i4b_l4_ifstate_changed(sc->sc_cdp, new_state);
 525 }
 526
 527 /*---------------------------------------------------------------------------*
 528  *      PPP control protocol negotiation complete (run ip-up script now)
 529  *---------------------------------------------------------------------------*
 530  */
 531 static void
 532 i4bisppp_negotiation_complete(struct sppp *sp)
 533 {
 534         struct i4bisppp_softc *sc = (struct i4bisppp_softc *)sp;
 535
 536         i4b_l4_negcomplete(sc->sc_cdp);
 537 }
 538
 539 /*===========================================================================*
 540  *                      ISDN INTERFACE ROUTINES
 541  *===========================================================================*/
 542
 543 /*---------------------------------------------------------------------------*
 544  *      this routine is called from L4 handler at connect time
 545  *---------------------------------------------------------------------------*/
 546 static void
 547 i4bisppp_connect(int unit, void *cdp)
 548 {
 549         struct i4bisppp_softc *sc = &i4bisppp_softc[unit];
 550         struct sppp *sp = &sc->sc_if_un.scu_sp;
 551         int s = splimp();
 552
 553         sc->sc_cdp = (call_desc_t *)cdp;
 554         sc->sc_state = ST_CONNECTED;
 555
 556 #if I4BISPPPACCT
 557         sc->sc_iinb = 0;
 558         sc->sc_ioutb = 0;
 559         sc->sc_inb = 0;
 560         sc->sc_outb = 0;
 561         sc->sc_linb = 0;
 562         sc->sc_loutb = 0;
 563         sc->sc_if.if_timer = I4BISPPPACCTINTVL;
 564 #endif
 565
 566 #if 0 /* never used ??? */
 567         UNTIMEOUT(i4bisppp_timeout, (void *)sp, sc->sc_ch);
 568 #endif
 569
 570         sp->pp_up(sp);          /* tell PPP we are ready */
 571 #ifndef __NetBSD__
 572         sp->pp_last_sent = sp->pp_last_recv = SECOND;
 573 #endif
 574         splx(s);
 575 }
 576
 577 /*---------------------------------------------------------------------------*
 578  *      this routine is called from L4 handler at disconnect time
 579  *---------------------------------------------------------------------------*/
 580 static void
 581 i4bisppp_disconnect(int unit, void *cdp)
 582 {
 583         call_desc_t *cd = (call_desc_t *)cdp;
 584         struct i4bisppp_softc *sc = &i4bisppp_softc[unit];
 585         struct sppp *sp = &sc->sc_if_un.scu_sp;
 586
 587         int s = splimp();
 588
 589         /* new stuff to check that the active channel is being closed */
 590         if (cd != sc->sc_cdp)
 591         {
 592                 NDBGL4(L4_ISPDBG, "isp%d, channel%d not active!", unit, cd->channelid);
 593                 splx(s);
 594                 return;
 595         }
 596
 597 #if I4BISPPPACCT
 598         sc->sc_if.if_timer = 0;
 599 #endif
 600
 601         i4b_l4_accounting(BDRV_ISPPP, unit, ACCT_FINAL,
 602                  sc->sc_ioutb, sc->sc_iinb, 0, 0, sc->sc_outb, sc->sc_inb);
 603
 604         if (sc->sc_state == ST_CONNECTED)
 605         {
 606 #if 0 /* never used ??? */
 607                 UNTIMEOUT(i4bisppp_timeout, (void *)sp, sc->sc_ch);
 608 #endif
 609                 sc->sc_cdp = (call_desc_t *)0;
 610                 /* do this here because pp_down calls i4bisppp_tlf */
 611                 sc->sc_state = ST_IDLE;
 612                 sp->pp_down(sp);        /* tell PPP we have hung up */
 613         }
 614
 615         splx(s);
 616 }
 617
 618 /*---------------------------------------------------------------------------*
 619  *      this routine is used to give a feedback from userland demon
 620  *      in case of dial problems
 621  *---------------------------------------------------------------------------*/
 622 static void
 623 i4bisppp_dialresponse(int unit, int status, cause_t cause)
 624 {
 625         struct i4bisppp_softc *sc = &i4bisppp_softc[unit];
 626         struct sppp *sp = &sc->sc_if_un.scu_sp;
 627
 628         NDBGL4(L4_ISPDBG, "isp%d: status=%d, cause=%d", unit, status, cause);
 629
 630         if(status != DSTAT_NONE)
 631         {
 632                 struct mbuf *m;
 633
 634                 NDBGL4(L4_ISPDBG, "isp%d: clearing queues", unit);
 635
 636                 if(!(sppp_isempty(&sc->sc_if)))
 637                 {
 638                         while((m = sppp_dequeue(&sc->sc_if)) != NULL)
 639                                 m_freem(m);
 640                 }
 641
 642                 sc->sc_cdp = (call_desc_t *)0;
 643                 /* do this here because pp_down calls i4bisppp_tlf */
 644                 sc->sc_state = ST_IDLE;
 645                 /*
 646                  * Ahh, sppp doesn't like to get a down event when
 647                  * dialing fails. So first tell it that we are up
 648                  * (doesn't hurt us since sc_state != ST_CONNECTED)
 649                  * and then go down.
 650                  */
 651                 sp->pp_up(sp);
 652                 sp->pp_down(sp);
 653         }
 654 }
 655
 656 /*---------------------------------------------------------------------------*
 657  *      interface up/down
 658  *---------------------------------------------------------------------------*/
 659 static void
 660 i4bisppp_updown(int unit, int updown)
 661 {
 662         /* could probably do something useful here */
 663 }
 664
 665 /*---------------------------------------------------------------------------*
 666  *      this routine is called from the HSCX interrupt handler
 667  *      when a new frame (mbuf) has been received and was put on
 668  *      the rx queue.
 669  *---------------------------------------------------------------------------*/
 670 static void
 671 i4bisppp_rx_data_rdy(int unit)
 672 {
 673         struct i4bisppp_softc *sc = &i4bisppp_softc[unit];
 674         struct mbuf *m;
 675         int s;
 676
 677         if((m = *isdn_linktab[unit]->rx_mbuf) == NULL)
 678                 return;
 679
 680         m->m_pkthdr.rcvif = &sc->sc_if;
 681         m->m_pkthdr.len = m->m_len;
 682
 683         microtime(&sc->sc_if.if_lastchange);
 684
 685         sc->sc_if.if_ipackets++;
 686 #if 0
 687         sc->sc_if.if_ibytes += m->m_pkthdr.len;
 688 #endif
 689
 690 #if I4BISPPPACCT
 691         sc->sc_inb += m->m_pkthdr.len;
 692 #endif
 693
 694 #ifdef I4BISPPPDEBUG
 695         printf("i4bisppp_rx_data_ready: received packet!\n");
 696 #endif
 697
 698 #if NBPFILTER > 0 || NBPF > 0
 699
 700 #ifdef __FreeBSD__
 701         if(sc->sc_if.if_bpf)
 702                 bpf_mtap(&sc->sc_if, m);
 703 #endif /* __FreeBSD__ */
 704
 705 #ifdef __NetBSD__
 706         if(sc->sc_if.if_bpf)
 707                 bpf_mtap(sc->sc_if.if_bpf, m);
 708 #endif
 709
 710 #endif /* NBPFILTER > 0  || NBPF > 0 */
 711
 712         s = splimp();
 713
 714         sppp_input(&sc->sc_if, m);
 715
 716         splx(s);
 717 }
 718
 719 /*---------------------------------------------------------------------------*
 720  *      this routine is called from the HSCX interrupt handler
 721  *      when the last frame has been sent out and there is no
 722  *      further frame (mbuf) in the tx queue.
 723  *---------------------------------------------------------------------------*/
 724 static void
 725 i4bisppp_tx_queue_empty(int unit)
 726 {
 727         i4bisppp_start(&i4bisppp_softc[unit].sc_if);
 728 }
 729
 730 /*---------------------------------------------------------------------------*
 731  *      THIS should be used instead of last_active_time to implement
 732  *      an activity timeout mechanism.
 733  *
 734  *      Sending back the time difference unneccessarily complicates the
 735  *      idletime checks in i4b_l4.c. Return the largest time instead.
 736  *      That way the code in i4b_l4.c needs only minimal changes.
 737  *---------------------------------------------------------------------------*/
 738 time_t
 739 i4bisppp_idletime(int unit)
 740 {
 741 #ifdef __NetBSD__
 742        return(i4bisppp_softc[unit].sc_cdp->last_active_time);
 743 #else
 744         struct sppp *sp;
 745         sp = (struct sppp *) &i4bisppp_softc[unit];
 746
 747         return((sp->pp_last_recv < sp->pp_last_sent) ?
 748                         sp->pp_last_sent : sp->pp_last_recv);
 749 #endif
 750 }
 751
 752 /*---------------------------------------------------------------------------*
 753  *      this routine is called from the HSCX interrupt handler
 754  *      each time a packet is received or transmitted. It should
 755  *      be used to implement an activity timeout mechanism.
 756  *---------------------------------------------------------------------------*/
 757 static void
 758 i4bisppp_activity(int unit, int rxtx)
 759 {
 760         i4bisppp_softc[unit].sc_cdp->last_active_time = SECOND;
 761 }
 762
 763 /*---------------------------------------------------------------------------*
 764  *      return this drivers linktab address
 765  *---------------------------------------------------------------------------*/
 766 drvr_link_t *
 767 i4bisppp_ret_linktab(int unit)
 768 {
 769         return(&i4bisppp_drvr_linktab[unit]);
 770 }
 771
 772 /*---------------------------------------------------------------------------*
 773  *      setup the isdn_linktab for this driver
 774  *---------------------------------------------------------------------------*/
 775 void
 776 i4bisppp_set_linktab(int unit, isdn_link_t *ilt)
 777 {
 778         isdn_linktab[unit] = ilt;
 779 }
 780
 781 /*---------------------------------------------------------------------------*
 782  *      initialize this drivers linktab
 783  *---------------------------------------------------------------------------*/
 784 static void
 785 i4bisppp_init_linktab(int unit)
 786 {
 787         i4bisppp_drvr_linktab[unit].unit = unit;
 788         i4bisppp_drvr_linktab[unit].bch_rx_data_ready = i4bisppp_rx_data_rdy;
 789         i4bisppp_drvr_linktab[unit].bch_tx_queue_empty = i4bisppp_tx_queue_empty;
 790         i4bisppp_drvr_linktab[unit].bch_activity = i4bisppp_activity;
 791         i4bisppp_drvr_linktab[unit].line_connected = i4bisppp_connect;
 792         i4bisppp_drvr_linktab[unit].line_disconnected = i4bisppp_disconnect;
 793         i4bisppp_drvr_linktab[unit].dial_response = i4bisppp_dialresponse;
 794         i4bisppp_drvr_linktab[unit].updown_ind = i4bisppp_updown;
 795 }
 796
 797 /*===========================================================================*/