Lines Matching refs:lp
75 isdn_net_local *lp = n->local;
78 if (lp->master)
79 dev = lp->master;
89 static __inline__ void isdn_net_device_wake_queue(isdn_net_local *lp)
91 if (lp->master)
92 netif_wake_queue(lp->master);
94 netif_wake_queue(lp->netdev->dev);
101 static __inline__ void isdn_net_device_stop_queue(isdn_net_local *lp)
103 if (lp->master)
104 netif_stop_queue(lp->master);
106 netif_stop_queue(lp->netdev->dev);
110 * find out if the net_device which this lp belongs to (lp can be
114 static __inline__ int isdn_net_device_busy(isdn_net_local *lp)
120 if (!isdn_net_lp_busy(lp))
123 if (lp->master)
124 nd = ISDN_MASTER_PRIV(lp)->netdev;
126 nd = lp->netdev;
129 nlp = lp->next;
130 while (nlp != lp) {
141 static __inline__ void isdn_net_inc_frame_cnt(isdn_net_local *lp)
143 atomic_inc(&lp->frame_cnt);
144 if (isdn_net_device_busy(lp))
145 isdn_net_device_stop_queue(lp);
148 static __inline__ void isdn_net_dec_frame_cnt(isdn_net_local *lp)
150 atomic_dec(&lp->frame_cnt);
152 if (!(isdn_net_device_busy(lp))) {
153 if (!skb_queue_empty(&lp->super_tx_queue)) {
154 schedule_work(&lp->tqueue);
156 isdn_net_device_wake_queue(lp);
161 static __inline__ void isdn_net_zero_frame_cnt(isdn_net_local *lp)
163 atomic_set(&lp->frame_cnt, 0);
183 static void isdn_net_ciscohdlck_connected(isdn_net_local *lp);
184 static void isdn_net_ciscohdlck_disconnected(isdn_net_local *lp);
270 isdn_net_bind_channel(isdn_net_local *lp, int idx)
272 lp->flags |= ISDN_NET_CONNECTED;
273 lp->isdn_device = dev->drvmap[idx];
274 lp->isdn_channel = dev->chanmap[idx];
275 dev->rx_netdev[idx] = lp->netdev;
276 dev->st_netdev[idx] = lp->netdev;
283 isdn_net_unbind_channel(isdn_net_local *lp)
285 skb_queue_purge(&lp->super_tx_queue);
287 if (!lp->master) { /* reset only master device */
292 qdisc_reset_all_tx(lp->netdev->dev);
294 lp->dialstate = 0;
295 dev->rx_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
296 dev->st_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
297 if (lp->isdn_device != -1 && lp->isdn_channel != -1)
298 isdn_free_channel(lp->isdn_device, lp->isdn_channel,
300 lp->flags &= ~ISDN_NET_CONNECTED;
301 lp->isdn_device = -1;
302 lp->isdn_channel = -1;
382 static void isdn_net_lp_disconnected(isdn_net_local *lp)
384 isdn_net_rm_from_bundle(lp);
400 isdn_net_local *lp = p->local;
402 struct concap_proto *cprot = lp->netdev->cprot;
408 if ((lp->flags & ISDN_NET_CONNECTED) &&
409 (!lp->dialstate)) {
410 isdn_net_dec_frame_cnt(lp);
411 lp->stats.tx_packets++;
412 lp->stats.tx_bytes += c->parm.length;
417 switch (lp->dialstate) {
421 lp->dialstate++;
424 lp->dialstate = 5;
436 if (!(lp->flags & ISDN_NET_CONNECTED)
440 if ((!lp->dialstate) && (lp->flags & ISDN_NET_CONNECTED)) {
441 if (lp->p_encap == ISDN_NET_ENCAP_CISCOHDLCK)
442 isdn_net_ciscohdlck_disconnected(lp);
444 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
445 isdn_ppp_free(lp);
447 isdn_net_lp_disconnected(lp);
448 isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
451 lp->charge);
452 isdn_net_unbind_channel(lp);
470 isdn_net_zero_frame_cnt(lp);
471 switch (lp->dialstate) {
479 if (lp->dialstate <= 6) {
484 lp->dialstate = 0;
486 if (lp->p_encap == ISDN_NET_ENCAP_CISCOHDLCK)
487 isdn_net_ciscohdlck_connected(lp);
488 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP) {
489 if (lp->master) { /* is lp a slave? */
490 isdn_net_dev *nd = ISDN_MASTER_PRIV(lp)->netdev;
491 isdn_net_add_to_bundle(nd, lp);
498 lp->chargetime = jiffies;
501 lp->dialstarted = 0;
502 lp->dialwait_timer = 0;
505 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
506 isdn_ppp_wakeup_daemon(lp);
515 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
516 isdn_net_device_wake_queue(lp);
522 if (lp->dialstate == 4) {
523 lp->dialstate--;
532 lp->charge++;
533 if (lp->hupflags & ISDN_HAVECHARGE) {
534 lp->hupflags &= ~ISDN_WAITCHARGE;
535 lp->chargeint = jiffies - lp->chargetime - (2 * HZ);
537 if (lp->hupflags & ISDN_WAITCHARGE)
538 lp->hupflags |= ISDN_HAVECHARGE;
539 lp->chargetime = jiffies;
541 p->dev->name, lp->chargetime);
568 isdn_net_local *lp = p->local;
571 if (lp->dialstate)
572 printk(KERN_DEBUG "%s: dialstate=%d\n", p->dev->name, lp->dialstate);
574 switch (lp->dialstate) {
582 lp->dial = lp->phone[1];
583 if (!lp->dial) {
591 if (lp->dialtimeout > 0)
592 if (lp->dialstarted == 0 || time_after(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait)) {
593 lp->dialstarted = jiffies;
594 lp->dialwait_timer = 0;
597 lp->dialstate++;
601 cmd.driver = lp->isdn_device;
602 cmd.arg = lp->isdn_channel;
605 sprintf(cmd.parm.num, "%s", isdn_map_eaz2msn(lp->msn, cmd.driver));
608 lp->dialretry = 0;
610 lp->dialstate++;
617 if (dev->global_flags & ISDN_GLOBAL_STOPPED || (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF)) {
627 cmd.driver = lp->isdn_device;
629 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8);
631 cmd.driver = lp->isdn_device;
633 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8);
635 cmd.driver = lp->isdn_device;
636 cmd.arg = lp->isdn_channel;
637 if (!lp->dial) {
643 if (!strncmp(lp->dial->num, "LEASED", strlen("LEASED"))) {
644 lp->dialstate = 4;
647 if (lp->dialtimeout > 0)
648 if (time_after(jiffies, lp->dialstarted + lp->dialtimeout)) {
649 lp->dialwait_timer = jiffies + lp->dialwait;
650 lp->dialstarted = 0;
656 cmd.driver = lp->isdn_device;
661 phone_number = lp->dial->num;
673 if (!(lp->dial = (isdn_net_phone *) lp->dial->next)) {
674 lp->dial = lp->phone[1];
675 lp->dialretry++;
677 if (lp->dialretry > lp->dialmax) {
678 if (lp->dialtimeout == 0) {
679 lp->dialwait_timer = jiffies + lp->dialwait;
680 lp->dialstarted = 0;
688 isdn_map_eaz2msn(lp->msn, cmd.driver));
689 i = isdn_dc2minor(lp->isdn_device, lp->isdn_channel);
696 lp->dialretry, cmd.parm.setup.phone,
698 lp->dtimer = 0;
700 printk(KERN_DEBUG "dial: d=%d c=%d\n", lp->isdn_device,
701 lp->isdn_channel);
705 lp->huptimer = 0;
706 lp->outgoing = 1;
707 if (lp->chargeint) {
708 lp->hupflags |= ISDN_HAVECHARGE;
709 lp->hupflags &= ~ISDN_WAITCHARGE;
711 lp->hupflags |= ISDN_WAITCHARGE;
712 lp->hupflags &= ~ISDN_HAVECHARGE;
715 lp->dialstate =
716 (lp->cbdelay &&
717 (lp->flags & ISDN_NET_CBOUT)) ? 12 : 4;
724 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
725 lp->dialstate = 3;
730 cmd.driver = lp->isdn_device;
731 cmd.arg = lp->isdn_channel;
734 lp->dtimer = 0;
735 lp->dialstate++;
743 printk(KERN_DEBUG "dialtimer2: %d\n", lp->dtimer);
745 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
746 lp->dialstate = 3;
754 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
756 cmd.driver = lp->isdn_device;
758 cmd.arg = lp->isdn_channel + (lp->l2_proto << 8);
760 cmd.driver = lp->isdn_device;
762 cmd.arg = lp->isdn_channel + (lp->l3_proto << 8);
764 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT15)
768 lp->dialstate++;
773 cmd.driver = lp->isdn_device;
774 cmd.arg = lp->isdn_channel;
778 lp->dtimer = 0;
779 lp->dialstate++;
785 printk(KERN_DEBUG "dialtimer4: %d\n", lp->dtimer);
787 if (lp->dtimer++ > ISDN_TIMER_DTIMEOUT10)
794 if (lp->dtimer++ > lp->cbdelay)
795 lp->dialstate = 1;
802 if (lp->dtimer++ > lp->cbdelay)
805 lp->dtimer = 0;
806 lp->dialstate = 4;
807 cmd.driver = lp->isdn_device;
809 cmd.arg = lp->isdn_channel;
811 isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
817 lp->dialstate, p->dev->name);
830 isdn_net_local *lp = netdev_priv(d);
833 struct concap_proto *cprot = lp->netdev->cprot;
837 if (lp->flags & ISDN_NET_CONNECTED) {
838 if (lp->slave != NULL) {
839 isdn_net_local *slp = ISDN_SLAVE_PRIV(lp);
843 lp->slave->name, d->name);
844 isdn_net_hangup(lp->slave);
849 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
850 isdn_ppp_free(lp);
852 isdn_net_lp_disconnected(lp);
861 cmd.driver = lp->isdn_device;
863 cmd.arg = lp->isdn_channel;
865 printk(KERN_INFO "%s: Chargesum is %d\n", d->name, lp->charge);
866 isdn_all_eaz(lp->isdn_device, lp->isdn_channel);
868 isdn_net_unbind_channel(lp);
877 isdn_net_log_skb(struct sk_buff *skb, isdn_net_local *lp)
892 printk(KERN_DEBUG "isdn_net: protocol %04x is buggy, dev %s\n", skb->protocol, lp->netdev->dev->name);
895 switch (lp->p_encap) {
964 void isdn_net_write_super(isdn_net_local *lp, struct sk_buff *skb)
969 skb_queue_tail(&lp->super_tx_queue, skb);
970 schedule_work(&lp->tqueue);
974 spin_lock_bh(&lp->xmit_lock);
975 if (!isdn_net_lp_busy(lp)) {
976 isdn_net_writebuf_skb(lp, skb);
978 skb_queue_tail(&lp->super_tx_queue, skb);
980 spin_unlock_bh(&lp->xmit_lock);
988 isdn_net_local *lp = container_of(work, isdn_net_local, tqueue);
991 spin_lock_bh(&lp->xmit_lock);
992 while (!isdn_net_lp_busy(lp)) {
993 skb = skb_dequeue(&lp->super_tx_queue);
996 isdn_net_writebuf_skb(lp, skb);
998 spin_unlock_bh(&lp->xmit_lock);
1003 * it's serialized by the caller holding the lp->xmit_lock spinlock
1005 void isdn_net_writebuf_skb(isdn_net_local *lp, struct sk_buff *skb)
1011 the lp isn't busy */
1012 if (isdn_net_lp_busy(lp)) {
1017 if (!(lp->flags & ISDN_NET_CONNECTED)) {
1021 ret = isdn_writebuf_skb_stub(lp->isdn_device, lp->isdn_channel, 1, skb);
1024 printk(KERN_WARNING "%s: HL driver queue full\n", lp->netdev->dev->name);
1028 lp->transcount += len;
1029 isdn_net_inc_frame_cnt(lp);
1034 lp->stats.tx_errors++;
1055 isdn_net_local *lp = netdev_priv(ndev);
1066 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
1071 lp = isdn_net_get_locked_lp(nd);
1072 if (!lp) {
1076 /* we have our lp locked from now on */
1079 lp->huptimer = 0; // FIXME?
1080 isdn_net_writebuf_skb(lp, skb);
1081 spin_unlock_bh(&lp->xmit_lock);
1088 if (lp->cps > lp->triggercps) {
1089 if (lp->slave) {
1090 if (!lp->sqfull) {
1092 lp->sqfull = 1;
1093 lp->sqfull_stamp = jiffies;
1096 if (time_after(jiffies, lp->sqfull_stamp + lp->slavedelay)) {
1097 slp = ISDN_SLAVE_PRIV(lp);
1099 isdn_net_force_dial_lp(ISDN_SLAVE_PRIV(lp));
1105 if (lp->sqfull && time_after(jiffies, lp->sqfull_stamp + lp->slavedelay + (10 * HZ))) {
1106 lp->sqfull = 0;
1119 isdn_net_local *lp = netdev_priv(dev);
1122 if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1134 isdn_net_local *lp = netdev_priv(ndev);
1136 printk(KERN_WARNING "isdn_tx_timeout dev %s dialstate %d\n", ndev->name, lp->dialstate);
1137 if (!lp->dialstate) {
1138 lp->stats.tx_errors++;
1168 isdn_net_local *lp = netdev_priv(ndev);
1170 struct concap_proto *cprot = lp->netdev->cprot;
1201 if (!(lp->flags & ISDN_NET_CONNECTED)) {
1204 if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) {
1209 if (lp->phone[1]) {
1212 if (lp->dialwait_timer <= 0)
1213 if (lp->dialstarted > 0 && lp->dialtimeout > 0 && time_before(jiffies, lp->dialstarted + lp->dialtimeout + lp->dialwait))
1214 lp->dialwait_timer = lp->dialstarted + lp->dialtimeout + lp->dialwait;
1216 if (lp->dialwait_timer > 0) {
1217 if (time_before(jiffies, lp->dialwait_timer)) {
1222 lp->dialwait_timer = 0;
1229 lp->l2_proto,
1230 lp->l3_proto,
1231 lp->pre_device,
1232 lp->pre_channel,
1233 lp->msn)
1238 lp->l2_proto,
1239 lp->l3_proto,
1240 lp->pre_device,
1241 lp->pre_channel^1,
1242 lp->msn)
1252 isdn_net_log_skb(skb, lp);
1253 lp->dialstate = 1;
1255 isdn_net_bind_channel(lp, chi);
1257 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
1259 if (isdn_ppp_bind(lp) < 0) {
1261 isdn_net_unbind_channel(lp);
1266 if (isdn_ppp_autodial_filter(skb, lp)) {
1267 isdn_ppp_free(lp);
1268 isdn_net_unbind_channel(lp);
1284 isdn_net_device_stop_queue(lp);
1295 if (!lp->dialstate) {
1350 isdn_net_local *lp = netdev_priv(dev);
1351 return &lp->stats;
1412 isdn_net_ciscohdlck_alloc_skb(isdn_net_local *lp, int len)
1414 unsigned short hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
1429 isdn_net_local *lp = netdev_priv(dev);
1433 int period = lp->cisco_keepalive_period;
1434 s8 debserint = lp->cisco_debserint;
1437 if (lp->p_encap != ISDN_NET_ENCAP_CISCOHDLCK)
1443 len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1445 &lp->cisco_keepalive_period, len))
1449 tmp = lp->cisco_keepalive_period;
1450 len = (unsigned long)sizeof(lp->cisco_keepalive_period);
1454 lp->cisco_keepalive_period = period;
1457 if (!rc && (tmp != lp->cisco_keepalive_period)) {
1459 lp->cisco_keepalive_period * HZ);
1460 mod_timer(&lp->cisco_timer, expires);
1463 dev->name, lp->cisco_keepalive_period);
1469 len = (unsigned long)sizeof(lp->cisco_debserint);
1471 &lp->cisco_debserint, len))
1475 len = (unsigned long)sizeof(lp->cisco_debserint);
1480 lp->cisco_debserint = debserint;
1496 isdn_net_local *lp = netdev_priv(dev);
1498 switch (lp->p_encap) {
1514 isdn_net_local *lp = (isdn_net_local *) data;
1517 unsigned long last_cisco_myseq = lp->cisco_myseq;
1520 if (!(lp->flags & ISDN_NET_CONNECTED) || lp->dialstate) {
1524 lp->cisco_myseq++;
1526 myseq_diff = (lp->cisco_myseq - lp->cisco_mineseen);
1527 if ((lp->cisco_line_state) && ((myseq_diff >= 3) || (myseq_diff <= -3))) {
1529 lp->cisco_line_state = 0;
1532 " changed state to down\n", lp->netdev->dev->name);
1534 } else if ((!lp->cisco_line_state) &&
1537 lp->cisco_line_state = 1;
1540 " changed state to up\n", lp->netdev->dev->name);
1544 if (lp->cisco_debserint)
1547 lp->netdev->dev->name, last_cisco_myseq, lp->cisco_mineseen,
1548 ((last_cisco_myseq == lp->cisco_mineseen) ? '*' : 040),
1549 lp->cisco_yourseq,
1550 ((lp->cisco_line_state) ? "line up" : "line down"));
1552 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1565 *(__be32 *)(p + 8) = cpu_to_be32(lp->cisco_myseq);
1566 *(__be32 *)(p + 12) = cpu_to_be32(lp->cisco_yourseq);
1570 isdn_net_write_super(lp, skb);
1572 lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1574 add_timer(&lp->cisco_timer);
1578 isdn_net_ciscohdlck_slarp_send_request(isdn_net_local *lp)
1583 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1601 isdn_net_write_super(lp, skb);
1605 isdn_net_ciscohdlck_connected(isdn_net_local *lp)
1607 lp->cisco_myseq = 0;
1608 lp->cisco_mineseen = 0;
1609 lp->cisco_yourseq = 0;
1610 lp->cisco_keepalive_period = ISDN_TIMER_KEEPINT;
1611 lp->cisco_last_slarp_in = 0;
1612 lp->cisco_line_state = 0;
1613 lp->cisco_debserint = 0;
1616 isdn_net_ciscohdlck_slarp_send_request(lp);
1618 init_timer(&lp->cisco_timer);
1619 lp->cisco_timer.data = (unsigned long) lp;
1620 lp->cisco_timer.function = isdn_net_ciscohdlck_slarp_send_keepalive;
1621 lp->cisco_timer.expires = jiffies + lp->cisco_keepalive_period * HZ;
1622 add_timer(&lp->cisco_timer);
1626 isdn_net_ciscohdlck_disconnected(isdn_net_local *lp)
1628 del_timer(&lp->cisco_timer);
1632 isdn_net_ciscohdlck_slarp_send_reply(isdn_net_local *lp)
1640 if ((in_dev = lp->netdev->dev->ip_ptr) != NULL) {
1649 skb = isdn_net_ciscohdlck_alloc_skb(lp, 4 + 14);
1668 isdn_net_write_super(lp, skb);
1672 isdn_net_ciscohdlck_slarp_in(isdn_net_local *lp, struct sk_buff *skb)
1691 lp->cisco_yourseq = 0;
1692 isdn_net_ciscohdlck_slarp_send_reply(lp);
1704 lp->netdev->dev->name, addr, &local, mask);
1708 lp->netdev->dev->name, addr, mask);
1711 period = (int)((jiffies - lp->cisco_last_slarp_in
1713 if (lp->cisco_debserint &&
1714 (period != lp->cisco_keepalive_period) &&
1715 lp->cisco_last_slarp_in) {
1718 lp->netdev->dev->name, period,
1719 lp->cisco_keepalive_period);
1721 lp->cisco_last_slarp_in = jiffies;
1725 lp->cisco_yourseq = my_seq;
1726 lp->cisco_mineseen = your_seq;
1732 isdn_net_ciscohdlck_receive(isdn_net_local *lp, struct sk_buff *skb)
1751 lp->netdev->dev->name, addr);
1756 lp->netdev->dev->name, ctrl);
1762 isdn_net_ciscohdlck_slarp_in(lp, skb);
1765 if (lp->cisco_debserint)
1768 lp->netdev->dev->name);
1787 isdn_net_local *lp = netdev_priv(ndev);
1788 isdn_net_local *olp = lp; /* original 'lp' */
1790 struct concap_proto *cprot = lp->netdev->cprot;
1792 lp->transcount += skb->len;
1794 lp->stats.rx_packets++;
1795 lp->stats.rx_bytes += skb->len;
1796 if (lp->master) {
1800 ndev = lp->master;
1801 lp = netdev_priv(ndev);
1802 lp->stats.rx_packets++;
1803 lp->stats.rx_bytes += skb->len;
1811 switch (lp->p_encap) {
1815 lp->huptimer = 0;
1821 lp->huptimer = 0;
1827 lp->huptimer = 0;
1831 isdn_net_ciscohdlck_receive(lp, skb);
1840 lp->huptimer = 0;
1849 isdn_ppp_receive(lp->netdev, olp, skb);
1863 lp->netdev->dev->name);
1883 isdn_net_local *lp = p->local;
1884 if ((lp->flags & ISDN_NET_CONNECTED) &&
1885 (!lp->dialstate)) {
1902 isdn_net_local *lp = netdev_priv(dev);
1906 switch (lp->p_encap) {
1943 if (lp->netdev->cprot) {
1959 isdn_net_local *lp = netdev_priv(dev);
1962 if (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
1990 isdn_net_local *lp = netdev_priv(dev);
1992 if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
2001 isdn_net_local *lp = netdev_priv(dev);
2002 if (lp->p_encap == ISDN_NET_ENCAP_ETHER)
2141 isdn_net_local *lp = p->local;
2154 my_eaz = isdn_map_eaz2msn(lp->msn, di);
2177 p->dev->name, lp->msn, lp->flags, lp->dialstate);
2180 (((!(lp->flags & ISDN_NET_CONNECTED)) && /* but not connected */
2182 ((((lp->dialstate == 4) || (lp->dialstate == 12)) && /* if dialing */
2183 (!(lp->flags & ISDN_NET_CALLBACK))) /* but no callback */
2188 lp->pre_device, lp->pre_channel);
2191 if ((lp->pre_channel != ch) ||
2192 (lp->pre_device != di)) {
2216 if ((lp->pre_device == di) &&
2217 (lp->pre_channel == 1)) {
2239 ((lp->pre_channel != ch) ||
2240 (lp->pre_device != di))) {
2259 n = lp->phone[0];
2260 if (lp->flags & ISDN_NET_SECURE) {
2267 if (n || (!(lp->flags & ISDN_NET_SECURE))) {
2278 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2295 if (lp->master) {
2296 isdn_net_local *mlp = ISDN_MASTER_PRIV(lp);
2298 printk(KERN_DEBUG "master=%s\n", lp->master->name);
2303 if (ISDN_SLAVE_PRIV(mlp) == lp)
2316 if (lp->flags & ISDN_NET_CALLBACK) {
2323 if (ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_OFF) {
2330 if (lp->phone[1]) {
2336 lp->l2_proto,
2337 lp->l3_proto,
2338 lp->pre_device,
2339 lp->pre_channel,
2340 lp->msn)
2349 lp->dtimer = 0;
2350 lp->dialstate = 11;
2352 isdn_net_bind_channel(lp, chi);
2354 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2355 if (isdn_ppp_bind(lp) < 0) {
2357 isdn_net_unbind_channel(lp);
2363 return (lp->flags & ISDN_NET_CBHUP) ? 2 : 4;
2373 if ((lp->dialstate == 4) || (lp->dialstate == 12)) {
2375 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2376 isdn_ppp_free(lp);
2378 isdn_net_lp_disconnected(lp);
2379 isdn_free_channel(lp->isdn_device, lp->isdn_channel,
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;
2399 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP) {
2400 if (isdn_ppp_bind(lp) < 0) {
2401 isdn_net_unbind_channel(lp);
2442 isdn_net_force_dial_lp(isdn_net_local *lp)
2444 if ((!(lp->flags & ISDN_NET_CONNECTED)) && !lp->dialstate) {
2446 if (lp->phone[1]) {
2453 lp->l2_proto,
2454 lp->l3_proto,
2455 lp->pre_device,
2456 lp->pre_channel,
2457 lp->msn)) < 0) {
2459 lp->netdev->dev->name);
2463 lp->dialstate = 1;
2465 isdn_net_bind_channel(lp, chi);
2467 if (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
2468 if (isdn_ppp_bind(lp) < 0) {
2469 isdn_net_unbind_channel(lp);
2490 isdn_net_dial_req(isdn_net_local *lp)
2493 if (!(ISDN_NET_DIALMODE(*lp) == ISDN_NET_DM_AUTO)) return -EBUSY;
2495 return isdn_net_force_dial_lp(lp);
2529 isdn_net_local *lp = netdev_priv(dev);
2544 lp->p_encap = ISDN_NET_ENCAP_RAWIP;
2545 lp->magic = ISDN_NET_MAGIC;
2546 lp->last = lp;
2547 lp->next = lp;
2548 lp->isdn_device = -1;
2549 lp->isdn_channel = -1;
2550 lp->pre_device = -1;
2551 lp->pre_channel = -1;
2552 lp->exclusive = -1;
2553 lp->ppp_slot = -1;
2554 lp->pppbind = -1;
2555 skb_queue_head_init(&lp->super_tx_queue);
2556 lp->l2_proto = ISDN_PROTO_L2_X75I;
2557 lp->l3_proto = ISDN_PROTO_L3_TRANS;
2558 lp->triggercps = 6000;
2559 lp->slavedelay = 10 * HZ;
2560 lp->hupflags = ISDN_INHUP; /* Do hangup even on incoming calls */
2561 lp->onhtime = 10; /* Default hangup-time for saving costs */
2562 lp->dialmax = 1;
2564 lp->flags = ISDN_NET_CBHUP | ISDN_NET_DM_MANUAL;
2565 lp->cbdelay = 25; /* Wait 5 secs before Callback */
2566 lp->dialtimeout = -1; /* Infinite Dial-Timeout */
2567 lp->dialwait = 5 * HZ; /* Wait 5 sec. after failed dial */
2568 lp->dialstarted = 0; /* Jiffies of last dial-start */
2569 lp->dialwait_timer = 0; /* Jiffies of earliest next dial-start */
2683 isdn_net_local *lp = p->local;
2696 if (lp->p_encap != cfg->p_encap) {
2709 lp->dops = NULL;
2713 lp->dops = &isdn_concap_reliable_dl_dops;
2784 drvidx = lp->pre_device;
2785 chidx = lp->pre_channel;
2793 lp->l2_proto, lp->l3_proto, drvidx,
2794 chidx, lp->msn)) < 0) {
2796 lp->exclusive = -1;
2804 lp->exclusive = i;
2807 lp->exclusive = -1;
2808 if ((lp->pre_device != -1) && (cfg->exclusive == -1)) {
2809 isdn_unexclusive_channel(lp->pre_device, lp->pre_channel);
2810 isdn_free_channel(lp->pre_device, lp->pre_channel, ISDN_USAGE_NET);
2815 strlcpy(lp->msn, cfg->eaz, sizeof(lp->msn));
2816 lp->pre_device = drvidx;
2817 lp->pre_channel = chidx;
2818 lp->onhtime = cfg->onhtime;
2819 lp->charge = cfg->charge;
2820 lp->l2_proto = cfg->l2_proto;
2821 lp->l3_proto = cfg->l3_proto;
2822 lp->cbdelay = cfg->cbdelay;
2823 lp->dialmax = cfg->dialmax;
2824 lp->triggercps = cfg->triggercps;
2825 lp->slavedelay = cfg->slavedelay * HZ;
2826 lp->pppbind = cfg->pppbind;
2827 lp->dialtimeout = cfg->dialtimeout >= 0 ? cfg->dialtimeout * HZ : -1;
2828 lp->dialwait = cfg->dialwait * HZ;
2830 lp->flags |= ISDN_NET_SECURE;
2832 lp->flags &= ~ISDN_NET_SECURE;
2834 lp->flags |= ISDN_NET_CBHUP;
2836 lp->flags &= ~ISDN_NET_CBHUP;
2839 lp->flags &= ~(ISDN_NET_CALLBACK | ISDN_NET_CBOUT);
2842 lp->flags |= ISDN_NET_CALLBACK;
2843 lp->flags &= ~ISDN_NET_CBOUT;
2846 lp->flags |= ISDN_NET_CBOUT;
2847 lp->flags &= ~ISDN_NET_CALLBACK;
2850 lp->flags &= ~ISDN_NET_DIALMODE_MASK; /* first all bits off */
2855 lp->flags |= ISDN_NET_DM_OFF; /* turn on `off' bit */
2858 lp->flags |= cfg->dialmode; /* turn on selected bits */
2861 lp->hupflags |= ISDN_CHARGEHUP;
2863 lp->hupflags &= ~ISDN_CHARGEHUP;
2865 lp->hupflags |= ISDN_INHUP;
2867 lp->hupflags &= ~ISDN_INHUP;
2869 lp->hupflags |= ISDN_CHARGEHUP | ISDN_HAVECHARGE | ISDN_MANCHARGE;
2870 lp->chargeint = cfg->chargeint * HZ;
2872 if (cfg->p_encap != lp->p_encap) {
2884 lp->p_encap = cfg->p_encap;
2899 isdn_net_local *lp = p->local;
2901 strcpy(cfg->eaz, lp->msn);
2902 cfg->exclusive = lp->exclusive;
2903 if (lp->pre_device >= 0) {
2904 sprintf(cfg->drvid, "%s,%d", dev->drvid[lp->pre_device],
2905 lp->pre_channel);
2908 cfg->onhtime = lp->onhtime;
2909 cfg->charge = lp->charge;
2910 cfg->l2_proto = lp->l2_proto;
2911 cfg->l3_proto = lp->l3_proto;
2912 cfg->p_encap = lp->p_encap;
2913 cfg->secure = (lp->flags & ISDN_NET_SECURE) ? 1 : 0;
2915 if (lp->flags & ISDN_NET_CALLBACK)
2917 if (lp->flags & ISDN_NET_CBOUT)
2919 cfg->cbhup = (lp->flags & ISDN_NET_CBHUP) ? 1 : 0;
2920 cfg->dialmode = lp->flags & ISDN_NET_DIALMODE_MASK;
2921 cfg->chargehup = (lp->hupflags & ISDN_CHARGEHUP) ? 1 : 0;
2922 cfg->ihup = (lp->hupflags & ISDN_INHUP) ? 1 : 0;
2923 cfg->cbdelay = lp->cbdelay;
2924 cfg->dialmax = lp->dialmax;
2925 cfg->triggercps = lp->triggercps;
2926 cfg->slavedelay = lp->slavedelay / HZ;
2927 cfg->chargeint = (lp->hupflags & ISDN_CHARGEHUP) ?
2928 (lp->chargeint / HZ) : 0;
2929 cfg->pppbind = lp->pppbind;
2930 cfg->dialtimeout = lp->dialtimeout >= 0 ? lp->dialtimeout / HZ : -1;
2931 cfg->dialwait = lp->dialwait / HZ;
2932 if (lp->slave) {
2933 if (strlen(lp->slave->name) >= 10)
2936 strcpy(cfg->slave, lp->slave->name);
2939 if (lp->master) {
2940 if (strlen(lp->master->name) >= 10)
2943 strcpy(cfg->master, lp->master->name);