SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/isdn/i4l/isdn_net.c

   1 /* $Id: isdn_net.c,v 1.1.2.2 2004/01/12 22:37:19 keil Exp $
   2  *
   3  * Linux ISDN subsystem, network interfaces and related functions (linklevel).
   4  *
   5  * Copyright 1994-1998  by Fritz Elfert (fritz@isdn4linux.de)
   6  * Copyright 1995,96    by Thinking Objects Software GmbH Wuerzburg
   7  * Copyright 1995,96    by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de)
   8  *
   9  * This software may be used and distributed according to the terms
  10  * of the GNU General Public License, incorporated herein by reference.
  11  *
  12  * Data Over Voice (DOV) support added - Guy Ellis 23-Mar-02
  13  *                                       guy@traverse.com.au
  14  * Outgoing calls - looks for a 'V' in first char of dialed number
  15  * Incoming calls - checks first character of eaz as follows:
  16  *   Numeric - accept DATA only - original functionality
  17  *   'V'     - accept VOICE (DOV) only
  18  *   'B'     - accept BOTH DATA and DOV types
  19  *
  20  * Jan 2001: fix CISCO HDLC      Bjoern A. Zeeb <i4l@zabbadoz.net>
  21  *           for info on the protocol, see
  22  *           http://i4l.zabbadoz.net/i4l/cisco-hdlc.txt
  23  */
  24
  25 #include <linux/isdn.h>
  26 #include <net/arp.h>
  27 #include <net/dst.h>
  28 #include <net/pkt_sched.h>
  29 #include <linux/inetdevice.h>
  30 #include "isdn_common.h"
  31 #include "isdn_net.h"
  32 #ifdef CONFIG_ISDN_PPP
  33 #include "isdn_ppp.h"
  34 #endif
  35 #ifdef CONFIG_ISDN_X25
  36 #include <linux/concap.h>
  37 #include "isdn_concap.h"
  38 #endif
  39
  40
  41 /*
  42  * Outline of new tbusy handling:
  43  *
  44  * Old method, roughly spoken, consisted of setting tbusy when entering
  45  * isdn_net_start_xmit() and at several other locations and clearing
  46  * it from isdn_net_start_xmit() thread when sending was successful.
  47  *
  48  * With 2.3.x multithreaded network core, to prevent problems, tbusy should
  49  * only be set by the isdn_net_start_xmit() thread and only when a tx-busy
  50  * condition is detected. Other threads (in particular isdn_net_stat_callb())
  51  * are only allowed to clear tbusy.
  52  *
  53  * -HE
  54  */
  55
  56 /*
  57  * About SOFTNET:
  58  * Most of the changes were pretty obvious and basically done by HE already.
  59  *
  60  * One problem of the isdn net device code is that is uses struct net_device
  61  * for masters and slaves. However, only master interface are registered to
  62  * the network layer, and therefore, it only makes sense to call netif_*
  63  * functions on them.
  64  *
  65  * --KG
  66  */
  67
  68 /*
  69  * Find out if the netdevice has been ifup-ed yet.
  70  * For slaves, look at the corresponding master.
  71  */
  72 static __inline__ int isdn_net_device_started(isdn_net_dev *n)
  73 {
  74         isdn_net_local *lp = n->local;
  75         struct net_device *dev;
  76
  77         if (lp->master)
  78                 dev = lp->master;
  79         else
  80                 dev = n->dev;
  81         return netif_running(dev);
  82 }
  83
  84 /*
  85  * wake up the network -> net_device queue.
  86  * For slaves, wake the corresponding master interface.
  87  */
  88 static __inline__ void isdn_net_device_wake_queue(isdn_net_local *lp)
  89 {
  90         if (lp->master)
  91                 netif_wake_queue(lp->master);
  92         else
  93                 netif_wake_queue(lp->netdev->dev);
  94 }
  95
  96 /*
  97  * stop the network -> net_device queue.
  98  * For slaves, stop the corresponding master interface.
  99  */
 100 static __inline__ void isdn_net_device_stop_queue(isdn_net_local *lp)
 101 {
 102         if (lp->master)
 103                 netif_stop_queue(lp->master);
 104         else
 105                 netif_stop_queue(lp->netdev->dev);
 106 }
 107
 108 /*
 109  * find out if the net_device which this lp belongs to (lp can be
 110  * master or slave) is busy. It's busy iff all (master and slave)
 111  * queues are busy
 112  */
 113 static __inline__ int isdn_net_device_busy(isdn_net_local *lp)
 114 {
 115         isdn_net_local *nlp;
 116         isdn_net_dev *nd;
 117         unsigned long flags;
 118
 119         if (!isdn_net_lp_busy(lp))
 120                 return 0;
 121
 122         if (lp->master)
 123                 nd = ISDN_MASTER_PRIV(lp)->netdev;
 124         else
 125                 nd = lp->netdev;
 126
 127         spin_lock_irqsave(&nd->queue_lock, flags);
 128         nlp = lp->next;
 129         while (nlp != lp) {
 130                 if (!isdn_net_lp_busy(nlp)) {
 131                         spin_unlock_irqrestore(&nd->queue_lock, flags);
 132                         return 0;
 133                 }
 134                 nlp = nlp->next;
 135         }
 136         spin_unlock_irqrestore(&nd->queue_lock, flags);
 137         return 1;
 138 }
 139
 140 static __inline__ void isdn_net_inc_frame_cnt(isdn_net_local *lp)
 141 {
 142         atomic_inc(&lp->frame_cnt);
 143         if (isdn_net_device_busy(lp))
 144                 isdn_net_device_stop_queue(lp);
 145 }
 146
 147 static __inline__ void isdn_net_dec_frame_cnt(isdn_net_local *lp)
 148 {
 149         atomic_dec(&lp->frame_cnt);
 150
 151         if (!(isdn_net_device_busy(lp))) {
 152                 if (!skb_queue_empty(&lp->super_tx_queue)) {
 153                         schedule_work(&lp->tqueue);
 154                 } else {
 155                         isdn_net_device_wake_queue(lp);
 156                 }
 157        }
 158 }
 159
 160 static __inline__ void isdn_net_zero_frame_cnt(isdn_net_local *lp)
 161 {
 162         atomic_set(&lp->frame_cnt, 0);
 163 }
 164
 165 /* For 2.2.x we leave the transmitter busy timeout at 2 secs, just
 166  * to be safe.
 167  * For 2.3.x we push it up to 20 secs, because call establishment
 168  * (in particular callback) may take such a long time, and we
 169  * don't want confusing messages in the log. However, there is a slight
 170  * possibility that this large timeout will break other things like MPPP,
 171  * which might rely on the tx timeout. If so, we'll find out this way...
 172  */
 173
 174 #define ISDN_NET_TX_TIMEOUT (20*HZ)
 175
 176 /* Prototypes */
 177
 178 static int isdn_net_force_dial_lp(isdn_net_local *);
 179 static netdev_tx_t isdn_net_start_xmit(struct sk_buff *,
 180                                              struct net_device *);
 181
 182 static void isdn_net_ciscohdlck_connected(isdn_net_local *lp);
 183 static void isdn_net_ciscohdlck_disconnected(isdn_net_local *lp);
 184
 185 char *isdn_net_revision = "$Revision: 1.1.2.2 $";
 186
 187  /*
 188   * Code for raw-networking over ISDN
 189   */
 190
 191 static void
 192 isdn_net_unreachable(struct net_device *dev, struct sk_buff *skb, char *reason)
 193 {
 194         if(skb) {
 195
 196                 u_short proto = ntohs(skb->protocol);
 197
 198                 printk(KERN_DEBUG "isdn_net: %s: %s, signalling dst_link_failure %s\n",
 199                        dev->name,
 200                        (reason != NULL) ? reason : "unknown",
 201                        (proto != ETH_P_IP) ? "Protocol != ETH_P_IP" : "");
 202
 203                 dst_link_failure(skb);
 204         }
 205         else {  /* dial not triggered by rawIP packet */
 206                 printk(KERN_DEBUG "isdn_net: %s: %s\n",
 207                            dev->name,
 208                            (reason != NULL) ? reason : "reason unknown");
 209         }
 210 }
 211
 212 static void
 213 isdn_net_reset(struct net_device *dev)
 214 {
 215 #ifdef CONFIG_ISDN_X25
 216         struct concap_device_ops * dops =
 217                 ((isdn_net_local *) netdev_priv(dev))->dops;
 218         struct concap_proto * cprot =
 219                 ((isdn_net_local *) netdev_priv(dev))->netdev->cprot;
 220 #endif
 221 #ifdef CONFIG_ISDN_X25
 222         if( cprot && cprot -> pops && dops )
 223                 cprot -> pops -> restart ( cprot, dev, dops );
 224 #endif
 225 }
 226
 227 /* Open/initialize the board. */
 228 static int
 229 isdn_net_open(struct net_device *dev)
 230 {
 231         int i;
 232         struct net_device *p;
 233         struct in_device *in_dev;
 234
 235         /* moved here from isdn_net_reset, because only the master has an
 236            interface associated which is supposed to be started. BTW:
 237            we need to call netif_start_queue, not netif_wake_queue here */
 238         netif_start_queue(dev);
 239
 240         isdn_net_reset(dev);
 241         /* Fill in the MAC-level header (not needed, but for compatibility... */
 242         for (i = 0; i < ETH_ALEN - sizeof(u32); i++)
 243                 dev->dev_addr[i] = 0xfc;
 244         if ((in_dev = dev->ip_ptr) != NULL) {
 245                 /*
 246                  *      Any address will do - we take the first
 247                  */
 248                 struct in_ifaddr *ifa = in_dev->ifa_list;
 249                 if (ifa != NULL)
 250                         memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
 251         }
 252
 253         /* If this interface has slaves, start them also */
 254         p = MASTER_TO_SLAVE(dev);
 255         if (p) {
 256                 while (p) {
 257                         isdn_net_reset(p);
 258                         p = MASTER_TO_SLAVE(p);
 259                 }
 260         }
 261         isdn_lock_drivers();
 262         return 0;
 263 }
 264
 265 /*
 266  * Assign an ISDN-channel to a net-interface
 267  */
 268 static void
 269 isdn_net_bind_channel(isdn_net_local * lp, int idx)
 270 {
 271         lp->flags |= ISDN_NET_CONNECTED;
 272         lp->isdn_device = dev->drvmap[idx];
 273         lp->isdn_channel = dev->chanmap[idx];
 274         dev->rx_netdev[idx] = lp->netdev;
 275         dev->st_netdev[idx] = lp->netdev;
 276 }
 277
 278 /*
 279  * unbind a net-interface (resets interface after an error)
 280  */
 281 static void
 282 isdn_net_unbind_channel(isdn_net_local * lp)
 283 {
 284         skb_queue_purge(&lp->super_tx_queue);
 285
 286         if (!lp->master) {      /* reset only master device */
 287                 /* Moral equivalent of dev_purge_queues():
 288                    BEWARE! This chunk of code cannot be called from hardware
 289                    interrupt handler. I hope it is true. --ANK
 290                  */
 291                 qdisc_reset_all_tx(lp->netdev->dev);
 292         }
 293         lp->dialstate = 0;
 294         dev->rx_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
 295         dev->st_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
 296         if (lp->isdn_device != -1 && lp->isdn_channel != -1)
 297                 isdn_free_channel(lp->isdn_device, lp->isdn_channel,
 298                                   ISDN_USAGE_NET);
 299         lp->flags &= ~ISDN_NET_CONNECTED;
 300         lp->isdn_device = -1;
 301         lp->isdn_channel = -1;
 302 }
 303
 304 /*
 305  * Perform auto-hangup and cps-calculation for net-interfaces.
 306  *
 307  * auto-hangup:
 308  * Increment idle-counter (this counter is reset on any incoming or
 309  * outgoing packet), if counter exceeds configured limit either do a
 310  * hangup immediately or - if configured - wait until just before the next
 311  * charge-info.
 312  *
 313  * cps-calculation (needed for dynamic channel-bundling):
 314  * Since this function is called every second, simply reset the
 315  * byte-counter of the interface after copying it to the cps-variable.
 316  */
 317 static unsigned long last_jiffies = -HZ;
 318
 319 void
 320 isdn_net_autohup(void)
 321 {
 322         isdn_net_dev *p = dev->netdev;
 323         int anymore;
 324
 325         anymore = 0;
 326         while (p) {
 327                 isdn_net_local *l = p->local;
 328                 if (jiffies == last_jiffies)
 329                         l->cps = l->transcount;
 330                 else
 331                         l->cps = (l->transcount * HZ) / (jiffies - last_jiffies);
 332                 l->transcount = 0;
 333                 if (dev->net_verbose > 3)
 334                         printk(KERN_DEBUG "%s: %d bogocps\n", p->dev->name, l->cps);
 335                 if ((l->flags & ISDN_NET_CONNECTED) && (!l->dialstate)) {
 336                         anymore = 1;
 337                         l->huptimer++;
 338                         /*
 339                          * if there is some dialmode where timeout-hangup
 340                          * should _not_ be done, check for that here
 341                          */
 342                         if ((l->onhtime) &&
 343                             (l->huptimer > l->onhtime))
 344                         {
 345                                 if (l->hupflags & ISDN_MANCHARGE &&
 346                                     l->hupflags & ISDN_CHARGEHUP) {
 347                                         while (time_after(jiffies, l->chargetime + l->chargeint))
 348                                                 l->chargetime += l->chargeint;
 349                                         if (time_after(jiffies, l->chargetime + l->chargeint - 2 * HZ))
 350                                                 if (l->outgoing || l->hupflags & ISDN_INHUP)
 351                                                         isdn_net_hangup(p->dev);
 352                                 } else if (l->outgoing) {
 353                                         if (l->hupflags & ISDN_CHARGEHUP) {
 354                                                 if (l->hupflags & ISDN_WAITCHARGE) {
 355                                                         printk(KERN_DEBUG "isdn_net: Hupflags of %s are %X\n",
 356                                                                p->dev->name, l->hupflags);
 357                                                         isdn_net_hangup(p->dev);
 358                                                 } else if (time_after(jiffies, l->chargetime + l->chargeint)) {
 359                                                         printk(KERN_DEBUG
 360                                                                "isdn_net: %s: chtime = %lu, chint = %d\n",
 361                                                                p->dev->name, l->chargetime, l->chargeint);
 362                                                         isdn_net_hangup(p->dev);
 363                                                 }
 364                                         } else
 365                                                 isdn_net_hangup(p->dev);
 366                                 } else if (l->hupflags & ISDN_INHUP)
 367                                         isdn_net_hangup(p->dev);
 368                         }
 369
 370                         if(dev->global_flags & ISDN_GLOBAL_STOPPED || (ISDN_NET_DIALMODE(*l) == ISDN_NET_DM_OFF)) {
 371                                 isdn_net_hangup(p->dev);
 372                                 break;
 373                         }
 374                 }
 375                 p = (isdn_net_dev *) p->next;
 376         }
 377         last_jiffies = jiffies;
 378         isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, anymore);
 379 }
 380
 381 static void isdn_net_lp_disconnected(isdn_net_local *lp)
 382 {
 383         isdn_net_rm_from_bundle(lp);
 384 }
 385
 386 /*
 387  * Handle status-messages from ISDN-interfacecard.
 388  * This function is called from within the main-status-dispatcher
 389  * isdn_status_callback, which itself is called from the low-level driver.
 390  * Return: 1 = Event handled, 0 = not for us or unknown Event.
 391  */
 392 int
 393 isdn_net_stat_callback(int idx, isdn_ctrl *c)
 394 {
 395         isdn_net_dev *p = dev->st_netdev[idx];
 396         int cmd = c->command;
 397
 398         if (p) {
 399                 isdn_net_local *lp = p->local;
 400 #ifdef CONFIG_ISDN_X25
 401                 struct concap_proto *cprot = lp->netdev->cprot;
 402                 struct concap_proto_ops *pops = cprot ? cprot->pops : NULL;
 403 #endif
 404                 switch (cmd) {
 405                         case ISDN_STAT_BSENT:
 406                                 /* A packet has successfully been sent out */
 407                                 if ((lp->flags & ISDN_NET_CONNECTED) &&
 408                                     (!lp->dialstate)) {
 409                                         isdn_net_dec_frame_cnt(lp);
 410                                         lp->stats.tx_packets++;
 411                                         lp->stats.tx_bytes += c->parm.length;
 412                                 }
 413                                 return 1;
 414                         case ISDN_STAT_DCONN:
 415                                 /* D-Channel is up */
 416                                 switch (lp->dialstate) {
 417                                         case 4:
 418                                         case 7:
 419                                         case 8:
 420                                                 lp->dialstate++;
 421                                                 return 1;
 422                                         case 12:
 423                                                 lp->dialstate = 5;
 424                                                 return 1;
 425                                 }
 426                                 break;
 427                         case ISDN_STAT_DHUP:
 428                                 /* Either D-Channel-hangup or error during dialout */
 429 #ifdef CONFIG_ISDN_X25
 430                                 /* If we are not connencted then dialing had
 431                                    failed. If there are generic encap protocol
 432                                    receiver routines signal the closure of
 433                                    the link*/
 434
 435                                 if( !(lp->flags & ISDN_NET_CONNECTED)
 436                                     && pops && pops -> disconn_ind )
 437                                         pops -> disconn_ind(cprot);
 438 #endif /* CONFIG_ISDN_X25 */
 439                                 if ((!lp->dialstate) && (lp->flags & ISDN_NET_CONNECTED)) {
 440                                         if (lp->p_encap == ISDN_NET_ENCAP_CISCOHDLCK)
 441                                                 isdn_net_ciscohdlck_disconnected(lp);
 442 #ifdef CONFIG_ISDN_PPP
 443                                         if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
 444                                                 isdn_ppp_free(lp);
 445 #endif
 446                                         isdn_net_lp_disconnected(lp);
 447                                         isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
 448                                         printk(KERN_INFO "%s: remote hangup\n", p->dev->name);
 449                                         printk(KERN_INFO "%s: Chargesum is %d\n", p->dev->name,
 450                                                lp->charge);
 451                                         isdn_net_unbind_channel(lp);
 452                                         return 1;
 453                                 }
 454                                 break;
 455 #ifdef CONFIG_ISDN_X25
 456                         case ISDN_STAT_BHUP:
 457                                 /* B-Channel-hangup */
 458                                 /* try if there are generic encap protocol
 459                                    receiver routines and signal the closure of
 460                                    the link */
 461                                 if( pops  &&  pops -> disconn_ind ){
 462                                                 pops -> disconn_ind(cprot);
 463                                                 return 1;
 464                                         }
 465                                 break;
 466 #endif /* CONFIG_ISDN_X25 */
 467                         case ISDN_STAT_BCONN:
 468                                 /* B-Channel is up */
 469                                 isdn_net_zero_frame_cnt(lp);
 470                                 switch (lp->dialstate) {
 471                                         case 5:
 472                                         case 6:
 473                                         case 7:
 474                                         case 8:
 475                                         case 9:
 476                                         case 10:
 477                                         case 12:
 478                                                 if (lp->dialstate <= 6) {
 479                                                         dev->usage[idx] |= ISDN_USAGE_OUTGOING;
 480                                                         isdn_info_update();
 481                                                 } else
 482                                                         dev->rx_netdev[idx] = p;
 483                                                 lp->dialstate = 0;
 484                                                 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 1);
 485                                                 if (lp->p_encap == ISDN_NET_ENCAP_CISCOHDLCK)
 486                                                         isdn_net_ciscohdlck_connected(lp);
 487                                                 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP) {
 488                                                         if (lp->master) { /* is lp a slave? */
 489                                                                 isdn_net_dev *nd = ISDN_MASTER_PRIV(lp)->netdev;
 490                                                                 isdn_net_add_to_bundle(nd, lp);
 491                                                         }
 492                                                 }
 493                                                 printk(KERN_INFO "isdn_net: %s connected\n", p->dev->name);
 494                                                 /* If first Chargeinfo comes before B-Channel connect,
 495                                                  * we correct the timestamp here.
 496                                                  */
 497                                                 lp->chargetime = jiffies;
 498
 499                                                 /* reset dial-timeout */
 500                                                 lp->dialstarted = 0;
 501                                                 lp->dialwait_timer = 0;
 502
 503 #ifdef CONFIG_ISDN_PPP
 504                                                 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
 505                                                         isdn_ppp_wakeup_daemon(lp);
 506 #endif
 507 #ifdef CONFIG_ISDN_X25
 508                                                 /* try if there are generic concap receiver routines */
 509                                                 if( pops )
 510                                                         if( pops->connect_ind)
 511                                                                 pops->connect_ind(cprot);
 512 #endif /* CONFIG_ISDN_X25 */
 513                                                 /* ppp needs to do negotiations first */
 514                                                 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
 515                                                         isdn_net_device_wake_queue(lp);
 516                                                 return 1;
 517                                 }
 518                                 break;
 519                         case ISDN_STAT_NODCH:
 520                                 /* No D-Channel avail. */
 521                                 if (lp->dialstate == 4) {
 522                                         lp->dialstate--;
 523                                         return 1;
 524                                 }
 525                                 break;
 526                         case ISDN_STAT_CINF:
 527                                 /* Charge-info from TelCo. Calculate interval between
 528                                  * charge-infos and set timestamp for last info for
 529                                  * usage by isdn_net_autohup()
 530                                  */
 531                                 lp->charge++;
 532                                 if (lp->hupflags & ISDN_HAVECHARGE) {
 533                                         lp->hupflags &= ~ISDN_WAITCHARGE;
 534                                         lp->chargeint = jiffies - lp->chargetime - (2 * HZ);
 535                                 }
 536                                 if (lp->hupflags & ISDN_WAITCHARGE)
 537                                         lp->hupflags |= ISDN_HAVECHARGE;
 538                                 lp->chargetime = jiffies;
 539                                 printk(KERN_DEBUG "isdn_net: Got CINF chargetime of %s now %lu\n",
 540                                        p->dev->name, lp->chargetime);
 541                                 return 1;
 542                 }
 543         }
 544         return 0;
 545 }
 546
 547 /*
 548  * Perform dialout for net-interfaces and timeout-handling for
 549  * D-Channel-up and B-Channel-up Messages.
 550  * This function is initially called from within isdn_net_start_xmit() or
 551  * or isdn_net_find_icall() after initializing the dialstate for an
 552  * interface. If further calls are needed, the function schedules itself
 553  * for a timer-callback via isdn_timer_function().
 554  * The dialstate is also affected by incoming status-messages from
 555  * the ISDN-Channel which are handled in isdn_net_stat_callback() above.
 556  */
 557 void
 558 isdn_net_dial(void)
 559 {
 560         isdn_net_dev *p = dev->netdev;
 561         int anymore = 0;
 562         int i;
 563         isdn_ctrl cmd;
 564         u_char *phone_number;
 565
 566         while (p) {
 567                 isdn_net_local *lp = p->local;
 568
 569 #ifdef ISDN_DEBUG_NET_DIAL
 570                 if (lp->dialstate)
 571                         printk(KERN_DEBUG "%s: dialstate=%d\n", p->dev->name, lp->dialstate);
 572 #endif
 573                 switch (lp->dialstate) {
 574                         case 0:
 575                                 /* Nothing to do for this interface */
 576                                 break;
 577                         case 1:
 578                                 /* Initiate dialout. Set phone-number-pointer to first number
 579                                  * of interface.
 580                                  */
 581                                 lp->dial = lp->phone[1];
 582                                 if (!lp->dial) {
 583                                         printk(KERN_WARNING "%s: phone number deleted?\n",
 584                                                p->dev->name);
 585                                         isdn_net_hangup(p->dev);
 586                                         break;
 587                                 }
 588                                 anymore = 1;
 589
 590                                 if(lp->dialtimeout > 0)
 591                                         if(lp->dialstarted == 0 || time_after(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait)) {
 592                                                 lp->dialstarted = jiffies;
 593                                                 lp->dialwait_timer = 0;
 594                                         }
 595
 596                                 lp->dialstate++;
 597                                 /* Fall through */
 598                         case 2:
 599                                 /* Prepare dialing. Clear EAZ, then set EAZ. */
 600                                 cmd.driver = lp->isdn_device;
 601                                 cmd.arg = lp->isdn_channel;
 602                                 cmd.command = ISDN_CMD_CLREAZ;
 603                                 isdn_command(&cmd);
 604                                 sprintf(cmd.parm.num, "%s", isdn_map_eaz2msn(lp->msn, cmd.driver));
 605                                 cmd.command = ISDN_CMD_SETEAZ;
 606                                 isdn_command(&cmd);
 607                                 lp->dialretry = 0;
 608                                 anymore = 1;
 609                                 lp->dialstate++;
 610                                 /* Fall through */
 611                         case 3:
 612                                 /* Setup interface, dial current phone-number, switch to next number.
 613                                  * If list of phone-numbers is exhausted, increment
 614                                  * retry-counter.
 615                                  */
 616                                 if(dev->global_flags & ISDN_GLOBAL_STOPPED || (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF)) {
 617                                         char *s;
 618                                         if (dev->global_flags & ISDN_GLOBAL_STOPPED)
 619                                                 s = "dial suppressed: isdn system stopped";
 620                                         else
 621                                                 s = "dial suppressed: dialmode `off'";
 622                                         isdn_net_unreachable(p->dev, NULL, s);
 623                                         isdn_net_hangup(p->dev);
 624                                         break;
 625                                 }
 626                                 cmd.driver = lp->isdn_device;
 627                                 cmd.command = ISDN_CMD_SETL2;
 628                                 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8);
 629                                 isdn_command(&cmd);
 630                                 cmd.driver = lp->isdn_device;
 631                                 cmd.command = ISDN_CMD_SETL3;
 632                                 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8);
 633                                 isdn_command(&cmd);
 634                                 cmd.driver = lp->isdn_device;
 635                                 cmd.arg = lp->isdn_channel;
 636                                 if (!lp->dial) {
 637                                         printk(KERN_WARNING "%s: phone number deleted?\n",
 638                                                p->dev->name);
 639                                         isdn_net_hangup(p->dev);
 640                                         break;
 641                                 }
 642                                 if (!strncmp(lp->dial->num, "LEASED", strlen("LEASED"))) {
 643                                         lp->dialstate = 4;
 644                                         printk(KERN_INFO "%s: Open leased line ...\n", p->dev->name);
 645                                 } else {
 646                                         if(lp->dialtimeout > 0)
 647                                                 if (time_after(jiffies, lp->dialstarted + lp->dialtimeout)) {
 648                                                         lp->dialwait_timer = jiffies + lp->dialwait;
 649                                                         lp->dialstarted = 0;
 650                                                         isdn_net_unreachable(p->dev, NULL, "dial: timed out");
 651                                                         isdn_net_hangup(p->dev);
 652                                                         break;
 653                                                 }
 654
 655                                         cmd.driver = lp->isdn_device;
 656                                         cmd.command = ISDN_CMD_DIAL;
 657                                         cmd.parm.setup.si2 = 0;
 658
 659                                         /* check for DOV */
 660                                         phone_number = lp->dial->num;
 661                                         if ((*phone_number == 'v') ||
 662                                             (*phone_number == 'V')) { /* DOV call */
 663                                                 cmd.parm.setup.si1 = 1;
 664                                         } else { /* DATA call */
 665                                                 cmd.parm.setup.si1 = 7;
 666                                         }
 667
 668                                         strcpy(cmd.parm.setup.phone, phone_number);
 669                                         /*
 670                                          * Switch to next number or back to start if at end of list.
 671                                          */
 672                                         if (!(lp->dial = (isdn_net_phone *) lp->dial->next)) {
 673                                                 lp->dial = lp->phone[1];
 674                                                 lp->dialretry++;
 675
 676                                                 if (lp->dialretry > lp->dialmax) {
 677                                                         if (lp->dialtimeout == 0) {
 678                                                                 lp->dialwait_timer = jiffies + lp->dialwait;
 679                                                                 lp->dialstarted = 0;
 680                                                                 isdn_net_unreachable(p->dev, NULL, "dial: tried all numbers dialmax times");
 681                                                         }
 682                                                         isdn_net_hangup(p->dev);
 683                                                         break;
 684                                                 }
 685                                         }
 686                                         sprintf(cmd.parm.setup.eazmsn, "%s",
 687                                                 isdn_map_eaz2msn(lp->msn, cmd.driver));
 688                                         i = isdn_dc2minor(lp->isdn_device, lp->isdn_channel);
 689                                         if (i >= 0) {
 690                                                 strcpy(dev->num[i], cmd.parm.setup.phone);
 691                                                 dev->usage[i] |= ISDN_USAGE_OUTGOING;
 692                                                 isdn_info_update();
 693                                         }
 694                                         printk(KERN_INFO "%s: dialing %d %s... %s\n", p->dev->name,
 695                                                lp->dialretry, cmd.parm.setup.phone,
 696                                                (cmd.parm.setup.si1 == 1) ? "DOV" : "");
 697                                         lp->dtimer = 0;
 698 #ifdef ISDN_DEBUG_NET_DIAL
 699                                         printk(KERN_DEBUG "dial: d=%d c=%d\n", lp->isdn_device,
 700                                                lp->isdn_channel);
 701 #endif
 702                                         isdn_command(&cmd);
 703                                 }
 704                                 lp->huptimer = 0;
 705                                 lp->outgoing = 1;
 706                                 if (lp->chargeint) {
 707                                         lp->hupflags |= ISDN_HAVECHARGE;
 708                                         lp->hupflags &= ~ISDN_WAITCHARGE;
 709                                 } else {
 710                                         lp->hupflags |= ISDN_WAITCHARGE;
 711                                         lp->hupflags &= ~ISDN_HAVECHARGE;
 712                                 }
 713                                 anymore = 1;
 714                                 lp->dialstate =
 715                                     (lp->cbdelay &&
 716                                      (lp->flags & ISDN_NET_CBOUT)) ? 12 : 4;
 717                                 break;
 718                         case 4:
 719                                 /* Wait for D-Channel-connect.
 720                                  * If timeout, switch back to state 3.
 721                                  * Dialmax-handling moved to state 3.
 722                                  */
 723                                 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
 724                                         lp->dialstate = 3;
 725                                 anymore = 1;
 726                                 break;
 727                         case 5:
 728                                 /* Got D-Channel-Connect, send B-Channel-request */
 729                                 cmd.driver = lp->isdn_device;
 730                                 cmd.arg = lp->isdn_channel;
 731                                 cmd.command = ISDN_CMD_ACCEPTB;
 732                                 anymore = 1;
 733                                 lp->dtimer = 0;
 734                                 lp->dialstate++;
 735                                 isdn_command(&cmd);
 736                                 break;
 737                         case 6:
 738                                 /* Wait for B- or D-Channel-connect. If timeout,
 739                                  * switch back to state 3.
 740                                  */
 741 #ifdef ISDN_DEBUG_NET_DIAL
 742                                 printk(KERN_DEBUG "dialtimer2: %d\n", lp->dtimer);
 743 #endif
 744                                 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
 745                                         lp->dialstate = 3;
 746                                 anymore = 1;
 747                                 break;
 748                         case 7:
 749                                 /* Got incoming Call, setup L2 and L3 protocols,
 750                                  * then wait for D-Channel-connect
 751                                  */
 752 #ifdef ISDN_DEBUG_NET_DIAL
 753                                 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
 754 #endif
 755                                 cmd.driver = lp->isdn_device;
 756                                 cmd.command = ISDN_CMD_SETL2;
 757                                 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8);
 758                                 isdn_command(&cmd);
 759                                 cmd.driver = lp->isdn_device;
 760                                 cmd.command = ISDN_CMD_SETL3;
 761                                 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8);
 762                                 isdn_command(&cmd);
 763                                 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT15)
 764                                         isdn_net_hangup(p->dev);
 765                                 else {
 766                                         anymore = 1;
 767                                         lp->dialstate++;
 768                                 }
 769                                 break;
 770                         case 9:
 771                                 /* Got incoming D-Channel-Connect, send B-Channel-request */
 772                                 cmd.driver = lp->isdn_device;
 773                                 cmd.arg = lp->isdn_channel;
 774                                 cmd.command = ISDN_CMD_ACCEPTB;
 775                                 isdn_command(&cmd);
 776                                 anymore = 1;
 777                                 lp->dtimer = 0;
 778                                 lp->dialstate++;
 779                                 break;
 780                         case 8:
 781                         case 10:
 782                                 /*  Wait for B- or D-channel-connect */
 783 #ifdef ISDN_DEBUG_NET_DIAL
 784                                 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
 785 #endif
 786                                 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
 787                                         isdn_net_hangup(p->dev);
 788                                 else
 789                                         anymore = 1;
 790                                 break;
 791                         case 11:
 792                                 /* Callback Delay */
 793                                 if (lp->dtimer++ > lp->cbdelay)
 794                                         lp->dialstate = 1;
 795                                 anymore = 1;
 796                                 break;
 797                         case 12:
 798                                 /* Remote does callback. Hangup after cbdelay, then wait for incoming
 799                                  * call (in state 4).
 800                                  */
 801                                 if (lp->dtimer++ > lp->cbdelay)
 802                                 {
 803                                         printk(KERN_INFO "%s: hangup waiting for callback ...\n", p->dev->name);
 804                                         lp->dtimer = 0;
 805                                         lp->dialstate = 4;
 806                                         cmd.driver = lp->isdn_device;
 807                                         cmd.command = ISDN_CMD_HANGUP;
 808                                         cmd.arg = lp->isdn_channel;
 809                                         isdn_command(&cmd);
 810                                         isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
 811                                 }
 812                                 anymore = 1;
 813                                 break;
 814                         default:
 815                                 printk(KERN_WARNING "isdn_net: Illegal dialstate %d for device %s\n",
 816                                        lp->dialstate, p->dev->name);
 817                 }
 818                 p = (isdn_net_dev *) p->next;
 819         }
 820         isdn_timer_ctrl(ISDN_TIMER_NETDIAL, anymore);
 821 }
 822
 823 /*
 824  * Perform hangup for a net-interface.
 825  */
 826 void
 827 isdn_net_hangup(struct net_device *d)
 828 {
 829         isdn_net_local *lp = (isdn_net_local *) netdev_priv(d);
 830         isdn_ctrl cmd;
 831 #ifdef CONFIG_ISDN_X25
 832         struct concap_proto *cprot = lp->netdev->cprot;
 833         struct concap_proto_ops *pops = cprot ? cprot->pops : NULL;
 834 #endif
 835
 836         if (lp->flags & ISDN_NET_CONNECTED) {
 837                 if (lp->slave != NULL) {
 838                         isdn_net_local *slp = ISDN_SLAVE_PRIV(lp);
 839                         if (slp->flags & ISDN_NET_CONNECTED) {
 840                                 printk(KERN_INFO
 841                                         "isdn_net: hang up slave %s before %s\n",
 842                                         lp->slave->name, d->name);
 843                                 isdn_net_hangup(lp->slave);
 844                         }
 845                 }
 846                 printk(KERN_INFO "isdn_net: local hangup %s\n", d->name);
 847 #ifdef CONFIG_ISDN_PPP
 848                 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
 849                         isdn_ppp_free(lp);
 850 #endif
 851                 isdn_net_lp_disconnected(lp);
 852 #ifdef CONFIG_ISDN_X25
 853                 /* try if there are generic encap protocol
 854                    receiver routines and signal the closure of
 855                    the link */
 856                 if( pops && pops -> disconn_ind )
 857                   pops -> disconn_ind(cprot);
 858 #endif /* CONFIG_ISDN_X25 */
 859
 860                 cmd.driver = lp->isdn_device;
 861                 cmd.command = ISDN_CMD_HANGUP;
 862                 cmd.arg = lp->isdn_channel;
 863                 isdn_command(&cmd);
 864                 printk(KERN_INFO "%s: Chargesum is %d\n", d->name, lp->charge);
 865                 isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
 866         }
 867         isdn_net_unbind_channel(lp);
 868 }
 869
 870 typedef struct {
 871         __be16 source;
 872         __be16 dest;
 873 } ip_ports;
 874
 875 static void
 876 isdn_net_log_skb(struct sk_buff * skb, isdn_net_local * lp)
 877 {
 878         /* hopefully, this was set correctly */
 879         const u_char *p = skb_network_header(skb);
 880         unsigned short proto = ntohs(skb->protocol);
 881         int data_ofs;
 882         ip_ports *ipp;
 883         char addinfo[100];
 884
 885         addinfo[0] = '\0';
 886         /* This check stolen from 2.1.72 dev_queue_xmit_nit() */
 887         if (p < skb->data || skb->network_header >= skb->tail) {
 888                 /* fall back to old isdn_net_log_packet method() */
 889                 char * buf = skb->data;
 890
 891                 printk(KERN_DEBUG "isdn_net: protocol %04x is buggy, dev %s\n", skb->protocol, lp->netdev->dev->name);
 892                 p = buf;
 893                 proto = ETH_P_IP;
 894                 switch (lp->p_encap) {
 895                         case ISDN_NET_ENCAP_IPTYP:
 896                                 proto = ntohs(*(__be16 *)&buf[0]);
 897                                 p = &buf[2];
 898                                 break;
 899                         case ISDN_NET_ENCAP_ETHER:
 900                                 proto = ntohs(*(__be16 *)&buf[12]);
 901                                 p = &buf[14];
 902                                 break;
 903                         case ISDN_NET_ENCAP_CISCOHDLC:
 904                                 proto = ntohs(*(__be16 *)&buf[2]);
 905                                 p = &buf[4];
 906                                 break;
 907 #ifdef CONFIG_ISDN_PPP
 908                         case ISDN_NET_ENCAP_SYNCPPP:
 909                                 proto = ntohs(skb->protocol);
 910                                 p = &buf[IPPP_MAX_HEADER];
 911                                 break;
 912 #endif
 913                 }
 914         }
 915         data_ofs = ((p[0] & 15) * 4);
 916         switch (proto) {
 917                 case ETH_P_IP:
 918                         switch (p[9]) {
 919                                 case 1:
 920                                         strcpy(addinfo, " ICMP");
 921                                         break;
 922                                 case 2:
 923                                         strcpy(addinfo, " IGMP");
 924                                         break;
 925                                 case 4:
 926                                         strcpy(addinfo, " IPIP");
 927                                         break;
 928                                 case 6:
 929                                         ipp = (ip_ports *) (&p[data_ofs]);
 930                                         sprintf(addinfo, " TCP, port: %d -> %d", ntohs(ipp->source),
 931                                                 ntohs(ipp->dest));
 932                                         break;
 933                                 case 8:
 934                                         strcpy(addinfo, " EGP");
 935                                         break;
 936                                 case 12:
 937                                         strcpy(addinfo, " PUP");
 938                                         break;
 939                                 case 17:
 940                                         ipp = (ip_ports *) (&p[data_ofs]);
 941                                         sprintf(addinfo, " UDP, port: %d -> %d", ntohs(ipp->source),
 942                                                 ntohs(ipp->dest));
 943                                         break;
 944                                 case 22:
 945                                         strcpy(addinfo, " IDP");
 946                                         break;
 947                         }
 948                         printk(KERN_INFO "OPEN: %pI4 -> %pI4%s\n",
 949                                p + 12, p + 16, addinfo);
 950                         break;
 951                 case ETH_P_ARP:
 952                         printk(KERN_INFO "OPEN: ARP %pI4 -> *.*.*.* ?%pI4\n",
 953                                p + 14, p + 24);
 954                         break;
 955         }
 956 }
 957
 958 /*
 959  * this function is used to send supervisory data, i.e. data which was
 960  * not received from the network layer, but e.g. frames from ipppd, CCP
 961  * reset frames etc.
 962  */
 963 void isdn_net_write_super(isdn_net_local *lp, struct sk_buff *skb)
 964 {
 965         if (in_irq()) {
 966                 // we can't grab the lock from irq context,
 967                 // so we just queue the packet
 968                 skb_queue_tail(&lp->super_tx_queue, skb);
 969                 schedule_work(&lp->tqueue);
 970                 return;
 971         }
 972
 973         spin_lock_bh(&lp->xmit_lock);
 974         if (!isdn_net_lp_busy(lp)) {
 975                 isdn_net_writebuf_skb(lp, skb);
 976         } else {
 977                 skb_queue_tail(&lp->super_tx_queue, skb);
 978         }
 979         spin_unlock_bh(&lp->xmit_lock);
 980 }
 981
 982 /*
 983  * called from tq_immediate
 984  */
 985 static void isdn_net_softint(struct work_struct *work)
 986 {
 987         isdn_net_local *lp = container_of(work, isdn_net_local, tqueue);
 988         struct sk_buff *skb;
 989
 990         spin_lock_bh(&lp->xmit_lock);
 991         while (!isdn_net_lp_busy(lp)) {
 992                 skb = skb_dequeue(&lp->super_tx_queue);
 993                 if (!skb)
 994                         break;
 995                 isdn_net_writebuf_skb(lp, skb);
 996         }
 997         spin_unlock_bh(&lp->xmit_lock);
 998 }
 999
