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.12 2005/01/23 20:23:22 joerg 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_arp.h>
  68 #include <net/if_types.h>
  69 #include <net/sppp/if_sppp.h>
  70
  71
  72 #if defined(__DragonFly__) || (defined(__FreeBSD_version) &&  __FreeBSD_version >= 400008)
  73 #include "use_bpf.h"
  74 #else
  75 #include "bpfilter.h"
  76 #endif
  77 #if NBPFILTER > 0 || NBPF > 0
  78 #include <sys/time.h>
  79 #include <net/bpf.h>
  80 #endif
  81
  82 #if defined(__DragonFly__) || defined(__FreeBSD__)
  83 #include <net/i4b/include/machine/i4b_debug.h>
  84 #include <net/i4b/include/machine/i4b_ioctl.h>
  85 #else
  86 #include <i4b/i4b_ioctl.h>
  87 #include <i4b/i4b_cause.h>
  88 #include <i4b/i4b_debug.h>
  89 #endif
  90
  91 #include "../include/i4b_global.h"
  92 #include "../include/i4b_l3l4.h"
  93 #include "../layer4/i4b_l4.h"
  94
  95 #if defined(__DragonFly__) || defined(__FreeBSD__)
  96 #define PDEVSTATIC      static
  97
  98 #ifdef __DragonFly__
  99 #define ISPPP_FMT       "%s: "
 100 #define ISPPP_ARG(sc)   ((sc)->sc_if.if_xname)
 101 #define IFP2UNIT(ifp)   ((struct i4bisppp_softc *)ifp->if_softc)->sc_unit
 102 #else
 103 #define ISPPP_FMT       "isp%d: "
 104 #define ISPPP_ARG(sc)   ((sc)->sc_if.if_unit)
 105 #define IFP2UNIT(ifp)   (ifp)->if_unit
 106 #endif
 107
 108 # if defined(__DragonFly__) || __FreeBSD_version >= 300001
 109 #  define IOCTL_CMD_T u_long
 110 # else
 111 #  define IOCTL_CMD_T int
 112 # endif
 113
 114 #elif defined __NetBSD__ || defined __OpenBSD__
 115 #define ISPPP_FMT       "%s: "
 116 #define ISPPP_ARG(sc)   ((sc)->sc_if.if_xname)
 117 #define PDEVSTATIC      /* not static */
 118 #define IOCTL_CMD_T     u_long
 119 #define IFP2UNIT(ifp)   ((struct i4bisppp_softc *)ifp->if_softc)->sc_unit
 120 #else
 121 # error "What system are you using?"
 122 #endif
 123
 124 #if defined(__DragonFly__) || defined(__FreeBSD__)
 125 PDEVSTATIC void i4bispppattach(void *);
 126 PSEUDO_SET(i4bispppattach, i4b_isppp);
 127 #else
 128 PDEVSTATIC void i4bispppattach(void);
 129 #endif
 130
 131 #define I4BISPPPACCT            1       /* enable accounting messages */
 132 #define I4BISPPPACCTINTVL       2       /* accounting msg interval in secs */
 133 #define I4BISPPPDISCDEBUG       1
 134
 135 #define PPP_HDRLEN              4       /* 4 octetts PPP header length  */
 136
 137 struct i4bisppp_softc {
 138         /*
 139          * struct sppp starts with a struct ifnet, but we gotta allocate
 140          * more space for it.  NB: do not relocate this union, it must
 141          * be first in isppp_softc.  The tls and tlf hooks below want to
 142          * convert a ``struct sppp *'' into a ``struct isppp_softc *''.
 143          */
 144         union {
 145                 struct ifnet scu_if;
 146                 struct sppp scu_sp;
 147         } sc_if_un;
 148 #define sc_if sc_if_un.scu_if
 149
 150         int     sc_state;       /* state of the interface       */
 151
 152 #if !defined(__FreeBSD__) || defined(__DragonFly__)
 153         int     sc_unit;        /* unit number for Net/OpenBSD  */
 154 #endif
 155
 156         call_desc_t *sc_cdp;    /* ptr to call descriptor       */
 157
 158 #ifdef I4BISPPPACCT
 159         int sc_iinb;            /* isdn driver # of inbytes     */
 160         int sc_ioutb;           /* isdn driver # of outbytes    */
 161         int sc_inb;             /* # of bytes rx'd              */
 162         int sc_outb;            /* # of bytes tx'd              */
 163         int sc_linb;            /* last # of bytes rx'd         */
 164         int sc_loutb;           /* last # of bytes tx'd         */
 165         int sc_fn;              /* flag, first null acct        */
 166 #endif
 167
 168 #if defined(__DragonFly__) || (defined(__FreeBSD_version) && __FreeBSD_version >= 300001)
 169         struct callout  sc_timeout;
 170 #endif
 171
 172 } i4bisppp_softc[NI4BISPPP];
 173
 174 static void     i4bisppp_init_linktab(int unit);
 175 static int      i4bisppp_ioctl(struct ifnet *ifp, IOCTL_CMD_T cmd, caddr_t data,
 176                                struct ucred *cr);
 177
 178 #if 0
 179 static void     i4bisppp_send(struct ifnet *ifp);
 180 #endif
 181
 182 static void     i4bisppp_start(struct ifnet *ifp);
 183
 184 #if 0 /* never used ??? */
 185 static void     i4bisppp_timeout(void *cookie);
 186 #endif
 187
 188 static void     i4bisppp_tls(struct sppp *sp);
 189 static void     i4bisppp_tlf(struct sppp *sp);
 190 static void     i4bisppp_state_changed(struct sppp *sp, int new_state);
 191 static void     i4bisppp_negotiation_complete(struct sppp *sp);
 192 static void     i4bisppp_watchdog(struct ifnet *ifp);
 193 time_t          i4bisppp_idletime(int unit);
 194
 195 /* initialized by L4 */
 196
 197 static drvr_link_t i4bisppp_drvr_linktab[NI4BISPPP];
 198 static isdn_link_t *isdn_linktab[NI4BISPPP];
 199
 200 enum i4bisppp_states {
 201         ST_IDLE,                        /* initialized, ready, idle     */
 202         ST_DIALING,                     /* dialling out to remote       */
 203         ST_CONNECTED,                   /* connected to remote          */
 204 };
 205
 206 /*===========================================================================*
 207  *                      DEVICE DRIVER ROUTINES
 208  *===========================================================================*/
 209
 210 /*---------------------------------------------------------------------------*
 211  *      interface attach routine at kernel boot time
 212  *---------------------------------------------------------------------------*/
 213 PDEVSTATIC void
 214 #if defined(__DragonFly__) || defined(__FreeBSD__)
 215 i4bispppattach(void *dummy)
 216 #else
 217 i4bispppattach()
 218 #endif
 219 {
 220         struct i4bisppp_softc *sc = i4bisppp_softc;
 221         int i;
 222
 223 #ifndef HACK_NO_PSEUDO_ATTACH_MSG
 224 #ifdef SPPP_VJ
 225         printf("i4bisppp: %d ISDN SyncPPP device(s) attached (VJ header compression)\n", NI4BISPPP);
 226 #else
 227         printf("i4bisppp: %d ISDN SyncPPP device(s) attached\n", NI4BISPPP);
 228 #endif
 229 #endif
 230
 231         for(i = 0; i < NI4BISPPP; sc++, i++) {
 232                 i4bisppp_init_linktab(i);
 233
 234                 sc->sc_if.if_softc = sc;
 235
 236 #ifdef __DragonFly__
 237                 if_initname(&(sc->sc_if), "isp", i);
 238 #elif defined(__FreeBSD__)
 239                 sc->sc_if.if_name = "isp";
 240 #if defined(__FreeBSD_version) && __FreeBSD_version < 300001
 241                 sc->sc_if.if_next = NULL;
 242 #endif
 243                 sc->sc_if.if_unit = i;
 244 #else
 245                 sprintf(sc->sc_if.if_xname, "isp%d", i);
 246                 sc->sc_unit = i;
 247 #endif
 248
 249                 sc->sc_if.if_mtu = PP_MTU;
 250
 251 #ifdef __NetBSD__
 252                 sc->sc_if.if_flags = IFF_SIMPLEX | IFF_POINTOPOINT |
 253                                         IFF_MULTICAST;
 254 #else
 255                 sc->sc_if.if_flags = IFF_SIMPLEX | IFF_POINTOPOINT;
 256 #endif
 257
 258                 sc->sc_if.if_type = IFT_ISDNBASIC;
 259                 sc->sc_state = ST_IDLE;
 260
 261                 sc->sc_if.if_ioctl = i4bisppp_ioctl;
 262
 263                 /* actually initialized by sppp_attach() */
 264                 /* sc->sc_if.if_output = sppp_output; */
 265
 266                 sc->sc_if.if_start = i4bisppp_start;
 267
 268                 sc->sc_if.if_hdrlen = 0;
 269                 sc->sc_if.if_addrlen = 0;
 270                 sc->sc_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
 271
 272                 sc->sc_if.if_ipackets = 0;
 273                 sc->sc_if.if_ierrors = 0;
 274                 sc->sc_if.if_opackets = 0;
 275                 sc->sc_if.if_oerrors = 0;
 276                 sc->sc_if.if_collisions = 0;
 277                 sc->sc_if.if_ibytes = 0;
 278                 sc->sc_if.if_obytes = 0;
 279                 sc->sc_if.if_imcasts = 0;
 280                 sc->sc_if.if_omcasts = 0;
 281                 sc->sc_if.if_iqdrops = 0;
 282                 sc->sc_if.if_noproto = 0;
 283
 284 #if I4BISPPPACCT
 285                 sc->sc_if.if_timer = 0;
 286                 sc->sc_if.if_watchdog = i4bisppp_watchdog;
 287                 sc->sc_iinb = 0;
 288                 sc->sc_ioutb = 0;
 289                 sc->sc_inb = 0;
 290                 sc->sc_outb = 0;
 291                 sc->sc_linb = 0;
 292                 sc->sc_loutb = 0;
 293                 sc->sc_fn = 1;
 294 #endif
 295
 296                 sc->sc_if_un.scu_sp.pp_tls = i4bisppp_tls;
 297                 sc->sc_if_un.scu_sp.pp_tlf = i4bisppp_tlf;
 298                 sc->sc_if_un.scu_sp.pp_con = i4bisppp_negotiation_complete;
 299                 sc->sc_if_un.scu_sp.pp_chg = i4bisppp_state_changed;
 300
 301                 sppp_attach(&sc->sc_if);
 302 /* XXX: validate / add proper code */
 303                 ether_ifattach_bpf(&sc->sc_if, ((struct arpcom*)sc)->ac_enaddr,
 304                                    DLT_PPP, PPP_HDRLEN);
 305                 callout_init(&sc->sc_timeout);
 306         }
 307 }
 308
 309 /*---------------------------------------------------------------------------*
 310  *      process ioctl
 311  *---------------------------------------------------------------------------*/
 312 static int
 313 i4bisppp_ioctl(struct ifnet *ifp, IOCTL_CMD_T cmd, caddr_t data,
 314                struct ucred *cr)
 315 {
 316         struct i4bisppp_softc *sc = ifp->if_softc;
 317 #if 0
 318         struct sppp *sp = (struct sppp *)sc;
 319         struct ifaddr *ifa = (struct ifaddr *) data;
 320         struct ifreq *ifr = (struct ifreq *) data;
 321 #endif
 322
 323         int error;
 324
 325         error = sppp_ioctl(&sc->sc_if, cmd, data);
 326         if (error)
 327                 return error;
 328
 329         switch(cmd) {
 330         case SIOCSIFFLAGS:
 331 #if 0 /* never used ??? */
 332                 x = splimp();
 333                 if ((ifp->if_flags & IFF_UP) == 0)
 334                         callout_stop(&sc->sc_timeout);
 335                 splx(x);
 336 #endif
 337                 break;
 338         }
 339
 340         return 0;
 341 }
 342
 343 /*---------------------------------------------------------------------------*
 344  *      start output to ISDN B-channel
 345  *---------------------------------------------------------------------------*/
 346 static void
 347 i4bisppp_start(struct ifnet *ifp)
 348 {
 349         struct i4bisppp_softc *sc = ifp->if_softc;
 350         struct mbuf *m;
 351         /* int s; */
 352         int unit = IFP2UNIT(ifp);
 353
 354         if (sppp_isempty(ifp))
 355                 return;
 356
 357         if(sc->sc_state != ST_CONNECTED)
 358                 return;
 359
 360         /*
 361          * s = splimp();
 362          * ifp->if_flags |= IFF_OACTIVE; // - need to clear this somewhere
 363          * splx(s);
 364          */
 365
 366         while ((m = sppp_dequeue(&sc->sc_if)) != NULL)
 367         {
 368                 BPF_MTAP(ifp, m);
 369
 370                 microtime(&ifp->if_lastchange);
 371
 372                 if(IF_QFULL(isdn_linktab[unit]->tx_queue))
 373                 {
 374                         NDBGL4(L4_ISPDBG, "isp%d, tx queue full!", unit);
 375                         m_freem(m);
 376                 }
 377                 else
 378                 {
 379 #if 0
 380                         sc->sc_if.if_obytes += m->m_pkthdr.len;
 381 #endif
 382                         sc->sc_outb += m->m_pkthdr.len;
 383                         sc->sc_if.if_opackets++;
 384
 385                         IF_ENQUEUE(isdn_linktab[unit]->tx_queue, m);
 386                 }
 387         }
 388         isdn_linktab[unit]->bch_tx_start(isdn_linktab[unit]->unit,
 389                                          isdn_linktab[unit]->channel);
 390 }
 391
 392 #ifdef I4BISPPPACCT
 393 /*---------------------------------------------------------------------------*
 394  *      watchdog routine
 395  *---------------------------------------------------------------------------*/
 396 static void
 397 i4bisppp_watchdog(struct ifnet *ifp)
 398 {
 399         struct i4bisppp_softc *sc = ifp->if_softc;
 400         int unit = IFP2UNIT(ifp);
 401         bchan_statistics_t bs;
 402
 403         (*isdn_linktab[unit]->bch_stat)
 404                 (isdn_linktab[unit]->unit, isdn_linktab[unit]->channel, &bs);
 405
 406         sc->sc_ioutb += bs.outbytes;
 407         sc->sc_iinb += bs.inbytes;
 408
 409         if((sc->sc_iinb != sc->sc_linb) || (sc->sc_ioutb != sc->sc_loutb) || sc->sc_fn)
 410         {
 411                 int ri = (sc->sc_iinb - sc->sc_linb)/I4BISPPPACCTINTVL;
 412                 int ro = (sc->sc_ioutb - sc->sc_loutb)/I4BISPPPACCTINTVL;
 413
 414                 if((sc->sc_iinb == sc->sc_linb) && (sc->sc_ioutb == sc->sc_loutb))
 415                         sc->sc_fn = 0;
 416                 else
 417                         sc->sc_fn = 1;
 418
 419                 sc->sc_linb = sc->sc_iinb;
 420                 sc->sc_loutb = sc->sc_ioutb;
 421
 422                 i4b_l4_accounting(BDRV_ISPPP, unit, ACCT_DURING,
 423                          sc->sc_ioutb, sc->sc_iinb, ro, ri, sc->sc_outb, sc->sc_inb);
 424         }
 425         sc->sc_if.if_timer = I4BISPPPACCTINTVL;
 426
 427 #if 0 /* old stuff, keep it around */
 428         printf(ISPPP_FMT "transmit timeout\n", ISPPP_ARG(sc));
 429         i4bisppp_start(ifp);
 430 #endif
 431 }
 432 #endif /* I4BISPPPACCT */
 433
 434 /*
 435  *===========================================================================*
 436  *                      SyncPPP layer interface routines
 437  *===========================================================================*
 438  */
 439
 440 #if 0 /* never used ??? */
 441 /*---------------------------------------------------------------------------*
 442  *      just an alias for i4bisppp_tls, but of type timeout_t
 443  *---------------------------------------------------------------------------*/
 444 static void
 445 i4bisppp_timeout(void *cookie)
 446 {
 447         i4bisppp_tls((struct sppp *)cookie);
 448 }
 449 #endif
 450
 451 /*---------------------------------------------------------------------------*
 452  *      PPP this-layer-started action
 453  *---------------------------------------------------------------------------*
 454  */
 455 static void
 456 i4bisppp_tls(struct sppp *sp)
 457 {
 458         struct i4bisppp_softc *sc = (struct i4bisppp_softc *)sp;
 459         struct ifnet *ifp = (struct ifnet *)sp;
 460
 461         if(sc->sc_state == ST_CONNECTED)
 462                 return;
 463
 464         i4b_l4_dialout(BDRV_ISPPP, IFP2UNIT(ifp));
 465 }
 466
 467 /*---------------------------------------------------------------------------*
 468  *      PPP this-layer-finished action
 469  *---------------------------------------------------------------------------*
 470  */
 471 static void
 472 i4bisppp_tlf(struct sppp *sp)
 473 {
 474         struct i4bisppp_softc *sc = (struct i4bisppp_softc *)sp;
 475 /*      call_desc_t *cd = sc->sc_cdp;   */
 476         struct ifnet *ifp = (struct ifnet *)sp;
 477
 478         if(sc->sc_state != ST_CONNECTED)
 479                 return;
 480
 481 #if 0 /* never used ??? */
 482         callout_stop(&sc->sc_timeout);
 483 #endif
 484
 485         i4b_l4_drvrdisc(BDRV_ISPPP, IFP2UNIT(ifp));
 486 }
 487 /*---------------------------------------------------------------------------*
 488  *      PPP interface phase change
 489  *---------------------------------------------------------------------------*
 490  */
 491 static void
 492 i4bisppp_state_changed(struct sppp *sp, int new_state)
 493 {
 494         struct i4bisppp_softc *sc = (struct i4bisppp_softc *)sp;
 495
 496         i4b_l4_ifstate_changed(sc->sc_cdp, new_state);
 497 }
 498
 499 /*---------------------------------------------------------------------------*
 500  *      PPP control protocol negotiation complete (run ip-up script now)
 501  *---------------------------------------------------------------------------*
 502  */
 503 static void
 504 i4bisppp_negotiation_complete(struct sppp *sp)
 505 {
 506         struct i4bisppp_softc *sc = (struct i4bisppp_softc *)sp;
 507
 508         i4b_l4_negcomplete(sc->sc_cdp);
 509 }
 510
 511 /*===========================================================================*
 512  *                      ISDN INTERFACE ROUTINES
 513  *===========================================================================*/
 514
 515 /*---------------------------------------------------------------------------*
 516  *      this routine is called from L4 handler at connect time
 517  *---------------------------------------------------------------------------*/
 518 static void
 519 i4bisppp_connect(int unit, void *cdp)
 520 {
 521         struct i4bisppp_softc *sc = &i4bisppp_softc[unit];
 522         struct sppp *sp = &sc->sc_if_un.scu_sp;
 523         int s = splimp();
 524
 525         sc->sc_cdp = (call_desc_t *)cdp;
 526         sc->sc_state = ST_CONNECTED;
 527
 528 #if I4BISPPPACCT
 529         sc->sc_iinb = 0;
 530         sc->sc_ioutb = 0;
 531         sc->sc_inb = 0;
 532         sc->sc_outb = 0;
 533         sc->sc_linb = 0;
 534         sc->sc_loutb = 0;
 535         sc->sc_if.if_timer = I4BISPPPACCTINTVL;
 536 #endif
 537
 538 #if 0 /* never used ??? */
 539         callout_stop(&sc->sc_timeout);
 540 #endif
 541
 542         sp->pp_up(sp);          /* tell PPP we are ready */
 543 #ifndef __NetBSD__
 544         sp->pp_last_sent = sp->pp_last_recv = SECOND;
 545 #endif
 546         splx(s);
 547 }
 548
 549 /*---------------------------------------------------------------------------*
 550  *      this routine is called from L4 handler at disconnect time
 551  *---------------------------------------------------------------------------*/
 552 static void
 553 i4bisppp_disconnect(int unit, void *cdp)
 554 {
 555         call_desc_t *cd = (call_desc_t *)cdp;
 556         struct i4bisppp_softc *sc = &i4bisppp_softc[unit];
 557         struct sppp *sp = &sc->sc_if_un.scu_sp;
 558
 559         int s = splimp();
 560
 561         /* new stuff to check that the active channel is being closed */
 562         if (cd != sc->sc_cdp)
 563         {
 564                 NDBGL4(L4_ISPDBG, "isp%d, channel%d not active!", unit, cd->channelid);
 565                 splx(s);
 566                 return;
 567         }
 568
 569 #if I4BISPPPACCT
 570         sc->sc_if.if_timer = 0;
 571 #endif
 572
 573         i4b_l4_accounting(BDRV_ISPPP, unit, ACCT_FINAL,
 574                  sc->sc_ioutb, sc->sc_iinb, 0, 0, sc->sc_outb, sc->sc_inb);
 575
 576         if (sc->sc_state == ST_CONNECTED)
 577         {
 578 #if 0 /* never used ??? */
 579                 callout_stop(&sc->sc_timeout);
 580 #endif
 581                 sc->sc_cdp = (call_desc_t *)0;
 582                 /* do this here because pp_down calls i4bisppp_tlf */
 583                 sc->sc_state = ST_IDLE;
 584                 sp->pp_down(sp);        /* tell PPP we have hung up */
 585         }
 586
 587         splx(s);
 588 }
 589
 590 /*---------------------------------------------------------------------------*
 591  *      this routine is used to give a feedback from userland demon
 592  *      in case of dial problems
 593  *---------------------------------------------------------------------------*/
 594 static void
 595 i4bisppp_dialresponse(int unit, int status, cause_t cause)
 596 {
 597         struct i4bisppp_softc *sc = &i4bisppp_softc[unit];
 598         struct sppp *sp = &sc->sc_if_un.scu_sp;
 599
 600         NDBGL4(L4_ISPDBG, "isp%d: status=%d, cause=%d", unit, status, cause);
 601
 602         if(status != DSTAT_NONE)
 603         {
 604                 struct mbuf *m;
 605
 606                 NDBGL4(L4_ISPDBG, "isp%d: clearing queues", unit);
 607
 608                 if(!(sppp_isempty(&sc->sc_if)))
 609                 {
 610                         while((m = sppp_dequeue(&sc->sc_if)) != NULL)
 611                                 m_freem(m);
 612                 }
 613
 614                 sc->sc_cdp = (call_desc_t *)0;
 615                 /* do this here because pp_down calls i4bisppp_tlf */
 616                 sc->sc_state = ST_IDLE;
 617                 /*
 618                  * Ahh, sppp doesn't like to get a down event when
 619                  * dialing fails. So first tell it that we are up
 620                  * (doesn't hurt us since sc_state != ST_CONNECTED)
 621                  * and then go down.
 622                  */
 623                 sp->pp_up(sp);
 624                 sp->pp_down(sp);
 625         }
 626 }
 627
 628 /*---------------------------------------------------------------------------*
 629  *      interface up/down
 630  *---------------------------------------------------------------------------*/
 631 static void
 632 i4bisppp_updown(int unit, int updown)
 633 {
 634         /* could probably do something useful here */
 635 }
 636
 637 /*---------------------------------------------------------------------------*
 638  *      this routine is called from the HSCX interrupt handler
 639  *      when a new frame (mbuf) has been received and was put on
 640  *      the rx queue.
 641  *---------------------------------------------------------------------------*/
 642 static void
 643 i4bisppp_rx_data_rdy(int unit)
 644 {
 645         struct i4bisppp_softc *sc = &i4bisppp_softc[unit];
 646         struct mbuf *m;
 647         int s;
 648
 649         if((m = *isdn_linktab[unit]->rx_mbuf) == NULL)
 650                 return;
 651
 652         m->m_pkthdr.rcvif = &sc->sc_if;
 653         m->m_pkthdr.len = m->m_len;
 654
 655         microtime(&sc->sc_if.if_lastchange);
 656
 657         sc->sc_if.if_ipackets++;
 658 #if 0
 659         sc->sc_if.if_ibytes += m->m_pkthdr.len;
 660 #endif
 661
 662 #if I4BISPPPACCT
 663         sc->sc_inb += m->m_pkthdr.len;
 664 #endif
 665
 666 #ifdef I4BISPPPDEBUG
 667         printf("i4bisppp_rx_data_ready: received packet!\n");
 668 #endif
 669
 670         BPF_MTAP(&sc->sc_if, m);
 671
 672         s = splimp();
 673
 674         sppp_input(&sc->sc_if, m);
 675
 676         splx(s);
 677 }
 678
 679 /*---------------------------------------------------------------------------*
 680  *      this routine is called from the HSCX interrupt handler
 681  *      when the last frame has been sent out and there is no
 682  *      further frame (mbuf) in the tx queue.
 683  *---------------------------------------------------------------------------*/
 684 static void
 685 i4bisppp_tx_queue_empty(int unit)
 686 {
 687         i4bisppp_start(&i4bisppp_softc[unit].sc_if);
 688 }
 689
 690 /*---------------------------------------------------------------------------*
 691  *      THIS should be used instead of last_active_time to implement
 692  *      an activity timeout mechanism.
 693  *
 694  *      Sending back the time difference unneccessarily complicates the
 695  *      idletime checks in i4b_l4.c. Return the largest time instead.
 696  *      That way the code in i4b_l4.c needs only minimal changes.
 697  *---------------------------------------------------------------------------*/
 698 time_t
 699 i4bisppp_idletime(int unit)
 700 {
 701 #ifdef __NetBSD__
 702        return(i4bisppp_softc[unit].sc_cdp->last_active_time);
 703 #else
 704         struct sppp *sp;
 705         sp = (struct sppp *) &i4bisppp_softc[unit];
 706
 707         return((sp->pp_last_recv < sp->pp_last_sent) ?
 708                         sp->pp_last_sent : sp->pp_last_recv);
 709 #endif
 710 }
 711
 712 /*---------------------------------------------------------------------------*
 713  *      this routine is called from the HSCX interrupt handler
 714  *      each time a packet is received or transmitted. It should
 715  *      be used to implement an activity timeout mechanism.
 716  *---------------------------------------------------------------------------*/
 717 static void
 718 i4bisppp_activity(int unit, int rxtx)
 719 {
 720         i4bisppp_softc[unit].sc_cdp->last_active_time = SECOND;
 721 }
 722
 723 /*---------------------------------------------------------------------------*
 724  *      return this drivers linktab address
 725  *---------------------------------------------------------------------------*/
 726 drvr_link_t *
 727 i4bisppp_ret_linktab(int unit)
 728 {
 729         return(&i4bisppp_drvr_linktab[unit]);
 730 }
 731
 732 /*---------------------------------------------------------------------------*
 733  *      setup the isdn_linktab for this driver
 734  *---------------------------------------------------------------------------*/
 735 void
 736 i4bisppp_set_linktab(int unit, isdn_link_t *ilt)
 737 {
 738         isdn_linktab[unit] = ilt;
 739 }
 740
 741 /*---------------------------------------------------------------------------*
 742  *      initialize this drivers linktab
 743  *---------------------------------------------------------------------------*/
 744 static void
 745 i4bisppp_init_linktab(int unit)
 746 {
 747         i4bisppp_drvr_linktab[unit].unit = unit;
 748         i4bisppp_drvr_linktab[unit].bch_rx_data_ready = i4bisppp_rx_data_rdy;
 749         i4bisppp_drvr_linktab[unit].bch_tx_queue_empty = i4bisppp_tx_queue_empty;
 750         i4bisppp_drvr_linktab[unit].bch_activity = i4bisppp_activity;
 751         i4bisppp_drvr_linktab[unit].line_connected = i4bisppp_connect;
 752         i4bisppp_drvr_linktab[unit].line_disconnected = i4bisppp_disconnect;
 753         i4bisppp_drvr_linktab[unit].dial_response = i4bisppp_dialresponse;
 754         i4bisppp_drvr_linktab[unit].updown_ind = i4bisppp_updown;
 755 }
 756
 757 /*===========================================================================*/