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