1000 /*
1001  * all frames sent from the (net) LL to a HL driver should go via this function
1002  * it's serialized by the caller holding the lp->xmit_lock spinlock
1003  */
1004 void isdn_net_writebuf_skb(isdn_net_local *lp, struct sk_buff *skb)
1005 {
1006         int ret;
1007         int len = skb->len;     /* save len */
1008
1009         /* before obtaining the lock the caller should have checked that
1010            the lp isn't busy */
1011         if (isdn_net_lp_busy(lp)) {
1012                 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__);
1013                 goto error;
1014         }
1015
1016         if (!(lp->flags & ISDN_NET_CONNECTED)) {
1017                 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__);
1018                 goto error;
1019         }
1020         ret = isdn_writebuf_skb_stub(lp->isdn_device, lp->isdn_channel, 1, skb);
1021         if (ret != len) {
1022                 /* we should never get here */
1023                 printk(KERN_WARNING "%s: HL driver queue full\n", lp->netdev->dev->name);
1024                 goto error;
1025         }
1026
1027         lp->transcount += len;
1028         isdn_net_inc_frame_cnt(lp);
1029         return;
1030
1031  error:
1032         dev_kfree_skb(skb);
1033         lp->stats.tx_errors++;
1034
1035 }
1036
1037
1038 /*
1039  *  Helper function for isdn_net_start_xmit.
1040  *  When called, the connection is already established.
1041  *  Based on cps-calculation, check if device is overloaded.
1042  *  If so, and if a slave exists, trigger dialing for it.
1043  *  If any slave is online, deliver packets using a simple round robin
1044  *  scheme.
1045  *
1046  *  Return: 0 on success, !0 on failure.
1047  */
1048
1049 static int
1050 isdn_net_xmit(struct net_device *ndev, struct sk_buff *skb)
1051 {
1052         isdn_net_dev *nd;
1053         isdn_net_local *slp;
1054         isdn_net_local *lp = (isdn_net_local *) netdev_priv(ndev);
1055         int retv = NETDEV_TX_OK;
1056
1057         if (((isdn_net_local *) netdev_priv(ndev))->master) {
1058                 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__);
1059                 dev_kfree_skb(skb);
1060                 return NETDEV_TX_OK;
1061         }
1062
1063         /* For the other encaps the header has already been built */
1064 #ifdef CONFIG_ISDN_PPP
1065         if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
1066                 return isdn_ppp_xmit(skb, ndev);
1067         }
1068 #endif
1069         nd = ((isdn_net_local *) netdev_priv(ndev))->netdev;
1070         lp = isdn_net_get_locked_lp(nd);
1071         if (!lp) {
1072                 printk(KERN_WARNING "%s: all channels busy - requeuing!\n", ndev->name);
1073                 return NETDEV_TX_BUSY;
1074         }
1075         /* we have our lp locked from now on */
1076
1077         /* Reset hangup-timeout */
1078         lp->huptimer = 0; // FIXME?
1079         isdn_net_writebuf_skb(lp, skb);
1080         spin_unlock_bh(&lp->xmit_lock);
1081
1082         /* the following stuff is here for backwards compatibility.
1083          * in future, start-up and hangup of slaves (based on current load)
1084          * should move to userspace and get based on an overall cps
1085          * calculation
1086          */
1087         if (lp->cps > lp->triggercps) {
1088                 if (lp->slave) {
1089                         if (!lp->sqfull) {
1090                                 /* First time overload: set timestamp only */
1091                                 lp->sqfull = 1;
1092                                 lp->sqfull_stamp = jiffies;
1093                         } else {
1094                                 /* subsequent overload: if slavedelay exceeded, start dialing */
1095                                 if (time_after(jiffies, lp->sqfull_stamp + lp->slavedelay)) {
1096                                         slp = ISDN_SLAVE_PRIV(lp);
1097                                         if (!(slp->flags & ISDN_NET_CONNECTED)) {
1098                                                 isdn_net_force_dial_lp(ISDN_SLAVE_PRIV(lp));
1099                                         }
1100                                 }
1101                         }
1102                 }
1103         } else {
1104                 if (lp->sqfull && time_after(jiffies, lp->sqfull_stamp + lp->slavedelay + (10 * HZ))) {
1105                         lp->sqfull = 0;
1106                 }
1107                 /* this is a hack to allow auto-hangup for slaves on moderate loads */
1108                 nd->queue = nd->local;
1109         }
1110
1111         return retv;
1112
1113 }
1114
1115 static void
1116 isdn_net_adjust_hdr(struct sk_buff *skb, struct net_device *dev)
1117 {
1118         isdn_net_local *lp = (isdn_net_local *) netdev_priv(dev);
1119         if (!skb)
1120                 return;
1121         if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1122                 const int pullsize = skb_network_offset(skb) - ETH_HLEN;
1123                 if (pullsize > 0) {
1124                         printk(KERN_DEBUG "isdn_net: Pull junk %d\n", pullsize);
1125                         skb_pull(skb, pullsize);
1126                 }
1127         }
1128 }
1129
1130
1131 static void isdn_net_tx_timeout(struct net_device * ndev)
1132 {
1133         isdn_net_local *lp = (isdn_net_local *) netdev_priv(ndev);
1134
1135         printk(KERN_WARNING "isdn_tx_timeout dev %s dialstate %d\n", ndev->name, lp->dialstate);
1136         if (!lp->dialstate){
1137                 lp->stats.tx_errors++;
1138                 /*
1139                  * There is a certain probability that this currently
1140                  * works at all because if we always wake up the interface,
1141                  * then upper layer will try to send the next packet
1142                  * immediately. And then, the old clean_up logic in the
1143                  * driver will hopefully continue to work as it used to do.
1144                  *
1145                  * This is rather primitive right know, we better should
1146                  * clean internal queues here, in particular for multilink and
1147                  * ppp, and reset HL driver's channel, too.   --HE
1148                  *
1149                  * actually, this may not matter at all, because ISDN hardware
1150                  * should not see transmitter hangs at all IMO
1151                  * changed KERN_DEBUG to KERN_WARNING to find out if this is
1152                  * ever called   --KG
1153                  */
1154         }
1155         ndev->trans_start = jiffies;
1156         netif_wake_queue(ndev);
1157 }
1158
1159 /*
1160  * Try sending a packet.
1161  * If this interface isn't connected to a ISDN-Channel, find a free channel,
1162  * and start dialing.
1163  */
1164 static netdev_tx_t
1165 isdn_net_start_xmit(struct sk_buff *skb, struct net_device *ndev)
1166 {
1167         isdn_net_local *lp = (isdn_net_local *) netdev_priv(ndev);
1168 #ifdef CONFIG_ISDN_X25
1169         struct concap_proto * cprot = lp -> netdev -> cprot;
1170 /* At this point hard_start_xmit() passes control to the encapsulation
1171    protocol (if present).
1172    For X.25 auto-dialing is completly bypassed because:
1173    - It does not conform with the semantics of a reliable datalink
1174      service as needed by X.25 PLP.
1175    - I don't want that the interface starts dialing when the network layer
1176      sends a message which requests to disconnect the lapb link (or if it
1177      sends any other message not resulting in data transmission).
1178    Instead, dialing will be initiated by the encapsulation protocol entity
1179    when a dl_establish request is received from the upper layer.
1180 */
1181         if (cprot && cprot -> pops) {
1182                 int ret = cprot -> pops -> encap_and_xmit ( cprot , skb);
1183
1184                 if (ret)
1185                         netif_stop_queue(ndev);
1186                 return ret;
1187         } else
1188 #endif
1189         /* auto-dialing xmit function */
1190         {
1191 #ifdef ISDN_DEBUG_NET_DUMP
1192                 u_char *buf;
1193 #endif
1194                 isdn_net_adjust_hdr(skb, ndev);
1195 #ifdef ISDN_DEBUG_NET_DUMP
1196                 buf = skb->data;
1197                 isdn_dumppkt("S:", buf, skb->len, 40);
1198 #endif
1199
1200                 if (!(lp->flags & ISDN_NET_CONNECTED)) {
1201                         int chi;
1202                         /* only do autodial if allowed by config */
1203                         if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) {
1204                                 isdn_net_unreachable(ndev, skb, "dial rejected: interface not in dialmode `auto'");
1205                                 dev_kfree_skb(skb);
1206                                 return NETDEV_TX_OK;
1207                         }
1208                         if (lp->phone[1]) {
1209                                 ulong flags;
1210
1211                                 if(lp->dialwait_timer <= 0)
1212                                         if(lp->dialstarted > 0 && lp->dialtimeout > 0 && time_before(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait))
1213                                                 lp->dialwait_timer = lp->dialstarted + lp->dialtimeout + lp->dialwait;
1214
1215                                 if(lp->dialwait_timer > 0) {
1216                                         if(time_before(jiffies, lp->dialwait_timer)) {
1217                                                 isdn_net_unreachable(ndev, skb, "dial rejected: retry-time not reached");
1218                                                 dev_kfree_skb(skb);
1219                                                 return NETDEV_TX_OK;
1220                                         } else
1221                                                 lp->dialwait_timer = 0;
1222                                 }
1223                                 /* Grab a free ISDN-Channel */
1224                                 spin_lock_irqsave(&dev->lock, flags);
1225                                 if (((chi =
1226                                      isdn_get_free_channel(
1227                                                         ISDN_USAGE_NET,
1228                                                         lp->l2_proto,
1229                                                         lp->l3_proto,
1230                                                         lp->pre_device,
1231                                                         lp->pre_channel,
1232                                                         lp->msn)
1233                                                         ) < 0) &&
1234                                         ((chi =
1235                                      isdn_get_free_channel(
1236                                                         ISDN_USAGE_NET,
1237                                                         lp->l2_proto,
1238                                                         lp->l3_proto,
1239                                                         lp->pre_device,
1240                                                         lp->pre_channel^1,
1241                                                         lp->msn)
1242                                                         ) < 0)) {
1243                                         spin_unlock_irqrestore(&dev->lock, flags);
1244                                         isdn_net_unreachable(ndev, skb,
1245                                                            "No channel");
1246                                         dev_kfree_skb(skb);
1247                                         return NETDEV_TX_OK;
1248                                 }
1249                                 /* Log packet, which triggered dialing */
1250                                 if (dev->net_verbose)
1251                                         isdn_net_log_skb(skb, lp);
1252                                 lp->dialstate = 1;
1253                                 /* Connect interface with channel */
1254                                 isdn_net_bind_channel(lp, chi);
1255 #ifdef CONFIG_ISDN_PPP
1256                                 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
1257                                         /* no 'first_skb' handling for syncPPP */
1258                                         if (isdn_ppp_bind(lp) < 0) {
1259                                                 dev_kfree_skb(skb);
1260                                                 isdn_net_unbind_channel(lp);
1261                                                 spin_unlock_irqrestore(&dev->lock, flags);
1262                                                 return NETDEV_TX_OK;    /* STN (skb to nirvana) ;) */
1263                                         }
1264 #ifdef CONFIG_IPPP_FILTER
1265                                         if (isdn_ppp_autodial_filter(skb, lp)) {
1266                                                 isdn_ppp_free(lp);
1267                                                 isdn_net_unbind_channel(lp);
1268                                                 spin_unlock_irqrestore(&dev->lock, flags);
1269                                                 isdn_net_unreachable(ndev, skb, "dial rejected: packet filtered");
1270                                                 dev_kfree_skb(skb);
1271                                                 return NETDEV_TX_OK;
1272                                         }
1273 #endif
1274                                         spin_unlock_irqrestore(&dev->lock, flags);
1275                                         isdn_net_dial();        /* Initiate dialing */
1276                                         netif_stop_queue(ndev);
1277                                         return NETDEV_TX_BUSY;  /* let upper layer requeue skb packet */
1278                                 }
1279 #endif
1280                                 /* Initiate dialing */
1281                                 spin_unlock_irqrestore(&dev->lock, flags);
1282                                 isdn_net_dial();
1283                                 isdn_net_device_stop_queue(lp);
1284                                 return NETDEV_TX_BUSY;
1285                         } else {
1286                                 isdn_net_unreachable(ndev, skb,
1287                                                      "No phone number");
1288                                 dev_kfree_skb(skb);
1289                                 return NETDEV_TX_OK;
1290                         }
1291                 } else {
1292                         /* Device is connected to an ISDN channel */
1293                         ndev->trans_start = jiffies;
1294                         if (!lp->dialstate) {
1295                                 /* ISDN connection is established, try sending */
1296                                 int ret;
1297                                 ret = (isdn_net_xmit(ndev, skb));
1298                                 if(ret) netif_stop_queue(ndev);
1299                                 return ret;
1300                         } else
1301                                 netif_stop_queue(ndev);
1302                 }
1303         }
1304         return NETDEV_TX_BUSY;
1305 }
1306
1307 /*
1308  * Shutdown a net-interface.
1309  */
1310 static int
1311 isdn_net_close(struct net_device *dev)
1312 {
1313         struct net_device *p;
1314 #ifdef CONFIG_ISDN_X25
1315         struct concap_proto * cprot =
1316                 ((isdn_net_local *) netdev_priv(dev))->netdev->cprot;
1317         /* printk(KERN_DEBUG "isdn_net_close %s\n" , dev-> name ); */
1318 #endif
1319
1320 #ifdef CONFIG_ISDN_X25
1321         if( cprot && cprot -> pops ) cprot -> pops -> close( cprot );
1322 #endif
1323         netif_stop_queue(dev);
1324         p = MASTER_TO_SLAVE(dev);
1325         if (p) {
1326                 /* If this interface has slaves, stop them also */
1327                 while (p) {
1328 #ifdef CONFIG_ISDN_X25
1329                         cprot = ((isdn_net_local *) netdev_priv(p))
1330                                 -> netdev -> cprot;
1331                         if( cprot && cprot -> pops )
1332                                 cprot -> pops -> close( cprot );
1333 #endif
1334                         isdn_net_hangup(p);
1335                         p = MASTER_TO_SLAVE(p);
1336                 }
1337         }
1338         isdn_net_hangup(dev);
1339         isdn_unlock_drivers();
1340         return 0;
1341 }
1342
1343 /*
1344  * Get statistics
1345  */
1346 static struct net_device_stats *
1347 isdn_net_get_stats(struct net_device *dev)
1348 {
1349         isdn_net_local *lp = (isdn_net_local *) netdev_priv(dev);
1350         return &lp->stats;
1351 }
1352
1353 /*      This is simply a copy from std. eth.c EXCEPT we pull ETH_HLEN
1354  *      instead of dev->hard_header_len off. This is done because the
1355  *      lowlevel-driver has already pulled off its stuff when we get
1356  *      here and this routine only gets called with p_encap == ETHER.
1357  *      Determine the packet's protocol ID. The rule here is that we
1358  *      assume 802.3 if the type field is short enough to be a length.
1359  *      This is normal practice and works for any 'now in use' protocol.
1360  */
1361
1362 static __be16
1363 isdn_net_type_trans(struct sk_buff *skb, struct net_device *dev)
1364 {
1365         struct ethhdr *eth;
1366         unsigned char *rawp;
1367
1368         skb_reset_mac_header(skb);
1369         skb_pull(skb, ETH_HLEN);
1370         eth = eth_hdr(skb);
1371
1372         if (*eth->h_dest & 1) {
1373                 if (memcmp(eth->h_dest, dev->broadcast, ETH_ALEN) == 0)
1374                         skb->pkt_type = PACKET_BROADCAST;
1375                 else
1376                         skb->pkt_type = PACKET_MULTICAST;
1377         }
1378         /*
1379          *      This ALLMULTI check should be redundant by 1.4
1380          *      so don't forget to remove it.
1381          */
1382
1383         else if (dev->flags & (IFF_PROMISC /*| IFF_ALLMULTI*/)) {
1384                 if (memcmp(eth->h_dest, dev->dev_addr, ETH_ALEN))
1385                         skb->pkt_type = PACKET_OTHERHOST;
1386         }
1387         if (ntohs(eth->h_proto) >= 1536)
1388                 return eth->h_proto;
1389
1390         rawp = skb->data;
1391
1392         /*
1393          *      This is a magic hack to spot IPX packets. Older Novell breaks
1394          *      the protocol design and runs IPX over 802.3 without an 802.2 LLC
1395          *      layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
1396          *      won't work for fault tolerant netware but does for the rest.
1397          */
1398         if (*(unsigned short *) rawp == 0xFFFF)
1399                 return htons(ETH_P_802_3);
1400         /*
1401          *      Real 802.2 LLC
1402          */
1403         return htons(ETH_P_802_2);
1404 }
1405
1406
1407 /*
1408  * CISCO HDLC keepalive specific stuff
1409  */
1410 static struct sk_buff*
1411 isdn_net_ciscohdlck_alloc_skb(isdn_net_local *lp, int len)
1412 {
1413         unsigned short hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
1414         struct sk_buff *skb;
1415
1416         skb = alloc_skb(hl + len, GFP_ATOMIC);
1417         if (skb)
1418                 skb_reserve(skb, hl);
1419         else
1420                 printk("isdn out of mem at %s:%d!\n", __FILE__, __LINE__);
1421         return skb;
1422 }
1423
1424 /* cisco hdlck device private ioctls */
1425 static int
1426 isdn_ciscohdlck_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1427 {
1428         isdn_net_local *lp = (isdn_net_local *) netdev_priv(dev);
1429         unsigned long len = 0;
1430         unsigned long expires = 0;
1431         int tmp = 0;
1432         int period = lp->cisco_keepalive_period;
1433         s8 debserint = lp->cisco_debserint;
1434         int rc = 0;
1435
1436         if (lp->p_encap != ISDN_NET_ENCAP_CISCOHDLCK)
1437                 return -EINVAL;
1438
1439         switch (cmd) {
1440                 /* get/set keepalive period */
1441                 case SIOCGKEEPPERIOD:
1442                         len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1443                         if (copy_to_user(ifr->ifr_data,
1444                                 &lp->cisco_keepalive_period, len))
1445                                 rc = -EFAULT;
1446                         break;
1447                 case SIOCSKEEPPERIOD:
1448                         tmp = lp->cisco_keepalive_period;
1449                         len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1450                         if (copy_from_user(&period, ifr->ifr_data, len))
1451                                 rc = -EFAULT;
1452                         if ((period > 0) && (period <= 32767))
1453                                 lp->cisco_keepalive_period = period;
1454                         else
1455                                 rc = -EINVAL;
1456                         if (!rc && (tmp != lp->cisco_keepalive_period)) {
1457                                 expires = (unsigned long)(jiffies +
1458                                         lp->cisco_keepalive_period * HZ);
1459                                 mod_timer(&lp->cisco_timer, expires);
1460                                 printk(KERN_INFO "%s: Keepalive period set "
1461                                         "to %d seconds.\n",
1462                                         dev->name, lp->cisco_keepalive_period);
1463                         }
1464                         break;
1465
1466                 /* get/set debugging */
1467                 case SIOCGDEBSERINT:
1468                         len = (unsigned long)sizeof(lp->cisco_debserint);
1469                         if (copy_to_user(ifr->ifr_data,
1470                                 &lp->cisco_debserint, len))
1471                                 rc = -EFAULT;
1472                         break;
1473                 case SIOCSDEBSERINT:
1474                         len = (unsigned long)sizeof(lp->cisco_debserint);
1475                         if (copy_from_user(&debserint,
1476                                 ifr->ifr_data, len))
1477                                 rc = -EFAULT;
1478                         if ((debserint >= 0) && (debserint <= 64))
1479                                 lp->cisco_debserint = debserint;
1480                         else
1481                                 rc = -EINVAL;
1482                         break;
1483
1484                 default:
1485                         rc = -EINVAL;
1486                         break;
1487         }
1488         return (rc);
1489 }
1490
1491
1492 static int isdn_net_ioctl(struct net_device *dev,
1493                           struct ifreq *ifr, int cmd)
1494 {
1495         isdn_net_local *lp = (isdn_net_local *) netdev_priv(dev);
1496
1497         switch (lp->p_encap) {
1498 #ifdef CONFIG_ISDN_PPP
1499         case ISDN_NET_ENCAP_SYNCPPP:
1500                 return isdn_ppp_dev_ioctl(dev, ifr, cmd);
1501 #endif
1502         case ISDN_NET_ENCAP_CISCOHDLCK:
1503                 return isdn_ciscohdlck_dev_ioctl(dev, ifr, cmd);
1504         default:
1505                 return -EINVAL;
1506         }
1507 }
1508
1509 /* called via cisco_timer.function */
1510 static void
1511 isdn_net_ciscohdlck_slarp_send_keepalive(unsigned long data)
1512 {
1513         isdn_net_local *lp = (isdn_net_local *) data;
1514         struct sk_buff *skb;
1515         unsigned char *p;
1516         unsigned long last_cisco_myseq = lp->cisco_myseq;
1517         int myseq_diff = 0;
1518
1519         if (!(lp->flags & ISDN_NET_CONNECTED) || lp->dialstate) {
1520                 printk("isdn BUG at %s:%d!\n", __FILE__, __LINE__);
1521                 return;
1522         }
1523         lp->cisco_myseq++;
1524
1525         myseq_diff = (lp->cisco_myseq - lp->cisco_mineseen);
1526         if ((lp->cisco_line_state) && ((myseq_diff >= 3)||(myseq_diff <= -3))) {
1527                 /* line up -> down */
1528                 lp->cisco_line_state = 0;
1529                 printk (KERN_WARNING
1530                                 "UPDOWN: Line protocol on Interface %s,"
1531                                 " changed state to down\n", lp->netdev->dev->name);
1532                 /* should stop routing higher-level data accross */
1533         } else if ((!lp->cisco_line_state) &&
1534                 (myseq_diff >= 0) && (myseq_diff <= 2)) {
1535                 /* line down -> up */
1536                 lp->cisco_line_state = 1;
1537                 printk (KERN_WARNING
1538                                 "UPDOWN: Line protocol on Interface %s,"
1539                                 " changed state to up\n", lp->netdev->dev->name);
1540                 /* restart routing higher-level data accross */
1541         }
1542
1543         if (lp->cisco_debserint)
1544                 printk (KERN_DEBUG "%s: HDLC "
1545                         "myseq %lu, mineseen %lu%c, yourseen %lu, %s\n",
1546                         lp->netdev->dev->name, last_cisco_myseq, lp->cisco_mineseen,
1547                         ((last_cisco_myseq == lp->cisco_mineseen) ? '*' : 040),
1548                         lp->cisco_yourseq,
1549                         ((lp->cisco_line_state) ? "line up" : "line down"));
1550
1551         skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1552         if (!skb)
1553                 return;
1554
1555         p = skb_put(skb, 4 + 14);
1556
1557         /* cisco header */
1558         *(u8 *)(p + 0) = CISCO_ADDR_UNICAST;
1559         *(u8 *)(p + 1) = CISCO_CTRL;
1560         *(__be16 *)(p + 2) = cpu_to_be16(CISCO_TYPE_SLARP);
1561
1562         /* slarp keepalive */
1563         *(__be32 *)(p +  4) = cpu_to_be32(CISCO_SLARP_KEEPALIVE);
1564         *(__be32 *)(p +  8) = cpu_to_be32(lp->cisco_myseq);
1565         *(__be32 *)(p + 12) = cpu_to_be32(lp->cisco_yourseq);
1566         *(__be16 *)(p + 16) = cpu_to_be16(0xffff); // reliability, always 0xffff
1567         p += 18;
1568
1569         isdn_net_write_super(lp, skb);
1570
1571         lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1572
1573         add_timer(&lp->cisco_timer);
1574 }
1575
1576 static void
1577 isdn_net_ciscohdlck_slarp_send_request(isdn_net_local *lp)
1578 {
1579         struct sk_buff *skb;
1580         unsigned char *p;
1581
1582         skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1583         if (!skb)
1584                 return;
1585
1586         p = skb_put(skb, 4 + 14);
1587
1588         /* cisco header */
1589         *(u8 *)(p + 0) = CISCO_ADDR_UNICAST;
1590         *(u8 *)(p + 1) = CISCO_CTRL;
1591         *(__be16 *)(p + 2) = cpu_to_be16(CISCO_TYPE_SLARP);
1592
1593         /* slarp request */
1594         *(__be32 *)(p +  4) = cpu_to_be32(CISCO_SLARP_REQUEST);
1595         *(__be32 *)(p +  8) = cpu_to_be32(0); // address
1596         *(__be32 *)(p + 12) = cpu_to_be32(0); // netmask
1597         *(__be16 *)(p + 16) = cpu_to_be16(0); // unused
1598         p += 18;
1599
1600         isdn_net_write_super(lp, skb);
1601 }
1602
1603 static void
1604 isdn_net_ciscohdlck_connected(isdn_net_local *lp)
1605 {
1606         lp->cisco_myseq = 0;
1607         lp->cisco_mineseen = 0;
1608         lp->cisco_yourseq = 0;
1609         lp->cisco_keepalive_period = ISDN_TIMER_KEEPINT;
1610         lp->cisco_last_slarp_in = 0;
1611         lp->cisco_line_state = 0;
1612         lp->cisco_debserint = 0;
1613
1614         /* send slarp request because interface/seq.no.s reset */
1615         isdn_net_ciscohdlck_slarp_send_request(lp);
1616
1617         init_timer(&lp->cisco_timer);
1618         lp->cisco_timer.data = (unsigned long) lp;
1619         lp->cisco_timer.function = isdn_net_ciscohdlck_slarp_send_keepalive;
1620         lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1621         add_timer(&lp->cisco_timer);
1622 }
1623
1624 static void
1625 isdn_net_ciscohdlck_disconnected(isdn_net_local *lp)
1626 {
1627         del_timer(&lp->cisco_timer);
1628 }
1629
1630 static void
1631 isdn_net_ciscohdlck_slarp_send_reply(isdn_net_local *lp)
1632 {
1633         struct sk_buff *skb;
1634         unsigned char *p;
1635         struct in_device *in_dev = NULL;
1636         __be32 addr = 0;                /* local ipv4 address */
1637         __be32 mask = 0;                /* local netmask */
1638
1639         if ((in_dev = lp->netdev->dev->ip_ptr) != NULL) {
1640                 /* take primary(first) address of interface */
1641                 struct in_ifaddr *ifa = in_dev->ifa_list;
1642                 if (ifa != NULL) {
1643                         addr = ifa->ifa_local;
1644                         mask = ifa->ifa_mask;
1645                 }
1646         }
1647
1648         skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1649         if (!skb)
1650                 return;
1651
1652         p = skb_put(skb, 4 + 14);
1653
1654         /* cisco header */
1655         *(u8 *)(p + 0) = CISCO_ADDR_UNICAST;
1656         *(u8 *)(p + 1) = CISCO_CTRL;
1657         *(__be16 *)(p + 2) = cpu_to_be16(CISCO_TYPE_SLARP);
1658
1659         /* slarp reply, send own ip/netmask; if values are nonsense remote
1660          * should think we are unable to provide it with an address via SLARP */
1661         *(__be32 *)(p +  4) = cpu_to_be32(CISCO_SLARP_REPLY);
1662         *(__be32 *)(p +  8) = addr; // address
1663         *(__be32 *)(p + 12) = mask; // netmask
1664         *(__be16 *)(p + 16) = cpu_to_be16(0); // unused
1665         p += 18;
1666
1667         isdn_net_write_super(lp, skb);
1668 }
1669
1670 static void
1671 isdn_net_ciscohdlck_slarp_in(isdn_net_local *lp, struct sk_buff *skb)
1672 {
1673         unsigned char *p;
1674         int period;
1675         u32 code;
1676         u32 my_seq;
1677         u32 your_seq;
1678         __be32 local;
1679         __be32 *addr, *mask;
1680         u16 unused;
1681
1682         if (skb->len < 14)
1683                 return;
1684
1685         p = skb->data;
1686         code = be32_to_cpup((__be32 *)p);
1687         p += 4;
1688
1689         switch (code) {
1690         case CISCO_SLARP_REQUEST:
1691                 lp->cisco_yourseq = 0;
1692                 isdn_net_ciscohdlck_slarp_send_reply(lp);
1693                 break;
1694         case CISCO_SLARP_REPLY:
1695                 addr = (__be32 *)p;
1696                 mask = (__be32 *)(p + 4);
1697                 if (*mask != cpu_to_be32(0xfffffffc))
1698                         goto slarp_reply_out;
1699                 if ((*addr & cpu_to_be32(3)) == cpu_to_be32(0) ||
1700                     (*addr & cpu_to_be32(3)) == cpu_to_be32(3))
1701                         goto slarp_reply_out;
1702                 local = *addr ^ cpu_to_be32(3);
1703                 printk(KERN_INFO "%s: got slarp reply: remote ip: %pI4, local ip: %pI4 mask: %pI4\n",
1704                        lp->netdev->dev->name, addr, &local, mask);
1705                 break;
1706   slarp_reply_out:
1707                 printk(KERN_INFO "%s: got invalid slarp reply (%pI4/%pI4) - ignored\n",
1708                        lp->netdev->dev->name, addr, mask);
1709                 break;
1710         case CISCO_SLARP_KEEPALIVE:
1711                 period = (int)((jiffies - lp->cisco_last_slarp_in
1712                                 + HZ/2 - 1) / HZ);
1713                 if (lp->cisco_debserint &&
1714                                 (period != lp->cisco_keepalive_period) &&
1715                                 lp->cisco_last_slarp_in) {
1716                         printk(KERN_DEBUG "%s: Keepalive period mismatch - "
1717                                 "is %d but should be %d.\n",
1718                                 lp->netdev->dev->name, period,
1719                                 lp->cisco_keepalive_period);
1720                 }
1721                 lp->cisco_last_slarp_in = jiffies;
1722                 my_seq = be32_to_cpup((__be32 *)(p + 0));
1723                 your_seq = be32_to_cpup((__be32 *)(p + 4));
1724                 unused = be16_to_cpup((__be16 *)(p + 8));
1725                 p += 10;
1726                 lp->cisco_yourseq = my_seq;
1727                 lp->cisco_mineseen = your_seq;
1728                 break;
1729         }
1730 }
1731
1732 static void
1733 isdn_net_ciscohdlck_receive(isdn_net_local *lp, struct sk_buff *skb)
1734 {
1735         unsigned char *p;
1736         u8 addr;
1737         u8 ctrl;
1738         u16 type;
1739
1740         if (skb->len < 4)
1741                 goto out_free;
1742
1743         p = skb->data;
1744         addr = *(u8 *)(p + 0);
1745         ctrl = *(u8 *)(p + 1);
1746         type = be16_to_cpup((__be16 *)(p + 2));
1747         p += 4;
1748         skb_pull(skb, 4);
1749
1750         if (addr != CISCO_ADDR_UNICAST && addr != CISCO_ADDR_BROADCAST) {
1751                 printk(KERN_WARNING "%s: Unknown Cisco addr 0x%02x\n",
1752                        lp->netdev->dev->name, addr);
1753                 goto out_free;
1754         }
1755         if (ctrl != CISCO_CTRL) {
1756                 printk(KERN_WARNING "%s: Unknown Cisco ctrl 0x%02x\n",
1757                        lp->netdev->dev->name, ctrl);
1758                 goto out_free;
1759         }
1760
1761         switch (type) {
1762         case CISCO_TYPE_SLARP:
1763                 isdn_net_ciscohdlck_slarp_in(lp, skb);
1764                 goto out_free;
1765         case CISCO_TYPE_CDP:
1766                 if (lp->cisco_debserint)
1767                         printk(KERN_DEBUG "%s: Received CDP packet. use "
1768                                 "\"no cdp enable\" on cisco.\n",
1769                                 lp->netdev->dev->name);
1770                 goto out_free;
1771         default:
1772                 /* no special cisco protocol */
1773                 skb->protocol = htons(type);
1774                 netif_rx(skb);
1775                 return;
1776         }
1777
1778  out_free:
1779         kfree_skb(skb);
1780 }
1781
1782 /*
1783  * Got a packet from ISDN-Channel.
1784  */
1785 static void
1786 isdn_net_receive(struct net_device *ndev, struct sk_buff *skb)
1787 {
1788         isdn_net_local *lp = (isdn_net_local *) netdev_priv(ndev);
1789         isdn_net_local *olp = lp;       /* original 'lp' */
1790 #ifdef CONFIG_ISDN_X25
1791         struct concap_proto *cprot = lp -> netdev -> cprot;
1792 #endif
1793         lp->transcount += skb->len;
1794
1795         lp->stats.rx_packets++;
1796         lp->stats.rx_bytes += skb->len;
1797         if (lp->master) {
1798                 /* Bundling: If device is a slave-device, deliver to master, also
1799                  * handle master's statistics and hangup-timeout
1800                  */
1801                 ndev = lp->master;
1802                 lp = (isdn_net_local *) netdev_priv(ndev);
1803                 lp->stats.rx_packets++;
1804                 lp->stats.rx_bytes += skb->len;
1805         }
1806         skb->dev = ndev;
1807         skb->pkt_type = PACKET_HOST;
1808         skb_reset_mac_header(skb);
1809 #ifdef ISDN_DEBUG_NET_DUMP
1810         isdn_dumppkt("R:", skb->data, skb->len, 40);
1811 #endif
1812         switch (lp->p_encap) {
1813                 case ISDN_NET_ENCAP_ETHER:
1814                         /* Ethernet over ISDN */
1815                         olp->huptimer = 0;
1816                         lp->huptimer = 0;
1817                         skb->protocol = isdn_net_type_trans(skb, ndev);
1818                         break;
1819                 case ISDN_NET_ENCAP_UIHDLC:
1820                         /* HDLC with UI-frame (for ispa with -h1 option) */
1821                         olp->huptimer = 0;
1822                         lp->huptimer = 0;
1823                         skb_pull(skb, 2);
1824                         /* Fall through */
1825                 case ISDN_NET_ENCAP_RAWIP:
1826                         /* RAW-IP without MAC-Header */
1827                         olp->huptimer = 0;
1828                         lp->huptimer = 0;
1829                         skb->protocol = htons(ETH_P_IP);
1830                         break;
1831                 case ISDN_NET_ENCAP_CISCOHDLCK:
1832                         isdn_net_ciscohdlck_receive(lp, skb);
1833                         return;
1834                 case ISDN_NET_ENCAP_CISCOHDLC:
1835                         /* CISCO-HDLC IP with type field and  fake I-frame-header */
1836                         skb_pull(skb, 2);
1837                         /* Fall through */
1838                 case ISDN_NET_ENCAP_IPTYP:
1839                         /* IP with type field */
1840                         olp->huptimer = 0;
1841                         lp->huptimer = 0;
1842                         skb->protocol = *(__be16 *)&(skb->data[0]);
1843                         skb_pull(skb, 2);
1844                         if (*(unsigned short *) skb->data == 0xFFFF)
1845                                 skb->protocol = htons(ETH_P_802_3);
1846                         break;
1847 #ifdef CONFIG_ISDN_PPP
1848                 case ISDN_NET_ENCAP_SYNCPPP:
1849                         /* huptimer is done in isdn_ppp_push_higher */
1850                         isdn_ppp_receive(lp->netdev, olp, skb);
1851                         return;
1852 #endif
1853
1854                 default:
1855 #ifdef CONFIG_ISDN_X25
1856                   /* try if there are generic sync_device receiver routines */
1857                         if(cprot) if(cprot -> pops)
1858                                 if( cprot -> pops -> data_ind){
1859                                         cprot -> pops -> data_ind(cprot,skb);
1860                                         return;
1861                                 };
1862 #endif /* CONFIG_ISDN_X25 */
1863                         printk(KERN_WARNING "%s: unknown encapsulation, dropping\n",
1864                                lp->netdev->dev->name);
1865                         kfree_skb(skb);
1866                         return;
1867         }
1868
1869         netif_rx(skb);
1870         return;
1871 }
1872
1873 /*
1874  * A packet arrived via ISDN. Search interface-chain for a corresponding
1875  * interface. If found, deliver packet to receiver-function and return 1,
1876  * else return 0.
1877  */
1878 int
1879 isdn_net_rcv_skb(int idx, struct sk_buff *skb)
1880 {
1881         isdn_net_dev *p = dev->rx_netdev[idx];
1882
1883         if (p) {
1884                 isdn_net_local *lp = p->local;
1885                 if ((lp->flags & ISDN_NET_CONNECTED) &&
1886                     (!lp->dialstate)) {
1887                         isdn_net_receive(p->dev, skb);
1888                         return 1;
1889                 }
1890         }
1891         return 0;
1892 }
1893
1894 /*
1895  *  build an header
1896  *  depends on encaps that is being used.
1897  */
1898
1899 static int isdn_net_header(struct sk_buff *skb, struct net_device *dev,
1900                            unsigned short type,
1901                            const void *daddr, const void *saddr, unsigned plen)
1902 {
1903         isdn_net_local *lp = netdev_priv(dev);
1904         unsigned char *p;
1905         ushort len = 0;
1906
1907         switch (lp->p_encap) {
1908                 case ISDN_NET_ENCAP_ETHER:
1909                         len = eth_header(skb, dev, type, daddr, saddr, plen);
1910                         break;
1911 #ifdef CONFIG_ISDN_PPP
1912                 case ISDN_NET_ENCAP_SYNCPPP:
1913                         /* stick on a fake header to keep fragmentation code happy. */
1914                         len = IPPP_MAX_HEADER;
1915                         skb_push(skb,len);
1916                         break;
1917 #endif
1918                 case ISDN_NET_ENCAP_RAWIP:
1919                         printk(KERN_WARNING "isdn_net_header called with RAW_IP!\n");
1920                         len = 0;
1921                         break;
1922                 case ISDN_NET_ENCAP_IPTYP:
1923                         /* ethernet type field */
1924                         *((__be16 *)skb_push(skb, 2)) = htons(type);
1925                         len = 2;
1926                         break;
1927                 case ISDN_NET_ENCAP_UIHDLC:
1928                         /* HDLC with UI-Frames (for ispa with -h1 option) */
1929                         *((__be16 *)skb_push(skb, 2)) = htons(0x0103);
1930                         len = 2;
1931                         break;
1932                 case ISDN_NET_ENCAP_CISCOHDLC:
1933                 case ISDN_NET_ENCAP_CISCOHDLCK:
1934                         p = skb_push(skb, 4);
1935                         *(u8 *)(p + 0) = CISCO_ADDR_UNICAST;
1936                         *(u8 *)(p + 1) = CISCO_CTRL;
1937                         *(__be16 *)(p + 2) = cpu_to_be16(type);
1938                         p += 4;
1939                         len = 4;
1940                         break;
1941 #ifdef CONFIG_ISDN_X25
1942                 default:
1943                   /* try if there are generic concap protocol routines */
1944                         if( lp-> netdev -> cprot ){
1945                                 printk(KERN_WARNING "isdn_net_header called with concap_proto!\n");
1946                                 len = 0;
1947                                 break;
1948                         }
1949                         break;
1950 #endif /* CONFIG_ISDN_X25 */
1951         }
1952         return len;
1953 }
1954
1955 /* We don't need to send arp, because we have point-to-point connections. */
1956 static int
1957 isdn_net_rebuild_header(struct sk_buff *skb)
1958 {
1959         struct net_device *dev = skb->dev;
1960         isdn_net_local *lp = netdev_priv(dev);
1961         int ret = 0;
1962
1963         if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1964                 struct ethhdr *eth = (struct ethhdr *) skb->data;
1965
1966                 /*
1967                  *      Only ARP/IP is currently supported
1968                  */
1969
1970                 if (eth->h_proto != htons(ETH_P_IP)) {
1971                         printk(KERN_WARNING
1972                                "isdn_net: %s don't know how to resolve type %d addresses?\n",
1973                                dev->name, (int) eth->h_proto);
1974                         memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
1975                         return 0;
1976                 }
1977                 /*
1978                  *      Try to get ARP to resolve the header.
1979                  */
1980 #ifdef CONFIG_INET
1981                 ret = arp_find(eth->h_dest, skb);
1982 #endif
1983         }
1984         return ret;
1985 }
1986
1987 static int isdn_header_cache(const struct neighbour *neigh, struct hh_cache *hh)
1988 {
1989         const struct net_device *dev = neigh->dev;
1990         isdn_net_local *lp = netdev_priv(dev);
1991
1992         if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
1993                 return eth_header_cache(neigh, hh);
1994         return -1;
1995 }
1996
1997 static void isdn_header_cache_update(struct hh_cache *hh,
1998                                      const struct net_device *dev,
1999                                      const unsigned char *haddr)
2000 {
2001         isdn_net_local *lp = netdev_priv(dev);
2002         if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
2003                 eth_header_cache_update(hh, dev, haddr);
2004 }
2005
2006 static const struct header_ops isdn_header_ops = {
2007         .create = isdn_net_header,
2008         .rebuild = isdn_net_rebuild_header,
2009         .cache = isdn_header_cache,
2010         .cache_update = isdn_header_cache_update,
2011 };
2012
2013 /*
2014  * Interface-setup. (just after registering a new interface)
2015  */
2016 static int
2017 isdn_net_init(struct net_device *ndev)
2018 {
2019         ushort max_hlhdr_len = 0;
2020         int drvidx;
2021
2022         /*
2023          *  up till binding we ask the protocol layer to reserve as much
2024          *  as we might need for HL layer
2025          */
2026
2027         for (drvidx = 0; drvidx < ISDN_MAX_DRIVERS; drvidx++)
2028                 if (dev->drv[drvidx])
2029                         if (max_hlhdr_len < dev->drv[drvidx]->interface->hl_hdrlen)
2030                                 max_hlhdr_len = dev->drv[drvidx]->interface->hl_hdrlen;
2031
2032         ndev->hard_header_len = ETH_HLEN + max_hlhdr_len;
2033         return 0;
2034 }
2035
2036 static void
2037 isdn_net_swapbind(int drvidx)
2038 {
2039         isdn_net_dev *p;
2040
2041 #ifdef ISDN_DEBUG_NET_ICALL
2042         printk(KERN_DEBUG "n_fi: swapping ch of %d\n", drvidx);
2043 #endif
2044         p = dev->netdev;
2045         while (p) {
2046                 if (p->local->pre_device == drvidx)
2047                         switch (p->local->pre_channel) {
2048                                 case 0:
2049                                         p->local->pre_channel = 1;
2050                                         break;
2051                                 case 1:
2052                                         p->local->pre_channel = 0;
2053                                         break;
2054                         }
2055                 p = (isdn_net_dev *) p->next;
2056         }
2057 }
2058
2059 static void
2060 isdn_net_swap_usage(int i1, int i2)
2061 {
2062         int u1 = dev->usage[i1] & ISDN_USAGE_EXCLUSIVE;
2063         int u2 = dev->usage[i2] & ISDN_USAGE_EXCLUSIVE;
2064
2065 #ifdef ISDN_DEBUG_NET_ICALL
2066         printk(KERN_DEBUG "n_fi: usage of %d and %d\n", i1, i2);
2067 #endif
2068         dev->usage[i1] &= ~ISDN_USAGE_EXCLUSIVE;
2069         dev->usage[i1] |= u2;
2070         dev->usage[i2] &= ~ISDN_USAGE_EXCLUSIVE;
2071         dev->usage[i2] |= u1;
2072         isdn_info_update();
2073 }
2074
2075 /*
2076  * An incoming call-request has arrived.
2077  * Search the interface-chain for an appropriate interface.
2078  * If found, connect the interface to the ISDN-channel and initiate
2079  * D- and B-Channel-setup. If secure-flag is set, accept only
2080  * configured phone-numbers. If callback-flag is set, initiate
2081  * callback-dialing.
2082  *
2083  * Return-Value: 0 = No appropriate interface for this call.
2084  *               1 = Call accepted
2085  *               2 = Reject call, wait cbdelay, then call back
2086  *               3 = Reject call
2087  *               4 = Wait cbdelay, then call back
2088  *               5 = No appropriate interface for this call,
2089  *                   would eventually match if CID was longer.
2090  */
2091
2092 int
2093 isdn_net_find_icall(int di, int ch, int idx, setup_parm *setup)
2094 {
2095         char *eaz;
2096         int si1;
2097         int si2;
2098         int ematch;
2099         int wret;
2100         int swapped;
2101         int sidx = 0;
2102         u_long flags;
2103         isdn_net_dev *p;
2104         isdn_net_phone *n;
2105         char nr[ISDN_MSNLEN];
2106         char *my_eaz;
2107
2108         /* Search name in netdev-chain */
2109         if (!setup->phone[0]) {
2110                 nr[0] = '0';
2111                 nr[1] = '\0';
2112                 printk(KERN_INFO "isdn_net: Incoming call without OAD, assuming '0'\n");
2113         } else
2114                 strlcpy(nr, setup->phone, ISDN_MSNLEN);
2115         si1 = (int) setup->si1;
2116         si2 = (int) setup->si2;
2117         if (!setup->eazmsn[0]) {
2118                 printk(KERN_WARNING "isdn_net: Incoming call without CPN, assuming '0'\n");
2119                 eaz = "0";
2120         } else
2121                 eaz = setup->eazmsn;
2122         if (dev->net_verbose > 1)
2123                 printk(KERN_INFO "isdn_net: call from %s,%d,%d -> %s\n", nr, si1, si2, eaz);
2124         /* Accept DATA and VOICE calls at this stage
2125          * local eaz is checked later for allowed call types
2126          */
2127         if ((si1 != 7) && (si1 != 1)) {
2128                 if (dev->net_verbose > 1)
2129                         printk(KERN_INFO "isdn_net: Service-Indicator not 1 or 7, ignored\n");
2130                 return 0;
2131         }
2132         n = (isdn_net_phone *) 0;
2133         p = dev->netdev;
2134         ematch = wret = swapped = 0;
2135 #ifdef ISDN_DEBUG_NET_ICALL
2136         printk(KERN_DEBUG "n_fi: di=%d ch=%d idx=%d usg=%d\n", di, ch, idx,
2137                 dev->usage[idx]);
2138 #endif
2139         while (p) {
2140                 int matchret;
2141                 isdn_net_local *lp = p->local;
2142
2143                 /* If last check has triggered as binding-swap, revert it */
2144                 switch (swapped) {
2145                         case 2:
2146                                 isdn_net_swap_usage(idx, sidx);
2147                                 /* fall through */
2148                         case 1:
2149                                 isdn_net_swapbind(di);
2150                                 break;
2151                 }
2152                 swapped = 0;
2153                 /* check acceptable call types for DOV */
2154                 my_eaz = isdn_map_eaz2msn(lp->msn, di);
2155                 if (si1 == 1) { /* it's a DOV call, check if we allow it */
2156                         if (*my_eaz == 'v' || *my_eaz == 'V' ||
2157                             *my_eaz == 'b' || *my_eaz == 'B')
2158                                 my_eaz++; /* skip to allow a match */
2159                         else
2160                                 my_eaz = NULL; /* force non match */
2161                 } else { /* it's a DATA call, check if we allow it */
2162                         if (*my_eaz == 'b' || *my_eaz == 'B')
2163                                 my_eaz++; /* skip to allow a match */
2164                 }
2165                 if (my_eaz)
2166                         matchret = isdn_msncmp(eaz, my_eaz);
2167                 else
2168                         matchret = 1;
2169                 if (!matchret)
2170                         ematch = 1;
2171
2172                 /* Remember if more numbers eventually can match */
2173                 if (matchret > wret)
2174                         wret = matchret;
2175 #ifdef ISDN_DEBUG_NET_ICALL
2176                 printk(KERN_DEBUG "n_fi: if='%s', l.msn=%s, l.flags=%d, l.dstate=%d\n",
2177                        p->dev->name, lp->msn, lp->flags, lp->dialstate);
2178 #endif
2179                 if ((!matchret) &&                                        /* EAZ is matching   */
2180                     (((!(lp->flags & ISDN_NET_CONNECTED)) &&              /* but not connected */
2181                       (USG_NONE(dev->usage[idx]))) ||                     /* and ch. unused or */
2182                      ((((lp->dialstate == 4) || (lp->dialstate == 12)) && /* if dialing        */
2183                        (!(lp->flags & ISDN_NET_CALLBACK)))                /* but no callback   */
2184                      )))
2185                          {
2186 #ifdef ISDN_DEBUG_NET_ICALL
2187                         printk(KERN_DEBUG "n_fi: match1, pdev=%d pch=%d\n",
2188                                lp->pre_device, lp->pre_channel);
2189 #endif
2190                         if (dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) {
2191                                 if ((lp->pre_channel != ch) ||
2192                                     (lp->pre_device != di)) {
2193                                         /* Here we got a problem:
2194                                          * If using an ICN-Card, an incoming call is always signaled on
2195                                          * on the first channel of the card, if both channels are
2196                                          * down. However this channel may be bound exclusive. If the
2197                                          * second channel is free, this call should be accepted.
2198                                          * The solution is horribly but it runs, so what:
2199                                          * We exchange the exclusive bindings of the two channels, the
2200                                          * corresponding variables in the interface-structs.
2201                                          */
2202                                         if (ch == 0) {
2203                                                 sidx = isdn_dc2minor(di, 1);
2204 #ifdef ISDN_DEBUG_NET_ICALL
2205                                                 printk(KERN_DEBUG "n_fi: ch is 0\n");
2206 #endif
2207                                                 if (USG_NONE(dev->usage[sidx])) {
2208                                                         /* Second Channel is free, now see if it is bound
2209                                                          * exclusive too. */
2210                                                         if (dev->usage[sidx] & ISDN_USAGE_EXCLUSIVE) {
2211 #ifdef ISDN_DEBUG_NET_ICALL
2212                                                                 printk(KERN_DEBUG "n_fi: 2nd channel is down and bound\n");
2213 #endif
2214                                                                 /* Yes, swap bindings only, if the original
2215                                                                  * binding is bound to channel 1 of this driver */
2216                                                                 if ((lp->pre_device == di) &&
2217                                                                     (lp->pre_channel == 1)) {
2218                                                                         isdn_net_swapbind(di);
2219                                                                         swapped = 1;
2220                                                                 } else {
2221                                                                         /* ... else iterate next device */
2222                                                                         p = (isdn_net_dev *) p->next;
2223                                                                         continue;
2224                                                                 }
2225                                                         } else {
2226 #ifdef ISDN_DEBUG_NET_ICALL
2227                                                                 printk(KERN_DEBUG "n_fi: 2nd channel is down and unbound\n");
2228 #endif
2229                                                                 /* No, swap always and swap excl-usage also */
2230                                                                 isdn_net_swap_usage(idx, sidx);
2231                                                                 isdn_net_swapbind(di);
2232                                                                 swapped = 2;
2233                                                         }
2234                                                         /* Now check for exclusive binding again */
2235 #ifdef ISDN_DEBUG_NET_ICALL
2236                                                         printk(KERN_DEBUG "n_fi: final check\n");
2237 #endif
2238                                                         if ((dev->usage[idx] & ISDN_USAGE_EXCLUSIVE) &&
2239                                                             ((lp->pre_channel != ch) ||
2240                                                              (lp->pre_device != di))) {
2241 #ifdef ISDN_DEBUG_NET_ICALL
2242                                                                 printk(KERN_DEBUG "n_fi: final check failed\n");
2243 #endif
2244                                                                 p = (isdn_net_dev *) p->next;
2245                                                                 continue;
2246                                                         }
2247                                                 }
2248                                         } else {
2249                                                 /* We are already on the second channel, so nothing to do */
2250 #ifdef ISDN_DEBUG_NET_ICALL
2251                                                 printk(KERN_DEBUG "n_fi: already on 2nd channel\n");
2252 #endif
2253                                         }
2254                                 }
2255                         }
2256 #ifdef ISDN_DEBUG_NET_ICALL
2257                         printk(KERN_DEBUG "n_fi: match2\n");
2258 #endif
2259                         n = lp->phone[0];
2260                         if (lp->flags & ISDN_NET_SECURE) {
2261                                 while (n) {
2262                                         if (!isdn_msncmp(nr, n->num))
2263                                                 break;
2264                                         n = (isdn_net_phone *) n->next;
2265                                 }
2266                         }
2267                         if (n || (!(lp->flags & ISDN_NET_SECURE))) {
2268 #ifdef ISDN_DEBUG_NET_ICALL
2269                                 printk(KERN_DEBUG "n_fi: match3\n");
2270 #endif
2271                                 /* matching interface found */
2272
2273                                 /*
2274                                  * Is the state STOPPED?
2275                                  * If so, no dialin is allowed,
2276                                  * so reject actively.
2277                                  * */
2278                                 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2279                                         printk(KERN_INFO "incoming call, interface %s `stopped' -> rejected\n",
2280                                                p->dev->name);
2281                                         return 3;
2282                                 }
2283                                 /*
2284                                  * Is the interface up?
2285                                  * If not, reject the call actively.
2286                                  */
2287                                 if (!isdn_net_device_started(p)) {
2288                                         printk(KERN_INFO "%s: incoming call, interface down -> rejected\n",
2289                                                p->dev->name);
2290                                         return 3;
2291                                 }
2292                                 /* Interface is up, now see if it's a slave. If so, see if
2293                                  * it's master and parent slave is online. If not, reject the call.
2294                                  */
2295                                 if (lp->master) {
2296                                         isdn_net_local *mlp = ISDN_MASTER_PRIV(lp);
2297                                         printk(KERN_DEBUG "ICALLslv: %s\n", p->dev->name);
2298                                         printk(KERN_DEBUG "master=%s\n", lp->master->name);
2299                                         if (mlp->flags & ISDN_NET_CONNECTED) {
2300                                                 printk(KERN_DEBUG "master online\n");
2301                                                 /* Master is online, find parent-slave (master if first slave) */
2302                                                 while (mlp->slave) {
2303                                                         if (ISDN_SLAVE_PRIV(mlp) == lp)
2304                                                                 break;
2305                                                         mlp = ISDN_SLAVE_PRIV(mlp);
2306                                                 }
2307                                         } else
2308                                                 printk(KERN_DEBUG "master offline\n");
2309                                         /* Found parent, if it's offline iterate next device */
2310                                         printk(KERN_DEBUG "mlpf: %d\n", mlp->flags & ISDN_NET_CONNECTED);
2311                                         if (!(mlp->flags & ISDN_NET_CONNECTED)) {
2312                                                 p = (isdn_net_dev *) p->next;
2313                                                 continue;
2314                                         }
2315                                 }
2316                                 if (lp->flags & ISDN_NET_CALLBACK) {
2317                                         int chi;
2318                                         /*
2319                                          * Is the state MANUAL?
2320                                          * If so, no callback can be made,
2321                                          * so reject actively.
2322                                          * */
2323                                         if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2324                                                 printk(KERN_INFO "incoming call for callback, interface %s `off' -> rejected\n",
2325                                                        p->dev->name);
2326                                                 return 3;
2327                                         }
2328                                         printk(KERN_DEBUG "%s: call from %s -> %s, start callback\n",
2329                                                p->dev->name, nr, eaz);
2330                                         if (lp->phone[1]) {
2331                                                 /* Grab a free ISDN-Channel */
2332                                                 spin_lock_irqsave(&dev->lock, flags);
2333                                                 if ((chi =
2334                                                         isdn_get_free_channel(
2335                                                                 ISDN_USAGE_NET,
2336                                                                 lp->l2_proto,
2337                                                                 lp->l3_proto,
2338                                                                 lp->pre_device,
2339                                                                 lp->pre_channel,
2340                                                                 lp->msn)
2341                                                                 ) < 0) {
2342
2343                                                         printk(KERN_WARNING "isdn_net_find_icall: No channel for %s\n",
2344                                                                 p->dev->name);
2345                                                         spin_unlock_irqrestore(&dev->lock, flags);
2346                                                         return 0;
2347                                                 }
2348                                                 /* Setup dialstate. */
2349                                                 lp->dtimer = 0;
2350                                                 lp->dialstate = 11;
2351                                                 /* Connect interface with channel */
2352                                                 isdn_net_bind_channel(lp, chi);
2353 #ifdef CONFIG_ISDN_PPP
2354                                                 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2355                                                         if (isdn_ppp_bind(lp) < 0) {
2356                                                                 spin_unlock_irqrestore(&dev->lock, flags);
2357                                                                 isdn_net_unbind_channel(lp);
2358                                                                 return 0;
2359                                                         }
2360 #endif
2361                                                 spin_unlock_irqrestore(&dev->lock, flags);
2362                                                 /* Initiate dialing by returning 2 or 4 */
2363                                                 return (lp->flags & ISDN_NET_CBHUP) ? 2 : 4;
2364                                         } else
2365                                                 printk(KERN_WARNING "isdn_net: %s: No phone number\n",
2366                                                         p->dev->name);
2367                                         return 0;
2368                                 } else {
2369                                         printk(KERN_DEBUG "%s: call from %s -> %s accepted\n",
2370                                                 p->dev->name, nr, eaz);
2371                                         /* if this interface is dialing, it does it probably on a different
2372                                            device, so free this device */
2373                                         if ((lp->dialstate == 4) || (lp->dialstate == 12)) {
2374 #ifdef CONFIG_ISDN_PPP
2375                                                 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2376                                                         isdn_ppp_free(lp);
2377 #endif
2378                                                 isdn_net_lp_disconnected(lp);
2379                                                 isdn_free_channel(lp->isdn_device, lp->isdn_channel,
2380                                                          ISDN_USAGE_NET);
2381                                         }
2382                                         spin_lock_irqsave(&dev->lock, flags);
2383                                         dev->usage[idx] &= ISDN_USAGE_EXCLUSIVE;
2384                                         dev->usage[idx] |= ISDN_USAGE_NET;
2385                                         strcpy(dev->num[idx], nr);
2386                                         isdn_info_update();
2387                                         dev->st_netdev[idx] = lp->netdev;
2388                                         lp->isdn_device = di;
2389                                         lp->isdn_channel = ch;
2390                                         lp->ppp_slot = -1;
2391                                         lp->flags |= ISDN_NET_CONNECTED;
2392                                         lp->dialstate = 7;
2393                                         lp->dtimer = 0;
2394                                         lp->outgoing = 0;
2395                                         lp->huptimer = 0;
2396                                         lp->hupflags |= ISDN_WAITCHARGE;
2397                                         lp->hupflags &= ~ISDN_HAVECHARGE;
2398 #ifdef CONFIG_ISDN_PPP
2399                                         if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
2400                                                 if (isdn_ppp_bind(lp) < 0) {
2401                                                         isdn_net_unbind_channel(lp);
2402                                                         spin_unlock_irqrestore(&dev->lock, flags);
2403                                                         return 0;
2404                                                 }
2405                                         }
2406 #endif
2407                                         spin_unlock_irqrestore(&dev->lock, flags);
2408                                         return 1;
2409                                 }
2410                         }
2411                 }
2412                 p = (isdn_net_dev *) p->next;
2413         }
2414         /* If none of configured EAZ/MSN matched and not verbose, be silent */
2415         if (!ematch || dev->net_verbose)
2416                 printk(KERN_INFO "isdn_net: call from %s -> %d %s ignored\n", nr, di, eaz);
2417         return (wret == 2)?5:0;
2418 }
2419
2420 /*
2421  * Search list of net-interfaces for an interface with given name.
2422  */
2423 isdn_net_dev *
2424 isdn_net_findif(char *name)
2425 {
2426         isdn_net_dev *p = dev->netdev;
2427
2428         while (p) {
2429                 if (!strcmp(p->dev->name, name))
2430                         return p;
2431                 p = (isdn_net_dev *) p->next;
2432         }
2433         return (isdn_net_dev *) NULL;
2434 }
2435
2436 /*
2437  * Force a net-interface to dial out.
2438  * This is called from the userlevel-routine below or
2439  * from isdn_net_start_xmit().
2440  */
2441 static int
2442 isdn_net_force_dial_lp(isdn_net_local * lp)
2443 {
2444         if ((!(lp->flags & ISDN_NET_CONNECTED)) && !lp->dialstate) {
2445                 int chi;
2446                 if (lp->phone[1]) {
2447                         ulong flags;
2448
2449                         /* Grab a free ISDN-Channel */
2450                         spin_lock_irqsave(&dev->lock, flags);
2451                         if ((chi = isdn_get_free_channel(
2452                                         ISDN_USAGE_NET,
2453                                         lp->l2_proto,
2454                                         lp->l3_proto,
2455                                         lp->pre_device,
2456                                         lp->pre_channel,
2457                                         lp->msn)) < 0) {
2458                                 printk(KERN_WARNING "isdn_net_force_dial: No channel for %s\n",
2459                                         lp->netdev->dev->name);
2460                                 spin_unlock_irqrestore(&dev->lock, flags);
2461                                 return -EAGAIN;
2462                         }
2463                         lp->dialstate = 1;
2464                         /* Connect interface with channel */
2465                         isdn_net_bind_channel(lp, chi);
2466 #ifdef CONFIG_ISDN_PPP
2467                         if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2468                                 if (isdn_ppp_bind(lp) < 0) {
2469                                         isdn_net_unbind_channel(lp);
2470                                         spin_unlock_irqrestore(&dev->lock, flags);
2471                                         return -EAGAIN;
2472                                 }
2473 #endif
2474                         /* Initiate dialing */
2475                         spin_unlock_irqrestore(&dev->lock, flags);
2476                         isdn_net_dial();
2477                         return 0;
2478                 } else
2479                         return -EINVAL;
2480         } else
2481                 return -EBUSY;
2482 }
2483
2484 /*
2485  * This is called from certain upper protocol layers (multilink ppp
2486  * and x25iface encapsulation module) that want to initiate dialing
2487  * themselves.
2488  */
2489 int
2490 isdn_net_dial_req(isdn_net_local * lp)
2491 {
2492         /* is there a better error code? */
2493         if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) return -EBUSY;
2494
2495         return isdn_net_force_dial_lp(lp);
2496 }
2497
2498 /*
2499  * Force a net-interface to dial out.
2500  * This is always called from within userspace (ISDN_IOCTL_NET_DIAL).
2501  */
2502 int
2503 isdn_net_force_dial(char *name)
2504 {
2505         isdn_net_dev *p = isdn_net_findif(name);
2506
2507         if (!p)
2508                 return -ENODEV;
2509         return (isdn_net_force_dial_lp(p->local));
2510 }
2511
2512 /* The ISDN-specific entries in the device structure. */
2513 static const struct net_device_ops isdn_netdev_ops = {
2514         .ndo_init             = isdn_net_init,
2515         .ndo_open             = isdn_net_open,
2516         .ndo_stop             = isdn_net_close,
2517         .ndo_do_ioctl         = isdn_net_ioctl,
2518
2519         .ndo_start_xmit       = isdn_net_start_xmit,
2520         .ndo_get_stats        = isdn_net_get_stats,
2521         .ndo_tx_timeout       = isdn_net_tx_timeout,
2522 };
2523
2524 /*
2525  * Helper for alloc_netdev()
2526  */
2527 static void _isdn_setup(struct net_device *dev)
2528 {
2529         isdn_net_local *lp = netdev_priv(dev);
2530
2531         ether_setup(dev);
2532
2533         /* Setup the generic properties */
2534         dev->flags = IFF_NOARP|IFF_POINTOPOINT;
2535         dev->header_ops = NULL;
2536         dev->netdev_ops = &isdn_netdev_ops;
2537
2538         /* for clients with MPPP maybe higher values better */
2539         dev->tx_queue_len = 30;
2540
2541         lp->p_encap = ISDN_NET_ENCAP_RAWIP;
2542         lp->magic = ISDN_NET_MAGIC;
2543         lp->last = lp;
2544         lp->next = lp;
2545         lp->isdn_device = -1;
2546         lp->isdn_channel = -1;
2547         lp->pre_device = -1;
2548         lp->pre_channel = -1;
2549         lp->exclusive = -1;
2550         lp->ppp_slot = -1;
2551         lp->pppbind = -1;
2552         skb_queue_head_init(&lp->super_tx_queue);
2553         lp->l2_proto = ISDN_PROTO_L2_X75I;
2554         lp->l3_proto = ISDN_PROTO_L3_TRANS;
2555         lp->triggercps = 6000;
2556         lp->slavedelay = 10 * HZ;
2557         lp->hupflags = ISDN_INHUP;      /* Do hangup even on incoming calls */
2558         lp->onhtime = 10;       /* Default hangup-time for saving costs */
2559         lp->dialmax = 1;
2560         /* Hangup before Callback, manual dial */
2561         lp->flags = ISDN_NET_CBHUP | ISDN_NET_DM_MANUAL;
2562         lp->cbdelay = 25;       /* Wait 5 secs before Callback */
2563         lp->dialtimeout = -1;  /* Infinite Dial-Timeout */
2564         lp->dialwait = 5 * HZ; /* Wait 5 sec. after failed dial */
2565         lp->dialstarted = 0;   /* Jiffies of last dial-start */
2566         lp->dialwait_timer = 0;  /* Jiffies of earliest next dial-start */
2567 }
2568
2569 /*
2570  * Allocate a new network-interface and initialize its data structures.
2571  */
2572 char *
2573 isdn_net_new(char *name, struct net_device *master)
2574 {
2575         isdn_net_dev *netdev;
2576
2577         /* Avoid creating an existing interface */
2578         if (isdn_net_findif(name)) {
2579                 printk(KERN_WARNING "isdn_net: interface %s already exists\n", name);
2580                 return NULL;
2581         }
2582         if (name == NULL)
2583                 return NULL;
2584         if (!(netdev = kzalloc(sizeof(isdn_net_dev), GFP_KERNEL))) {
2585                 printk(KERN_WARNING "isdn_net: Could not allocate net-device\n");
2586                 return NULL;
2587         }
2588         netdev->dev = alloc_netdev(sizeof(isdn_net_local), name, _isdn_setup);
2589         if (!netdev->dev) {
2590                 printk(KERN_WARNING "isdn_net: Could not allocate network device\n");
2591                 kfree(netdev);
2592                 return NULL;
2593         }
2594         netdev->local = netdev_priv(netdev->dev);
2595
2596         if (master) {
2597                 /* Device shall be a slave */
2598                 struct net_device *p = MASTER_TO_SLAVE(master);
2599                 struct net_device *q = master;
2600
2601                 netdev->local->master = master;
2602                 /* Put device at end of slave-chain */
2603                 while (p) {
2604                         q = p;
2605                         p = MASTER_TO_SLAVE(p);
2606                 }
2607                 MASTER_TO_SLAVE(q) = netdev->dev;
2608         } else {
2609                 /* Device shall be a master */
2610                 /*
2611                  * Watchdog timer (currently) for master only.
2612                  */
2613                 netdev->dev->watchdog_timeo = ISDN_NET_TX_TIMEOUT;
2614                 if (register_netdev(netdev->dev) != 0) {
2615                         printk(KERN_WARNING "isdn_net: Could not register net-device\n");
2616                         free_netdev(netdev->dev);
2617                         kfree(netdev);
2618                         return NULL;
2619                 }
2620         }
2621         netdev->queue = netdev->local;
2622         spin_lock_init(&netdev->queue_lock);
2623
2624         netdev->local->netdev = netdev;
2625
2626         INIT_WORK(&netdev->local->tqueue, isdn_net_softint);
2627         spin_lock_init(&netdev->local->xmit_lock);
2628
2629         /* Put into to netdev-chain */
2630         netdev->next = (void *) dev->netdev;
2631         dev->netdev = netdev;
2632         return netdev->dev->name;
2633 }
2634
2635 char *
2636 isdn_net_newslave(char *parm)
2637 {
2638         char *p = strchr(parm, ',');
2639         isdn_net_dev *n;
2640         char newname[10];
2641
2642         if (p) {
2643                 /* Slave-Name MUST not be empty */
2644                 if (!strlen(p + 1))
2645                         return NULL;
2646                 strcpy(newname, p + 1);
2647                 *p = 0;
2648                 /* Master must already exist */
2649                 if (!(n = isdn_net_findif(parm)))
2650                         return NULL;
2651                 /* Master must be a real interface, not a slave */
2652                 if (n->local->master)
2653                         return NULL;
2654                 /* Master must not be started yet */
2655                 if (isdn_net_device_started(n))
2656                         return NULL;
2657                 return (isdn_net_new(newname, n->dev));
2658         }
2659         return NULL;
2660 }
2661
2662 /*
2663  * Set interface-parameters.
2664  * Always set all parameters, so the user-level application is responsible
2665  * for not overwriting existing setups. It has to get the current
2666  * setup first, if only selected parameters are to be changed.
2667  */
2668 int
2669 isdn_net_setcfg(isdn_net_ioctl_cfg * cfg)
2670 {
2671         isdn_net_dev *p = isdn_net_findif(cfg->name);
2672         ulong features;
2673         int i;
2674         int drvidx;
2675         int chidx;
2676         char drvid[25];
2677
2678         if (p) {
2679                 isdn_net_local *lp = p->local;
2680
2681                 /* See if any registered driver supports the features we want */
2682                 features = ((1 << cfg->l2_proto) << ISDN_FEATURE_L2_SHIFT) |
2683                         ((1 << cfg->l3_proto) << ISDN_FEATURE_L3_SHIFT);
2684                 for (i = 0; i < ISDN_MAX_DRIVERS; i++)
2685                         if (dev->drv[i])
2686                                 if ((dev->drv[i]->interface->features & features) == features)
2687                                         break;
2688                 if (i == ISDN_MAX_DRIVERS) {
2689                         printk(KERN_WARNING "isdn_net: No driver with selected features\n");
2690                         return -ENODEV;
2691                 }
2692                 if (lp->p_encap != cfg->p_encap){
2693 #ifdef CONFIG_ISDN_X25
2694                         struct concap_proto * cprot = p -> cprot;
2695 #endif
2696                         if (isdn_net_device_started(p)) {
2697                                 printk(KERN_WARNING "%s: cannot change encap when if is up\n",
2698                                        p->dev->name);
2699                                 return -EBUSY;
2700                         }
2701 #ifdef CONFIG_ISDN_X25
2702                         if( cprot && cprot -> pops )
2703                                 cprot -> pops -> proto_del ( cprot );
2704                         p -> cprot = NULL;
2705                         lp -> dops = NULL;
2706                         /* ... ,  prepare for configuration of new one ... */
2707                         switch ( cfg -> p_encap ){
2708                         case ISDN_NET_ENCAP_X25IFACE:
2709                                 lp -> dops = &isdn_concap_reliable_dl_dops;
2710                         }
2711                         /* ... and allocate new one ... */
2712                         p -> cprot = isdn_concap_new( cfg -> p_encap );
2713                         /* p -> cprot == NULL now if p_encap is not supported
2714                            by means of the concap_proto mechanism */
2715                         /* the protocol is not configured yet; this will
2716                            happen later when isdn_net_reset() is called */
2717 #endif
2718                 }
2719                 switch ( cfg->p_encap ) {
2720                 case ISDN_NET_ENCAP_SYNCPPP:
2721 #ifndef CONFIG_ISDN_PPP
2722                         printk(KERN_WARNING "%s: SyncPPP support not configured\n",
2723                                p->dev->name);
2724                         return -EINVAL;
2725 #else
2726                         p->dev->type = ARPHRD_PPP;      /* change ARP type */
2727                         p->dev->addr_len = 0;
2728 #endif
2729                         break;
2730                 case ISDN_NET_ENCAP_X25IFACE:
2731 #ifndef CONFIG_ISDN_X25
2732                         printk(KERN_WARNING "%s: isdn-x25 support not configured\n",
2733                                p->dev->name);
2734                         return -EINVAL;
2735 #else
2736                         p->dev->type = ARPHRD_X25;      /* change ARP type */
2737                         p->dev->addr_len = 0;
2738 #endif
2739                         break;
2740                 case ISDN_NET_ENCAP_CISCOHDLCK:
2741                         break;
2742                 default:
2743                         if( cfg->p_encap >= 0 &&
2744                             cfg->p_encap <= ISDN_NET_ENCAP_MAX_ENCAP )
2745                                 break;
2746                         printk(KERN_WARNING
2747                                "%s: encapsulation protocol %d not supported\n",
2748                                p->dev->name, cfg->p_encap);
2749                         return -EINVAL;
2750                 }
2751                 if (strlen(cfg->drvid)) {
2752                         /* A bind has been requested ... */
2753                         char *c,
2754                         *e;
2755
2756                         drvidx = -1;
2757                         chidx = -1;
2758                         strcpy(drvid, cfg->drvid);
2759                         if ((c = strchr(drvid, ','))) {
2760                                 /* The channel-number is appended to the driver-Id with a comma */
2761                                 chidx = (int) simple_strtoul(c + 1, &e, 10);
2762                                 if (e == c)
2763                                         chidx = -1;
2764                                 *c = '\0';
2765                         }
2766                         for (i = 0; i < ISDN_MAX_DRIVERS; i++)
2767                                 /* Lookup driver-Id in array */
2768                                 if (!(strcmp(dev->drvid[i], drvid))) {
2769                                         drvidx = i;
2770                                         break;
2771                                 }
2772                         if ((drvidx == -1) || (chidx == -1))
2773                                 /* Either driver-Id or channel-number invalid */
2774                                 return -ENODEV;
2775                 } else {
2776                         /* Parameters are valid, so get them */
2777                         drvidx = lp->pre_device;
2778                         chidx = lp->pre_channel;
2779                 }
2780                 if (cfg->exclusive > 0) {
2781                         unsigned long flags;
2782
2783                         /* If binding is exclusive, try to grab the channel */
2784                         spin_lock_irqsave(&dev->lock, flags);
2785                         if ((i = isdn_get_free_channel(ISDN_USAGE_NET,
2786                                 lp->l2_proto, lp->l3_proto, drvidx,
2787                                 chidx, lp->msn)) < 0) {
2788                                 /* Grab failed, because desired channel is in use */
2789                                 lp->exclusive = -1;
2790                                 spin_unlock_irqrestore(&dev->lock, flags);
2791                                 return -EBUSY;
2792                         }
2793                         /* All went ok, so update isdninfo */
2794                         dev->usage[i] = ISDN_USAGE_EXCLUSIVE;
2795                         isdn_info_update();
2796                         spin_unlock_irqrestore(&dev->lock, flags);
2797                         lp->exclusive = i;
2798                 } else {
2799                         /* Non-exclusive binding or unbind. */
2800                         lp->exclusive = -1;
2801                         if ((lp->pre_device != -1) && (cfg->exclusive == -1)) {
2802                                 isdn_unexclusive_channel(lp->pre_device, lp->pre_channel);
2803                                 isdn_free_channel(lp->pre_device, lp->pre_channel, ISDN_USAGE_NET);
2804                                 drvidx = -1;
2805                                 chidx = -1;
2806                         }
2807                 }
2808                 strlcpy(lp->msn, cfg->eaz, sizeof(lp->msn));
2809                 lp->pre_device = drvidx;
2810                 lp->pre_channel = chidx;
2811                 lp->onhtime = cfg->onhtime;
2812                 lp->charge = cfg->charge;
2813                 lp->l2_proto = cfg->l2_proto;
2814                 lp->l3_proto = cfg->l3_proto;
2815                 lp->cbdelay = cfg->cbdelay;
2816                 lp->dialmax = cfg->dialmax;
2817                 lp->triggercps = cfg->triggercps;
2818                 lp->slavedelay = cfg->slavedelay * HZ;
2819                 lp->pppbind = cfg->pppbind;
2820                 lp->dialtimeout = cfg->dialtimeout >= 0 ? cfg->dialtimeout * HZ : -1;
2821                 lp->dialwait = cfg->dialwait * HZ;
2822                 if (cfg->secure)
2823                         lp->flags |= ISDN_NET_SECURE;
2824                 else
2825                         lp->flags &= ~ISDN_NET_SECURE;
2826                 if (cfg->cbhup)
2827                         lp->flags |= ISDN_NET_CBHUP;
2828                 else
2829                         lp->flags &= ~ISDN_NET_CBHUP;
2830                 switch (cfg->callback) {
2831                         case 0:
2832                                 lp->flags &= ~(ISDN_NET_CALLBACK | ISDN_NET_CBOUT);
2833                                 break;
2834                         case 1:
2835                                 lp->flags |= ISDN_NET_CALLBACK;
2836                                 lp->flags &= ~ISDN_NET_CBOUT;
2837                                 break;
2838                         case 2:
2839                                 lp->flags |= ISDN_NET_CBOUT;
2840                                 lp->flags &= ~ISDN_NET_CALLBACK;
2841                                 break;
2842                 }
2843                 lp->flags &= ~ISDN_NET_DIALMODE_MASK;   /* first all bits off */
2844                 if (cfg->dialmode && !(cfg->dialmode & ISDN_NET_DIALMODE_MASK)) {
2845                         /* old isdnctrl version, where only 0 or 1 is given */
2846                         printk(KERN_WARNING
2847                              "Old isdnctrl version detected! Please update.\n");
2848                         lp->flags |= ISDN_NET_DM_OFF; /* turn on `off' bit */
2849                 }
2850                 else {
2851                         lp->flags |= cfg->dialmode;  /* turn on selected bits */
2852                 }
2853                 if (cfg->chargehup)
2854                         lp->hupflags |= ISDN_CHARGEHUP;
2855                 else
2856                         lp->hupflags &= ~ISDN_CHARGEHUP;
2857                 if (cfg->ihup)
2858                         lp->hupflags |= ISDN_INHUP;
2859                 else
2860                         lp->hupflags &= ~ISDN_INHUP;
2861                 if (cfg->chargeint > 10) {
2862                         lp->hupflags |= ISDN_CHARGEHUP | ISDN_HAVECHARGE | ISDN_MANCHARGE;
2863                         lp->chargeint = cfg->chargeint * HZ;
2864                 }
2865                 if (cfg->p_encap != lp->p_encap) {
2866                         if (cfg->p_encap == ISDN_NET_ENCAP_RAWIP) {
2867                                 p->dev->header_ops = NULL;
2868                                 p->dev->flags = IFF_NOARP|IFF_POINTOPOINT;
2869                         } else {
2870                                 p->dev->header_ops = &isdn_header_ops;
2871                                 if (cfg->p_encap == ISDN_NET_ENCAP_ETHER)
2872                                         p->dev->flags = IFF_BROADCAST | IFF_MULTICAST;
2873                                 else
2874                                         p->dev->flags = IFF_NOARP|IFF_POINTOPOINT;
2875                         }
2876                 }
2877                 lp->p_encap = cfg->p_encap;
2878                 return 0;
2879         }
2880         return -ENODEV;
2881 }
2882
2883 /*
2884  * Perform get-interface-parameters.ioctl
2885  */
2886 int
2887 isdn_net_getcfg(isdn_net_ioctl_cfg * cfg)
2888 {
2889         isdn_net_dev *p = isdn_net_findif(cfg->name);
2890
2891         if (p) {
2892                 isdn_net_local *lp = p->local;
2893
2894                 strcpy(cfg->eaz, lp->msn);
2895                 cfg->exclusive = lp->exclusive;
2896                 if (lp->pre_device >= 0) {
2897                         sprintf(cfg->drvid, "%s,%d", dev->drvid[lp->pre_device],
2898                                 lp->pre_channel);
2899                 } else
2900                         cfg->drvid[0] = '\0';
2901                 cfg->onhtime = lp->onhtime;
2902                 cfg->charge = lp->charge;
2903                 cfg->l2_proto = lp->l2_proto;
2904                 cfg->l3_proto = lp->l3_proto;
2905                 cfg->p_encap = lp->p_encap;
2906                 cfg->secure = (lp->flags & ISDN_NET_SECURE) ? 1 : 0;
2907                 cfg->callback = 0;
2908                 if (lp->flags & ISDN_NET_CALLBACK)
2909                         cfg->callback = 1;
2910                 if (lp->flags & ISDN_NET_CBOUT)
2911                         cfg->callback = 2;
2912                 cfg->cbhup = (lp->flags & ISDN_NET_CBHUP) ? 1 : 0;
2913                 cfg->dialmode = lp->flags & ISDN_NET_DIALMODE_MASK;
2914                 cfg->chargehup = (lp->hupflags & 4) ? 1 : 0;
2915                 cfg->ihup = (lp->hupflags & 8) ? 1 : 0;
2916                 cfg->cbdelay = lp->cbdelay;
2917                 cfg->dialmax = lp->dialmax;
2918                 cfg->triggercps = lp->triggercps;
2919                 cfg->slavedelay = lp->slavedelay / HZ;
2920                 cfg->chargeint = (lp->hupflags & ISDN_CHARGEHUP) ?
2921                     (lp->chargeint / HZ) : 0;
2922                 cfg->pppbind = lp->pppbind;
2923                 cfg->dialtimeout = lp->dialtimeout >= 0 ? lp->dialtimeout / HZ : -1;
2924                 cfg->dialwait = lp->dialwait / HZ;
2925                 if (lp->slave) {
2926                         if (strlen(lp->slave->name) > 8)
2927                                 strcpy(cfg->slave, "too-long");
2928                         else
2929                                 strcpy(cfg->slave, lp->slave->name);
2930                 } else
2931                         cfg->slave[0] = '\0';
2932                 if (lp->master) {
2933                         if (strlen(lp->master->name) > 8)
2934                                 strcpy(cfg->master, "too-long");
2935                         strcpy(cfg->master, lp->master->name);
2936                 } else
2937                         cfg->master[0] = '\0';
2938                 return 0;
2939         }
2940         return -ENODEV;
2941 }
2942
2943 /*
2944  * Add a phone-number to an interface.
2945  */
2946 int
2947 isdn_net_addphone(isdn_net_ioctl_phone * phone)
2948 {
2949         isdn_net_dev *p = isdn_net_findif(phone->name);
2950         isdn_net_phone *n;
2951
2952         if (p) {
2953                 if (!(n = kmalloc(sizeof(isdn_net_phone), GFP_KERNEL)))
2954                         return -ENOMEM;
2955                 strlcpy(n->num, phone->phone, sizeof(n->num));
2956                 n->next = p->local->phone[phone->outgoing & 1];
2957                 p->local->phone[phone->outgoing & 1] = n;
2958                 return 0;
2959         }
2960         return -ENODEV;
2961 }
2962
2963 /*
2964  * Copy a string of all phone-numbers of an interface to user space.
2965  * This might sleep and must be called with the isdn semaphore down.
2966  */
2967 int
2968 isdn_net_getphones(isdn_net_ioctl_phone * phone, char __user *phones)
2969 {
2970         isdn_net_dev *p = isdn_net_findif(phone->name);
2971         int inout = phone->outgoing & 1;
2972         int more = 0;
2973         int count = 0;
2974         isdn_net_phone *n;
2975
2976         if (!p)
2977                 return -ENODEV;
2978         inout &= 1;
2979         for (n = p->local->phone[inout]; n; n = n->next) {
2980                 if (more) {
2981                         put_user(' ', phones++);
2982                         count++;
2983                 }
2984                 if (copy_to_user(phones, n->num, strlen(n->num) + 1)) {
2985                         return -EFAULT;
2986                 }
2987                 phones += strlen(n->num);
2988                 count += strlen(n->num);
2989                 more = 1;
2990         }
2991         put_user(0, phones);
2992         count++;
2993         return count;
2994 }
2995
2996 /*
2997  * Copy a string containing the peer's phone number of a connected interface
2998  * to user space.
2999  */
3000 int
3001 isdn_net_getpeer(isdn_net_ioctl_phone *phone, isdn_net_ioctl_phone __user *peer)
3002 {
3003         isdn_net_dev *p = isdn_net_findif(phone->name);
3004         int ch, dv, idx;
3005
3006         if (!p)
3007                 return -ENODEV;
3008         /*
3009          * Theoretical race: while this executes, the remote number might
3010          * become invalid (hang up) or change (new connection), resulting
3011          * in (partially) wrong number copied to user. This race
3012          * currently ignored.
3013          */
3014         ch = p->local->isdn_channel;
3015         dv = p->local->isdn_device;
3016         if(ch < 0 && dv < 0)
3017                 return -ENOTCONN;
3018         idx = isdn_dc2minor(dv, ch);
3019         if (idx <0 )
3020                 return -ENODEV;
3021         /* for pre-bound channels, we need this extra check */
3022         if (strncmp(dev->num[idx], "???", 3) == 0)
3023                 return -ENOTCONN;
3024         strncpy(phone->phone, dev->num[idx], ISDN_MSNLEN);
3025         phone->outgoing = USG_OUTGOING(dev->usage[idx]);
3026         if (copy_to_user(peer, phone, sizeof(*peer)))
3027                 return -EFAULT;
3028         return 0;
3029 }
3030 /*
3031  * Delete a phone-number from an interface.
3032  */
3033 int
3034 isdn_net_delphone(isdn_net_ioctl_phone * phone)
3035 {
3036         isdn_net_dev *p = isdn_net_findif(phone->name);
3037         int inout = phone->outgoing & 1;
3038         isdn_net_phone *n;
3039         isdn_net_phone *m;
3040
3041         if (p) {
3042                 n = p->local->phone[inout];
3043                 m = NULL;
3044                 while (n) {
3045                         if (!strcmp(n->num, phone->phone)) {
3046                                 if (p->local->dial == n)
3047                                         p->local->dial = n->next;
3048                                 if (m)
3049                                         m->next = n->next;
3050                                 else
3051                                         p->local->phone[inout] = n->next;
3052                                 kfree(n);
3053                                 return 0;
3054                         }
3055                         m = n;
3056                         n = (isdn_net_phone *) n->next;
3057                 }
3058                 return -EINVAL;
3059         }
3060         return -ENODEV;
3061 }
3062
3063 /*
3064  * Delete all phone-numbers of an interface.
3065  */
3066 static int
3067 isdn_net_rmallphone(isdn_net_dev * p)
3068 {
3069         isdn_net_phone *n;
3070         isdn_net_phone *m;
3071         int i;
3072
3073         for (i = 0; i < 2; i++) {
3074                 n = p->local->phone[i];
3075                 while (n) {
3076                         m = n->next;
3077                         kfree(n);
3078                         n = m;
3079                 }
3080                 p->local->phone[i] = NULL;
3081         }
3082         p->local->dial = NULL;
3083         return 0;
3084 }
3085
3086 /*
3087  * Force a hangup of a network-interface.
3088  */
3089 int
3090 isdn_net_force_hangup(char *name)
3091 {
3092         isdn_net_dev *p = isdn_net_findif(name);
3093         struct net_device *q;
3094
3095         if (p) {
3096                 if (p->local->isdn_device < 0)
3097                         return 1;
3098                 q = p->local->slave;
3099                 /* If this interface has slaves, do a hangup for them also. */
3100                 while (q) {
3101                         isdn_net_hangup(q);
3102                         q = MASTER_TO_SLAVE(q);
3103                 }
3104                 isdn_net_hangup(p->dev);
3105                 return 0;
3106         }
3107         return -ENODEV;
3108 }
3109
3110 /*
3111  * Helper-function for isdn_net_rm: Do the real work.
3112  */
3113 static int
3114 isdn_net_realrm(isdn_net_dev * p, isdn_net_dev * q)
3115 {
3116         u_long flags;
3117
3118         if (isdn_net_device_started(p)) {
3119                 return -EBUSY;
3120         }
3121 #ifdef CONFIG_ISDN_X25
3122         if( p -> cprot && p -> cprot -> pops )
3123                 p -> cprot -> pops -> proto_del ( p -> cprot );
3124 #endif
3125         /* Free all phone-entries */
3126         isdn_net_rmallphone(p);
3127         /* If interface is bound exclusive, free channel-usage */
3128         if (p->local->exclusive != -1)
3129                 isdn_unexclusive_channel(p->local->pre_device, p->local->pre_channel);
3130         if (p->local->master) {
3131                 /* It's a slave-device, so update master's slave-pointer if necessary */
3132                 if (((isdn_net_local *) ISDN_MASTER_PRIV(p->local))->slave ==
3133                     p->dev)
3134                         ((isdn_net_local *)ISDN_MASTER_PRIV(p->local))->slave =
3135                                 p->local->slave;
3136         } else {
3137                 /* Unregister only if it's a master-device */
3138                 unregister_netdev(p->dev);
3139         }
3140         /* Unlink device from chain */
3141         spin_lock_irqsave(&dev->lock, flags);
3142         if (q)
3143                 q->next = p->next;
3144         else
3145                 dev->netdev = p->next;
3146         if (p->local->slave) {
3147                 /* If this interface has a slave, remove it also */
3148                 char *slavename = p->local->slave->name;
3149                 isdn_net_dev *n = dev->netdev;
3150                 q = NULL;
3151                 while (n) {
3152                         if (!strcmp(n->dev->name, slavename)) {
3153                                 spin_unlock_irqrestore(&dev->lock, flags);
3154                                 isdn_net_realrm(n, q);
3155                                 spin_lock_irqsave(&dev->lock, flags);
3156                                 break;
3157                         }
3158                         q = n;
3159                         n = (isdn_net_dev *)n->next;
3160                 }
3161         }
3162         spin_unlock_irqrestore(&dev->lock, flags);
3163         /* If no more net-devices remain, disable auto-hangup timer */
3164         if (dev->netdev == NULL)
3165                 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 0);
3166         free_netdev(p->dev);
3167         kfree(p);
3168
3169         return 0;
3170 }
3171
3172 /*
3173  * Remove a single network-interface.
3174  */
3175 int
3176 isdn_net_rm(char *name)
3177 {
3178         u_long flags;
3179         isdn_net_dev *p;
3180         isdn_net_dev *q;
3181
3182         /* Search name in netdev-chain */
3183         spin_lock_irqsave(&dev->lock, flags);
3184         p = dev->netdev;
3185         q = NULL;
3186         while (p) {
3187                 if (!strcmp(p->dev->name, name)) {
3188                         spin_unlock_irqrestore(&dev->lock, flags);
3189                         return (isdn_net_realrm(p, q));
3190                 }
3191                 q = p;
3192                 p = (isdn_net_dev *) p->next;
3193         }
3194         spin_unlock_irqrestore(&dev->lock, flags);
3195         /* If no more net-devices remain, disable auto-hangup timer */
3196         if (dev->netdev == NULL)
3197                 isdn_timer_ctrl(ISDN_TIMER_NETHANGUP, 0);
3198         return -ENODEV;
3199 }
3200
3201 /*
3202  * Remove all network-interfaces
3203  */
3204 int
3205 isdn_net_rmall(void)
3206 {
3207         u_long flags;
3208         int ret;
3209
3210         /* Walk through netdev-chain */
3211         spin_lock_irqsave(&dev->lock, flags);
3212         while (dev->netdev) {
3213                 if (!dev->netdev->local->master) {
3214                         /* Remove master-devices only, slaves get removed with their master */
3215                         spin_unlock_irqrestore(&dev->lock, flags);
3216                         if ((ret = isdn_net_realrm(dev->netdev, NULL))) {
3217                                 return ret;
3218                         }
3219                         spin_lock_irqsave(&dev->lock, flags);
3220                 }
3221         }
3222         dev->netdev = NULL;
3223         spin_unlock_irqrestore(&dev->lock, flags);
3224         return 0;
3225 }