Lines Matching refs:lp
74 isdn_net_local *lp = n->local;
77 if (lp->master)
78 dev = lp->master;
88 static __inline__ void isdn_net_device_wake_queue(isdn_net_local *lp)
90 if (lp->master)
91 netif_wake_queue(lp->master);
93 netif_wake_queue(&lp->netdev->dev);
100 static __inline__ void isdn_net_device_stop_queue(isdn_net_local *lp)
102 if (lp->master)
103 netif_stop_queue(lp->master);
105 netif_stop_queue(&lp->netdev->dev);
109 * find out if the net_device which this lp belongs to (lp can be
113 static __inline__ int isdn_net_device_busy(isdn_net_local *lp)
119 if (!isdn_net_lp_busy(lp))
122 if (lp->master)
123 nd = ((isdn_net_local *) lp->master->priv)->netdev;
125 nd = lp->netdev;
128 nlp = lp->next;
129 while (nlp != lp) {
140 static __inline__ void isdn_net_inc_frame_cnt(isdn_net_local *lp)
142 atomic_inc(&lp->frame_cnt);
143 if (isdn_net_device_busy(lp))
144 isdn_net_device_stop_queue(lp);
147 static __inline__ void isdn_net_dec_frame_cnt(isdn_net_local *lp)
149 atomic_dec(&lp->frame_cnt);
151 if (!(isdn_net_device_busy(lp))) {
152 if (!skb_queue_empty(&lp->super_tx_queue)) {
153 schedule_work(&lp->tqueue);
155 isdn_net_device_wake_queue(lp);
160 static __inline__ void isdn_net_zero_frame_cnt(isdn_net_local *lp)
162 atomic_set(&lp->frame_cnt, 0);
181 static void isdn_net_ciscohdlck_connected(isdn_net_local *lp);
182 static void isdn_net_ciscohdlck_disconnected(isdn_net_local *lp);
268 isdn_net_bind_channel(isdn_net_local * lp, int idx)
270 lp->flags |= ISDN_NET_CONNECTED;
271 lp->isdn_device = dev->drvmap[idx];
272 lp->isdn_channel = dev->chanmap[idx];
273 dev->rx_netdev[idx] = lp->netdev;
274 dev->st_netdev[idx] = lp->netdev;
281 isdn_net_unbind_channel(isdn_net_local * lp)
283 skb_queue_purge(&lp->super_tx_queue);
285 if (!lp->master) { /* reset only master device */
290 qdisc_reset(lp->netdev->dev.qdisc);
292 lp->dialstate = 0;
293 dev->rx_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
294 dev->st_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
295 isdn_free_channel(lp->isdn_device, lp->isdn_channel, ISDN_USAGE_NET);
296 lp->flags &= ~ISDN_NET_CONNECTED;
297 lp->isdn_device = -1;
298 lp->isdn_channel = -1;
378 static void isdn_net_lp_disconnected(isdn_net_local *lp)
380 isdn_net_rm_from_bundle(lp);
396 isdn_net_local *lp = p->local;
398 struct concap_proto *cprot = lp->netdev->cprot;
404 if ((lp->flags & ISDN_NET_CONNECTED) &&
405 (!lp->dialstate)) {
406 isdn_net_dec_frame_cnt(lp);
407 lp->stats.tx_packets++;
408 lp->stats.tx_bytes += c->parm.length;
413 switch (lp->dialstate) {
417 lp->dialstate++;
420 lp->dialstate = 5;
432 if( !(lp->flags & ISDN_NET_CONNECTED)
436 if ((!lp->dialstate) && (lp->flags & ISDN_NET_CONNECTED)) {
437 if (lp->p_encap == ISDN_NET_ENCAP_CISCOHDLCK)
438 isdn_net_ciscohdlck_disconnected(lp);
440 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
441 isdn_ppp_free(lp);
443 isdn_net_lp_disconnected(lp);
444 isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
445 printk(KERN_INFO "%s: remote hangup\n", lp->name);
446 printk(KERN_INFO "%s: Chargesum is %d\n", lp->name,
447 lp->charge);
448 isdn_net_unbind_channel(lp);
466 isdn_net_zero_frame_cnt(lp);
467 switch (lp->dialstate) {
475 if (lp->dialstate <= 6) {
480 lp->dialstate = 0;
482 if (lp->p_encap == ISDN_NET_ENCAP_CISCOHDLCK)
483 isdn_net_ciscohdlck_connected(lp);
484 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP) {
485 if (lp->master) { /* is lp a slave? */
486 isdn_net_dev *nd = ((isdn_net_local *)lp->master->priv)->netdev;
487 isdn_net_add_to_bundle(nd, lp);
490 printk(KERN_INFO "isdn_net: %s connected\n", lp->name);
494 lp->chargetime = jiffies;
497 lp->dialstarted = 0;
498 lp->dialwait_timer = 0;
501 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
502 isdn_ppp_wakeup_daemon(lp);
511 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
512 isdn_net_device_wake_queue(lp);
518 if (lp->dialstate == 4) {
519 lp->dialstate--;
528 lp->charge++;
529 if (lp->hupflags & ISDN_HAVECHARGE) {
530 lp->hupflags &= ~ISDN_WAITCHARGE;
531 lp->chargeint = jiffies - lp->chargetime - (2 * HZ);
533 if (lp->hupflags & ISDN_WAITCHARGE)
534 lp->hupflags |= ISDN_HAVECHARGE;
535 lp->chargetime = jiffies;
537 lp->name, lp->chargetime);
564 isdn_net_local *lp = p->local;
567 if (lp->dialstate)
568 printk(KERN_DEBUG "%s: dialstate=%d\n", lp->name, lp->dialstate);
570 switch (lp->dialstate) {
578 lp->dial = lp->phone[1];
579 if (!lp->dial) {
581 lp->name);
587 if(lp->dialtimeout > 0)
588 if(lp->dialstarted == 0 || time_after(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait)) {
589 lp->dialstarted = jiffies;
590 lp->dialwait_timer = 0;
593 lp->dialstate++;
597 cmd.driver = lp->isdn_device;
598 cmd.arg = lp->isdn_channel;
601 sprintf(cmd.parm.num, "%s", isdn_map_eaz2msn(lp->msn, cmd.driver));
604 lp->dialretry = 0;
606 lp->dialstate++;
613 if(dev->global_flags & ISDN_GLOBAL_STOPPED || (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF)) {
623 cmd.driver = lp->isdn_device;
625 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8);
627 cmd.driver = lp->isdn_device;
629 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8);
631 cmd.driver = lp->isdn_device;
632 cmd.arg = lp->isdn_channel;
633 if (!lp->dial) {
635 lp->name);
639 if (!strncmp(lp->dial->num, "LEASED", strlen("LEASED"))) {
640 lp->dialstate = 4;
641 printk(KERN_INFO "%s: Open leased line ...\n", lp->name);
643 if(lp->dialtimeout > 0)
644 if (time_after(jiffies, lp->dialstarted + lp->dialtimeout)) {
645 lp->dialwait_timer = jiffies + lp->dialwait;
646 lp->dialstarted = 0;
652 cmd.driver = lp->isdn_device;
657 phone_number = lp->dial->num;
669 if (!(lp->dial = (isdn_net_phone *) lp->dial->next)) {
670 lp->dial = lp->phone[1];
671 lp->dialretry++;
673 if (lp->dialretry > lp->dialmax) {
674 if (lp->dialtimeout == 0) {
675 lp->dialwait_timer = jiffies + lp->dialwait;
676 lp->dialstarted = 0;
684 isdn_map_eaz2msn(lp->msn, cmd.driver));
685 i = isdn_dc2minor(lp->isdn_device, lp->isdn_channel);
691 printk(KERN_INFO "%s: dialing %d %s... %s\n", lp->name,
692 lp->dialretry, cmd.parm.setup.phone,
694 lp->dtimer = 0;
696 printk(KERN_DEBUG "dial: d=%d c=%d\n", lp->isdn_device,
697 lp->isdn_channel);
701 lp->huptimer = 0;
702 lp->outgoing = 1;
703 if (lp->chargeint) {
704 lp->hupflags |= ISDN_HAVECHARGE;
705 lp->hupflags &= ~ISDN_WAITCHARGE;
707 lp->hupflags |= ISDN_WAITCHARGE;
708 lp->hupflags &= ~ISDN_HAVECHARGE;
711 lp->dialstate =
712 (lp->cbdelay &&
713 (lp->flags & ISDN_NET_CBOUT)) ? 12 : 4;
720 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
721 lp->dialstate = 3;
726 cmd.driver = lp->isdn_device;
727 cmd.arg = lp->isdn_channel;
730 lp->dtimer = 0;
731 lp->dialstate++;
739 printk(KERN_DEBUG "dialtimer2: %d\n", lp->dtimer);
741 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
742 lp->dialstate = 3;
750 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
752 cmd.driver = lp->isdn_device;
754 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8);
756 cmd.driver = lp->isdn_device;
758 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8);
760 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT15)
764 lp->dialstate++;
769 cmd.driver = lp->isdn_device;
770 cmd.arg = lp->isdn_channel;
774 lp->dtimer = 0;
775 lp->dialstate++;
781 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
783 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
790 if (lp->dtimer++ > lp->cbdelay)
791 lp->dialstate = 1;
798 if (lp->dtimer++ > lp->cbdelay)
800 printk(KERN_INFO "%s: hangup waiting for callback ...\n", lp->name);
801 lp->dtimer = 0;
802 lp->dialstate = 4;
803 cmd.driver = lp->isdn_device;
805 cmd.arg = lp->isdn_channel;
807 isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
813 lp->dialstate, lp->name);
826 isdn_net_local *lp = (isdn_net_local *) d->priv;
829 struct concap_proto *cprot = lp->netdev->cprot;
833 if (lp->flags & ISDN_NET_CONNECTED) {
834 if (lp->slave != NULL) {
835 isdn_net_local *slp = (isdn_net_local *)lp->slave->priv;
839 slp->name, lp->name);
840 isdn_net_hangup(lp->slave);
843 printk(KERN_INFO "isdn_net: local hangup %s\n", lp->name);
845 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
846 isdn_ppp_free(lp);
848 isdn_net_lp_disconnected(lp);
857 cmd.driver = lp->isdn_device;
859 cmd.arg = lp->isdn_channel;
861 printk(KERN_INFO "%s: Chargesum is %d\n", lp->name, lp->charge);
862 isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
864 isdn_net_unbind_channel(lp);
873 isdn_net_log_skb(struct sk_buff * skb, isdn_net_local * lp)
888 printk(KERN_DEBUG "isdn_net: protocol %04x is buggy, dev %s\n", skb->protocol, lp->name);
891 switch (lp->p_encap) {
966 void isdn_net_write_super(isdn_net_local *lp, struct sk_buff *skb)
971 skb_queue_tail(&lp->super_tx_queue, skb);
972 schedule_work(&lp->tqueue);
976 spin_lock_bh(&lp->xmit_lock);
977 if (!isdn_net_lp_busy(lp)) {
978 isdn_net_writebuf_skb(lp, skb);
980 skb_queue_tail(&lp->super_tx_queue, skb);
982 spin_unlock_bh(&lp->xmit_lock);
990 isdn_net_local *lp = container_of(work, isdn_net_local, tqueue);
993 spin_lock_bh(&lp->xmit_lock);
994 while (!isdn_net_lp_busy(lp)) {
995 skb = skb_dequeue(&lp->super_tx_queue);
998 isdn_net_writebuf_skb(lp, skb);
1000 spin_unlock_bh(&lp->xmit_lock);
1005 * it's serialized by the caller holding the lp->xmit_lock spinlock
1007 void isdn_net_writebuf_skb(isdn_net_local *lp, struct sk_buff *skb)
1013 the lp isn't busy */
1014 if (isdn_net_lp_busy(lp)) {
1019 if (!(lp->flags & ISDN_NET_CONNECTED)) {
1023 ret = isdn_writebuf_skb_stub(lp->isdn_device, lp->isdn_channel, 1, skb);
1026 printk(KERN_WARNING "%s: HL driver queue full\n", lp->name);
1030 lp->transcount += len;
1031 isdn_net_inc_frame_cnt(lp);
1036 lp->stats.tx_errors++;
1057 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
1068 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
1073 lp = isdn_net_get_locked_lp(nd);
1074 if (!lp) {
1078 /* we have our lp locked from now on */
1081 lp->huptimer = 0;
1082 isdn_net_writebuf_skb(lp, skb);
1083 spin_unlock_bh(&lp->xmit_lock);
1090 if (lp->cps > lp->triggercps) {
1091 if (lp->slave) {
1092 if (!lp->sqfull) {
1094 lp->sqfull = 1;
1095 lp->sqfull_stamp = jiffies;
1098 if (time_after(jiffies, lp->sqfull_stamp + lp->slavedelay)) {
1099 slp = lp->slave->priv;
1101 isdn_net_force_dial_lp((isdn_net_local *) lp->slave->priv);
1107 if (lp->sqfull && time_after(jiffies, lp->sqfull_stamp + lp->slavedelay + (10 * HZ))) {
1108 lp->sqfull = 0;
1121 isdn_net_local *lp = (isdn_net_local *) dev->priv;
1124 if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1136 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
1138 printk(KERN_WARNING "isdn_tx_timeout dev %s dialstate %d\n", ndev->name, lp->dialstate);
1139 if (!lp->dialstate){
1140 lp->stats.tx_errors++;
1170 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
1172 struct concap_proto * cprot = lp -> netdev -> cprot;
1203 if (!(lp->flags & ISDN_NET_CONNECTED)) {
1206 if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) {
1211 if (lp->phone[1]) {
1214 if(lp->dialwait_timer <= 0)
1215 if(lp->dialstarted > 0 && lp->dialtimeout > 0 && time_before(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait))
1216 lp->dialwait_timer = lp->dialstarted + lp->dialtimeout + lp->dialwait;
1218 if(lp->dialwait_timer > 0) {
1219 if(time_before(jiffies, lp->dialwait_timer)) {
1224 lp->dialwait_timer = 0;
1231 lp->l2_proto,
1232 lp->l3_proto,
1233 lp->pre_device,
1234 lp->pre_channel,
1235 lp->msn)
1240 lp->l2_proto,
1241 lp->l3_proto,
1242 lp->pre_device,
1243 lp->pre_channel^1,
1244 lp->msn)
1254 isdn_net_log_skb(skb, lp);
1255 lp->dialstate = 1;
1257 isdn_net_bind_channel(lp, chi);
1259 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
1261 if (isdn_ppp_bind(lp) < 0) {
1263 isdn_net_unbind_channel(lp);
1268 if (isdn_ppp_autodial_filter(skb, lp)) {
1269 isdn_ppp_free(lp);
1270 isdn_net_unbind_channel(lp);
1286 isdn_net_device_stop_queue(lp);
1297 if (!lp->dialstate) {
1351 isdn_net_local *lp = (isdn_net_local *) dev->priv;
1352 return &lp->stats;
1413 isdn_net_ciscohdlck_alloc_skb(isdn_net_local *lp, int len)
1415 unsigned short hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
1430 isdn_net_local *lp = (isdn_net_local *) dev->priv;
1434 int period = lp->cisco_keepalive_period;
1435 s8 debserint = lp->cisco_debserint;
1438 if (lp->p_encap != ISDN_NET_ENCAP_CISCOHDLCK)
1444 len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1446 &lp->cisco_keepalive_period, len))
1450 tmp = lp->cisco_keepalive_period;
1451 len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1455 lp->cisco_keepalive_period = period;
1458 if (!rc && (tmp != lp->cisco_keepalive_period)) {
1460 lp->cisco_keepalive_period * HZ);
1461 mod_timer(&lp->cisco_timer, expires);
1464 lp->name, lp->cisco_keepalive_period);
1470 len = (unsigned long)sizeof(lp->cisco_debserint);
1472 &lp->cisco_debserint, len))
1476 len = (unsigned long)sizeof(lp->cisco_debserint);
1481 lp->cisco_debserint = debserint;
1497 isdn_net_local *lp = (isdn_net_local *) data;
1500 unsigned long last_cisco_myseq = lp->cisco_myseq;
1503 if (!(lp->flags & ISDN_NET_CONNECTED) || lp->dialstate) {
1507 lp->cisco_myseq++;
1509 myseq_diff = (lp->cisco_myseq - lp->cisco_mineseen);
1510 if ((lp->cisco_line_state) && ((myseq_diff >= 3)||(myseq_diff <= -3))) {
1512 lp->cisco_line_state = 0;
1515 " changed state to down\n", lp->name);
1517 } else if ((!lp->cisco_line_state) &&
1520 lp->cisco_line_state = 1;
1523 " changed state to up\n", lp->name);
1527 if (lp->cisco_debserint)
1530 lp->name, last_cisco_myseq, lp->cisco_mineseen,
1531 ((last_cisco_myseq == lp->cisco_mineseen) ? '*' : 040),
1532 lp->cisco_yourseq,
1533 ((lp->cisco_line_state) ? "line up" : "line down"));
1535 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1548 p += put_u32(p, lp->cisco_myseq);
1549 p += put_u32(p, lp->cisco_yourseq);
1552 isdn_net_write_super(lp, skb);
1554 lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1556 add_timer(&lp->cisco_timer);
1560 isdn_net_ciscohdlck_slarp_send_request(isdn_net_local *lp)
1565 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1582 isdn_net_write_super(lp, skb);
1586 isdn_net_ciscohdlck_connected(isdn_net_local *lp)
1588 lp->cisco_myseq = 0;
1589 lp->cisco_mineseen = 0;
1590 lp->cisco_yourseq = 0;
1591 lp->cisco_keepalive_period = ISDN_TIMER_KEEPINT;
1592 lp->cisco_last_slarp_in = 0;
1593 lp->cisco_line_state = 0;
1594 lp->cisco_debserint = 0;
1597 isdn_net_ciscohdlck_slarp_send_request(lp);
1599 init_timer(&lp->cisco_timer);
1600 lp->cisco_timer.data = (unsigned long) lp;
1601 lp->cisco_timer.function = isdn_net_ciscohdlck_slarp_send_keepalive;
1602 lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1603 add_timer(&lp->cisco_timer);
1607 isdn_net_ciscohdlck_disconnected(isdn_net_local *lp)
1609 del_timer(&lp->cisco_timer);
1613 isdn_net_ciscohdlck_slarp_send_reply(isdn_net_local *lp)
1621 if ((in_dev = lp->netdev->dev.ip_ptr) != NULL) {
1630 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1648 isdn_net_write_super(lp, skb);
1652 isdn_net_ciscohdlck_slarp_in(isdn_net_local *lp, struct sk_buff *skb)
1670 lp->cisco_yourseq = 0;
1671 isdn_net_ciscohdlck_slarp_send_reply(lp);
1685 lp->name,
1693 "- ignored\n", lp->name,
1697 period = (int)((jiffies - lp->cisco_last_slarp_in
1699 if (lp->cisco_debserint &&
1700 (period != lp->cisco_keepalive_period) &&
1701 lp->cisco_last_slarp_in) {
1704 lp->name, period, lp->cisco_keepalive_period);
1706 lp->cisco_last_slarp_in = jiffies;
1710 lp->cisco_yourseq = my_seq;
1711 lp->cisco_mineseen = your_seq;
1717 isdn_net_ciscohdlck_receive(isdn_net_local *lp, struct sk_buff *skb)
1735 lp->name, addr);
1740 lp->name, ctrl);
1746 isdn_net_ciscohdlck_slarp_in(lp, skb);
1749 if (lp->cisco_debserint)
1751 "\"no cdp enable\" on cisco.\n", lp->name);
1770 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
1771 isdn_net_local *olp = lp; /* original 'lp' */
1773 struct concap_proto *cprot = lp -> netdev -> cprot;
1775 lp->transcount += skb->len;
1777 lp->stats.rx_packets++;
1778 lp->stats.rx_bytes += skb->len;
1779 if (lp->master) {
1783 ndev = lp->master;
1784 lp = (isdn_net_local *) ndev->priv;
1785 lp->stats.rx_packets++;
1786 lp->stats.rx_bytes += skb->len;
1794 switch (lp->p_encap) {
1798 lp->huptimer = 0;
1804 lp->huptimer = 0;
1810 lp->huptimer = 0;
1814 isdn_net_ciscohdlck_receive(lp, skb);
1823 lp->huptimer = 0;
1832 isdn_ppp_receive(lp->netdev, olp, skb);
1846 lp->name);
1866 isdn_net_local *lp = p->local;
1867 if ((lp->flags & ISDN_NET_CONNECTED) &&
1868 (!lp->dialstate)) {
1925 isdn_net_local *lp = dev->priv;
1929 switch (lp->p_encap) {
1965 if( lp-> netdev -> cprot ){
1981 isdn_net_local *lp = dev->priv;
1984 if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
2015 isdn_net_local *lp = (isdn_net_local *) ndev->priv;
2019 lp->org_hhc = ndev->hard_header_cache;
2020 lp->org_hcu = ndev->header_cache_update;
2165 isdn_net_local *lp = p->local;
2178 my_eaz = isdn_map_eaz2msn(lp->msn, di);
2201 lp->name, lp->msn, lp->flags, lp->dialstate);
2204 (((!(lp->flags & ISDN_NET_CONNECTED)) && /* but not connected */
2206 ((((lp->dialstate == 4) || (lp->dialstate == 12)) && /* if dialing */
2207 (!(lp->flags & ISDN_NET_CALLBACK))) /* but no callback */
2212 lp->pre_device, lp->pre_channel);
2215 if ((lp->pre_channel != ch) ||
2216 (lp->pre_device != di)) {
2240 if ((lp->pre_device == di) &&
2241 (lp->pre_channel == 1)) {
2263 ((lp->pre_channel != ch) ||
2264 (lp->pre_device != di))) {
2283 n = lp->phone[0];
2284 if (lp->flags & ISDN_NET_SECURE) {
2291 if (n || (!(lp->flags & ISDN_NET_SECURE))) {
2302 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2304 lp->name);
2313 lp->name);
2319 if (lp->master) {
2320 isdn_net_local *mlp = (isdn_net_local *) lp->master->priv;
2321 printk(KERN_DEBUG "ICALLslv: %s\n", lp->name);
2327 if ((isdn_net_local *) mlp->slave->priv == lp)
2340 if (lp->flags & ISDN_NET_CALLBACK) {
2347 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2349 lp->name);
2353 lp->name, nr, eaz);
2354 if (lp->phone[1]) {
2360 lp->l2_proto,
2361 lp->l3_proto,
2362 lp->pre_device,
2363 lp->pre_channel,
2364 lp->msn)
2367 printk(KERN_WARNING "isdn_net_find_icall: No channel for %s\n", lp->name);
2372 lp->dtimer = 0;
2373 lp->dialstate = 11;
2375 isdn_net_bind_channel(lp, chi);
2377 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2378 if (isdn_ppp_bind(lp) < 0) {
2380 isdn_net_unbind_channel(lp);
2386 return (lp->flags & ISDN_NET_CBHUP) ? 2 : 4;
2388 printk(KERN_WARNING "isdn_net: %s: No phone number\n", lp->name);
2391 printk(KERN_DEBUG "%s: call from %s -> %s accepted\n", lp->name, nr,
2395 if ((lp->dialstate == 4) || (lp->dialstate == 12)) {
2397 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2398 isdn_ppp_free(lp);
2400 isdn_net_lp_disconnected(lp);
2401 isdn_free_channel(lp->isdn_device, lp->isdn_channel,
2409 dev->st_netdev[idx] = lp->netdev;
2410 lp->isdn_device = di;
2411 lp->isdn_channel = ch;
2412 lp->ppp_slot = -1;
2413 lp->flags |= ISDN_NET_CONNECTED;
2414 lp->dialstate = 7;
2415 lp->dtimer = 0;
2416 lp->outgoing = 0;
2417 lp->huptimer = 0;
2418 lp->hupflags |= ISDN_WAITCHARGE;
2419 lp->hupflags &= ~ISDN_HAVECHARGE;
2421 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
2422 if (isdn_ppp_bind(lp) < 0) {
2423 isdn_net_unbind_channel(lp);
2464 isdn_net_force_dial_lp(isdn_net_local * lp)
2466 if ((!(lp->flags & ISDN_NET_CONNECTED)) && !lp->dialstate) {
2468 if (lp->phone[1]) {
2475 lp->l2_proto,
2476 lp->l3_proto,
2477 lp->pre_device,
2478 lp->pre_channel,
2479 lp->msn)) < 0) {
2480 printk(KERN_WARNING "isdn_net_force_dial: No channel for %s\n", lp->name);
2484 lp->dialstate = 1;
2486 isdn_net_bind_channel(lp, chi);
2488 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2489 if (isdn_ppp_bind(lp) < 0) {
2490 isdn_net_unbind_channel(lp);
2511 isdn_net_dial_req(isdn_net_local * lp)
2514 if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) return -EBUSY;
2516 return isdn_net_force_dial_lp(lp);
2674 isdn_net_local *lp = p->local;
2687 if (lp->p_encap != cfg->p_encap){
2693 lp->name);
2700 lp -> dops = NULL;
2704 lp -> dops = &isdn_concap_reliable_dl_dops;
2718 lp->name);
2774 drvidx = lp->pre_device;
2775 chidx = lp->pre_channel;
2783 lp->l2_proto, lp->l3_proto, drvidx,
2784 chidx, lp->msn)) < 0) {
2786 lp->exclusive = -1;
2794 lp->exclusive = i;
2797 lp->exclusive = -1;
2798 if ((lp->pre_device != -1) && (cfg->exclusive == -1)) {
2799 isdn_unexclusive_channel(lp->pre_device, lp->pre_channel);
2800 isdn_free_channel(lp->pre_device, lp->pre_channel, ISDN_USAGE_NET);
2805 strcpy(lp->msn, cfg->eaz);
2806 lp->pre_device = drvidx;
2807 lp->pre_channel = chidx;
2808 lp->onhtime = cfg->onhtime;
2809 lp->charge = cfg->charge;
2810 lp->l2_proto = cfg->l2_proto;
2811 lp->l3_proto = cfg->l3_proto;
2812 lp->cbdelay = cfg->cbdelay;
2813 lp->dialmax = cfg->dialmax;
2814 lp->triggercps = cfg->triggercps;
2815 lp->slavedelay = cfg->slavedelay * HZ;
2816 lp->pppbind = cfg->pppbind;
2817 lp->dialtimeout = cfg->dialtimeout >= 0 ? cfg->dialtimeout * HZ : -1;
2818 lp->dialwait = cfg->dialwait * HZ;
2820 lp->flags |= ISDN_NET_SECURE;
2822 lp->flags &= ~ISDN_NET_SECURE;
2824 lp->flags |= ISDN_NET_CBHUP;
2826 lp->flags &= ~ISDN_NET_CBHUP;
2829 lp->flags &= ~(ISDN_NET_CALLBACK | ISDN_NET_CBOUT);
2832 lp->flags |= ISDN_NET_CALLBACK;
2833 lp->flags &= ~ISDN_NET_CBOUT;
2836 lp->flags |= ISDN_NET_CBOUT;
2837 lp->flags &= ~ISDN_NET_CALLBACK;
2840 lp->flags &= ~ISDN_NET_DIALMODE_MASK; /* first all bits off */
2845 lp->flags |= ISDN_NET_DM_OFF; /* turn on `off' bit */
2848 lp->flags |= cfg->dialmode; /* turn on selected bits */
2851 lp->hupflags |= ISDN_CHARGEHUP;
2853 lp->hupflags &= ~ISDN_CHARGEHUP;
2855 lp->hupflags |= ISDN_INHUP;
2857 lp->hupflags &= ~ISDN_INHUP;
2859 lp->hupflags |= ISDN_CHARGEHUP | ISDN_HAVECHARGE | ISDN_MANCHARGE;
2860 lp->chargeint = cfg->chargeint * HZ;
2862 if (cfg->p_encap != lp->p_encap) {
2871 p->dev.hard_header_cache = lp->org_hhc;
2872 p->dev.header_cache_update = lp->org_hcu;
2881 lp->p_encap = cfg->p_encap;
2896 isdn_net_local *lp = p->local;
2898 strcpy(cfg->eaz, lp->msn);
2899 cfg->exclusive = lp->exclusive;
2900 if (lp->pre_device >= 0) {
2901 sprintf(cfg->drvid, "%s,%d", dev->drvid[lp->pre_device],
2902 lp->pre_channel);
2905 cfg->onhtime = lp->onhtime;
2906 cfg->charge = lp->charge;
2907 cfg->l2_proto = lp->l2_proto;
2908 cfg->l3_proto = lp->l3_proto;
2909 cfg->p_encap = lp->p_encap;
2910 cfg->secure = (lp->flags & ISDN_NET_SECURE) ? 1 : 0;
2912 if (lp->flags & ISDN_NET_CALLBACK)
2914 if (lp->flags & ISDN_NET_CBOUT)
2916 cfg->cbhup = (lp->flags & ISDN_NET_CBHUP) ? 1 : 0;
2917 cfg->dialmode = lp->flags & ISDN_NET_DIALMODE_MASK;
2918 cfg->chargehup = (lp->hupflags & 4) ? 1 : 0;
2919 cfg->ihup = (lp->hupflags & 8) ? 1 : 0;
2920 cfg->cbdelay = lp->cbdelay;
2921 cfg->dialmax = lp->dialmax;
2922 cfg->triggercps = lp->triggercps;
2923 cfg->slavedelay = lp->slavedelay / HZ;
2924 cfg->chargeint = (lp->hupflags & ISDN_CHARGEHUP) ?
2925 (lp->chargeint / HZ) : 0;
2926 cfg->pppbind = lp->pppbind;
2927 cfg->dialtimeout = lp->dialtimeout >= 0 ? lp->dialtimeout / HZ : -1;
2928 cfg->dialwait = lp->dialwait / HZ;
2929 if (lp->slave)
2930 strcpy(cfg->slave, ((isdn_net_local *) lp->slave->priv)->name);
2933 if (lp->master)
2934 strcpy(cfg->master, ((isdn_net_local *) lp->master->priv)->name);