2 * Generic HDLC support routines for Linux
5 * Copyright (C) 1999 - 2006 Krzysztof Halasa <khc@pm.waw.pl>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License
9 * as published by the Free Software Foundation.
16 (exist,new) -> 0,0 when "PVC create" or if "link unreliable"
17 0,x -> 1,1 if "link reliable" when sending FULL STATUS
18 1,1 -> 1,0 if received FULL STATUS ACK
20 (active) -> 0 when "ifconfig PVC down" or "link unreliable" or "PVC create"
21 -> 1 when "PVC up" and (exist,new) = 1,0
24 (exist,new,active) = FULL STATUS if "link reliable"
25 = 0, 0, 0 if "link unreliable"
27 active = open and "link reliable"
28 exist = new = not used
30 CCITT LMI: ITU-T Q.933 Annex A
31 ANSI LMI: ANSI T1.617 Annex D
32 CISCO LMI: the original, aka "Gang of Four" LMI
36 #include <linux/module.h>
37 #include <linux/kernel.h>
38 #include <linux/slab.h>
39 #include <linux/poll.h>
40 #include <linux/errno.h>
41 #include <linux/if_arp.h>
42 #include <linux/init.h>
43 #include <linux/skbuff.h>
44 #include <linux/pkt_sched.h>
45 #include <linux/random.h>
46 #include <linux/inetdevice.h>
47 #include <linux/lapb.h>
48 #include <linux/rtnetlink.h>
49 #include <linux/etherdevice.h>
50 #include <linux/hdlc.h>
62 #define NLPID_IPV6 0x8E
63 #define NLPID_SNAP 0x80
64 #define NLPID_PAD 0x00
65 #define NLPID_CCITT_ANSI_LMI 0x08
66 #define NLPID_CISCO_LMI 0x09
69 #define LMI_CCITT_ANSI_DLCI 0 /* LMI DLCI */
70 #define LMI_CISCO_DLCI 1023
72 #define LMI_CALLREF 0x00 /* Call Reference */
73 #define LMI_ANSI_LOCKSHIFT 0x95 /* ANSI locking shift */
74 #define LMI_ANSI_CISCO_REPTYPE 0x01 /* report type */
75 #define LMI_CCITT_REPTYPE 0x51
76 #define LMI_ANSI_CISCO_ALIVE 0x03 /* keep alive */
77 #define LMI_CCITT_ALIVE 0x53
78 #define LMI_ANSI_CISCO_PVCSTAT 0x07 /* PVC status */
79 #define LMI_CCITT_PVCSTAT 0x57
81 #define LMI_FULLREP 0x00 /* full report */
82 #define LMI_INTEGRITY 0x01 /* link integrity report */
83 #define LMI_SINGLE 0x02 /* single PVC report */
85 #define LMI_STATUS_ENQUIRY 0x75
86 #define LMI_STATUS 0x7D /* reply */
88 #define LMI_REPT_LEN 1 /* report type element length */
89 #define LMI_INTEG_LEN 2 /* link integrity element length */
91 #define LMI_CCITT_CISCO_LENGTH 13 /* LMI frame lengths */
92 #define LMI_ANSI_LENGTH 14
96 #if defined(__LITTLE_ENDIAN_BITFIELD)
117 }__attribute__ ((packed
)) fr_hdr
;
120 typedef struct pvc_device_struct
{
121 struct net_device
*frad
;
122 struct net_device
*main
;
123 struct net_device
*ether
; /* bridged Ethernet interface */
124 struct pvc_device_struct
*next
; /* Sorted in ascending DLCI order */
130 unsigned int active
: 1;
131 unsigned int exist
: 1;
132 unsigned int deleted
: 1;
133 unsigned int fecn
: 1;
134 unsigned int becn
: 1;
135 unsigned int bandwidth
; /* Cisco LMI reporting only */
140 struct net_device_stats stats
;
146 pvc_device
*first_pvc
;
149 struct timer_list timer
;
150 unsigned long last_poll
;
155 u32 last_errors
; /* last errors bit list */
157 u8 txseq
; /* TX sequence number */
158 u8 rxseq
; /* RX sequence number */
162 static int fr_ioctl(struct net_device
*dev
, struct ifreq
*ifr
);
165 static inline u16
q922_to_dlci(u8
*hdr
)
167 return ((hdr
[0] & 0xFC) << 2) | ((hdr
[1] & 0xF0) >> 4);
171 static inline void dlci_to_q922(u8
*hdr
, u16 dlci
)
173 hdr
[0] = (dlci
>> 2) & 0xFC;
174 hdr
[1] = ((dlci
<< 4) & 0xF0) | 0x01;
178 static inline struct frad_state
* state(hdlc_device
*hdlc
)
180 return(struct frad_state
*)(hdlc
->state
);
183 static inline struct pvc_desc
* pvcdev_to_desc(struct net_device
*dev
)
188 static inline struct net_device_stats
* pvc_get_stats(struct net_device
*dev
)
190 return &pvcdev_to_desc(dev
)->stats
;
193 static inline pvc_device
* find_pvc(hdlc_device
*hdlc
, u16 dlci
)
195 pvc_device
*pvc
= state(hdlc
)->first_pvc
;
198 if (pvc
->dlci
== dlci
)
200 if (pvc
->dlci
> dlci
)
201 return NULL
; /* the listed is sorted */
209 static pvc_device
* add_pvc(struct net_device
*dev
, u16 dlci
)
211 hdlc_device
*hdlc
= dev_to_hdlc(dev
);
212 pvc_device
*pvc
, **pvc_p
= &state(hdlc
)->first_pvc
;
215 if ((*pvc_p
)->dlci
== dlci
)
217 if ((*pvc_p
)->dlci
> dlci
)
218 break; /* the list is sorted */
219 pvc_p
= &(*pvc_p
)->next
;
222 pvc
= kzalloc(sizeof(pvc_device
), GFP_ATOMIC
);
224 printk(KERN_DEBUG
"add_pvc: allocated pvc %p, frad %p\n", pvc
, dev
);
231 pvc
->next
= *pvc_p
; /* Put it in the chain */
237 static inline int pvc_is_used(pvc_device
*pvc
)
239 return pvc
->main
|| pvc
->ether
;
243 static inline void pvc_carrier(int on
, pvc_device
*pvc
)
247 if (!netif_carrier_ok(pvc
->main
))
248 netif_carrier_on(pvc
->main
);
250 if (!netif_carrier_ok(pvc
->ether
))
251 netif_carrier_on(pvc
->ether
);
254 if (netif_carrier_ok(pvc
->main
))
255 netif_carrier_off(pvc
->main
);
257 if (netif_carrier_ok(pvc
->ether
))
258 netif_carrier_off(pvc
->ether
);
263 static inline void delete_unused_pvcs(hdlc_device
*hdlc
)
265 pvc_device
**pvc_p
= &state(hdlc
)->first_pvc
;
268 if (!pvc_is_used(*pvc_p
)) {
269 pvc_device
*pvc
= *pvc_p
;
271 printk(KERN_DEBUG
"freeing unused pvc: %p\n", pvc
);
277 pvc_p
= &(*pvc_p
)->next
;
282 static inline struct net_device
** get_dev_p(pvc_device
*pvc
, int type
)
284 if (type
== ARPHRD_ETHER
)
291 static int fr_hard_header(struct sk_buff
**skb_p
, u16 dlci
)
294 struct sk_buff
*skb
= *skb_p
;
296 switch (skb
->protocol
) {
297 case __constant_htons(NLPID_CCITT_ANSI_LMI
):
299 skb_push(skb
, head_len
);
300 skb
->data
[3] = NLPID_CCITT_ANSI_LMI
;
303 case __constant_htons(NLPID_CISCO_LMI
):
305 skb_push(skb
, head_len
);
306 skb
->data
[3] = NLPID_CISCO_LMI
;
309 case __constant_htons(ETH_P_IP
):
311 skb_push(skb
, head_len
);
312 skb
->data
[3] = NLPID_IP
;
315 case __constant_htons(ETH_P_IPV6
):
317 skb_push(skb
, head_len
);
318 skb
->data
[3] = NLPID_IPV6
;
321 case __constant_htons(ETH_P_802_3
):
323 if (skb_headroom(skb
) < head_len
) {
324 struct sk_buff
*skb2
= skb_realloc_headroom(skb
,
331 skb_push(skb
, head_len
);
332 skb
->data
[3] = FR_PAD
;
333 skb
->data
[4] = NLPID_SNAP
;
334 skb
->data
[5] = FR_PAD
;
338 skb
->data
[9] = 0x07; /* bridged Ethernet frame w/out FCS */
343 skb_push(skb
, head_len
);
344 skb
->data
[3] = FR_PAD
;
345 skb
->data
[4] = NLPID_SNAP
;
346 skb
->data
[5] = FR_PAD
;
347 skb
->data
[6] = FR_PAD
;
348 skb
->data
[7] = FR_PAD
;
349 *(__be16
*)(skb
->data
+ 8) = skb
->protocol
;
352 dlci_to_q922(skb
->data
, dlci
);
353 skb
->data
[2] = FR_UI
;
359 static int pvc_open(struct net_device
*dev
)
361 pvc_device
*pvc
= pvcdev_to_desc(dev
)->pvc
;
363 if ((pvc
->frad
->flags
& IFF_UP
) == 0)
364 return -EIO
; /* Frad must be UP in order to activate PVC */
366 if (pvc
->open_count
++ == 0) {
367 hdlc_device
*hdlc
= dev_to_hdlc(pvc
->frad
);
368 if (state(hdlc
)->settings
.lmi
== LMI_NONE
)
369 pvc
->state
.active
= netif_carrier_ok(pvc
->frad
);
371 pvc_carrier(pvc
->state
.active
, pvc
);
372 state(hdlc
)->dce_changed
= 1;
379 static int pvc_close(struct net_device
*dev
)
381 pvc_device
*pvc
= pvcdev_to_desc(dev
)->pvc
;
383 if (--pvc
->open_count
== 0) {
384 hdlc_device
*hdlc
= dev_to_hdlc(pvc
->frad
);
385 if (state(hdlc
)->settings
.lmi
== LMI_NONE
)
386 pvc
->state
.active
= 0;
388 if (state(hdlc
)->settings
.dce
) {
389 state(hdlc
)->dce_changed
= 1;
390 pvc
->state
.active
= 0;
398 static int pvc_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
400 pvc_device
*pvc
= pvcdev_to_desc(dev
)->pvc
;
401 fr_proto_pvc_info info
;
403 if (ifr
->ifr_settings
.type
== IF_GET_PROTO
) {
404 if (dev
->type
== ARPHRD_ETHER
)
405 ifr
->ifr_settings
.type
= IF_PROTO_FR_ETH_PVC
;
407 ifr
->ifr_settings
.type
= IF_PROTO_FR_PVC
;
409 if (ifr
->ifr_settings
.size
< sizeof(info
)) {
410 /* data size wanted */
411 ifr
->ifr_settings
.size
= sizeof(info
);
415 info
.dlci
= pvc
->dlci
;
416 memcpy(info
.master
, pvc
->frad
->name
, IFNAMSIZ
);
417 if (copy_to_user(ifr
->ifr_settings
.ifs_ifsu
.fr_pvc_info
,
418 &info
, sizeof(info
)))
426 static int pvc_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
428 pvc_device
*pvc
= pvcdev_to_desc(dev
)->pvc
;
429 struct net_device_stats
*stats
= pvc_get_stats(dev
);
431 if (pvc
->state
.active
) {
432 if (dev
->type
== ARPHRD_ETHER
) {
433 int pad
= ETH_ZLEN
- skb
->len
;
434 if (pad
> 0) { /* Pad the frame with zeros */
436 if (skb_tailroom(skb
) < pad
)
437 if (pskb_expand_head(skb
, 0, pad
,
444 memset(skb
->data
+ len
, 0, pad
);
446 skb
->protocol
= __constant_htons(ETH_P_802_3
);
448 if (!fr_hard_header(&skb
, pvc
->dlci
)) {
449 stats
->tx_bytes
+= skb
->len
;
451 if (pvc
->state
.fecn
) /* TX Congestion counter */
452 stats
->tx_compressed
++;
453 skb
->dev
= pvc
->frad
;
466 static int pvc_change_mtu(struct net_device
*dev
, int new_mtu
)
468 if ((new_mtu
< 68) || (new_mtu
> HDLC_MAX_MTU
))
476 static inline void fr_log_dlci_active(pvc_device
*pvc
)
478 printk(KERN_INFO
"%s: DLCI %d [%s%s%s]%s %s\n",
481 pvc
->main
? pvc
->main
->name
: "",
482 pvc
->main
&& pvc
->ether
? " " : "",
483 pvc
->ether
? pvc
->ether
->name
: "",
484 pvc
->state
.new ? " new" : "",
485 !pvc
->state
.exist
? "deleted" :
486 pvc
->state
.active
? "active" : "inactive");
491 static inline u8
fr_lmi_nextseq(u8 x
)
498 static void fr_lmi_send(struct net_device
*dev
, int fullrep
)
500 hdlc_device
*hdlc
= dev_to_hdlc(dev
);
502 pvc_device
*pvc
= state(hdlc
)->first_pvc
;
503 int lmi
= state(hdlc
)->settings
.lmi
;
504 int dce
= state(hdlc
)->settings
.dce
;
505 int len
= lmi
== LMI_ANSI
? LMI_ANSI_LENGTH
: LMI_CCITT_CISCO_LENGTH
;
506 int stat_len
= (lmi
== LMI_CISCO
) ? 6 : 3;
510 if (dce
&& fullrep
) {
511 len
+= state(hdlc
)->dce_pvc_count
* (2 + stat_len
);
512 if (len
> HDLC_MAX_MRU
) {
513 printk(KERN_WARNING
"%s: Too many PVCs while sending "
514 "LMI full report\n", dev
->name
);
519 skb
= dev_alloc_skb(len
);
521 printk(KERN_WARNING
"%s: Memory squeeze on fr_lmi_send()\n",
525 memset(skb
->data
, 0, len
);
527 if (lmi
== LMI_CISCO
) {
528 skb
->protocol
= __constant_htons(NLPID_CISCO_LMI
);
529 fr_hard_header(&skb
, LMI_CISCO_DLCI
);
531 skb
->protocol
= __constant_htons(NLPID_CCITT_ANSI_LMI
);
532 fr_hard_header(&skb
, LMI_CCITT_ANSI_DLCI
);
534 data
= skb_tail_pointer(skb
);
535 data
[i
++] = LMI_CALLREF
;
536 data
[i
++] = dce
? LMI_STATUS
: LMI_STATUS_ENQUIRY
;
538 data
[i
++] = LMI_ANSI_LOCKSHIFT
;
539 data
[i
++] = lmi
== LMI_CCITT
? LMI_CCITT_REPTYPE
:
540 LMI_ANSI_CISCO_REPTYPE
;
541 data
[i
++] = LMI_REPT_LEN
;
542 data
[i
++] = fullrep
? LMI_FULLREP
: LMI_INTEGRITY
;
543 data
[i
++] = lmi
== LMI_CCITT
? LMI_CCITT_ALIVE
: LMI_ANSI_CISCO_ALIVE
;
544 data
[i
++] = LMI_INTEG_LEN
;
545 data
[i
++] = state(hdlc
)->txseq
=
546 fr_lmi_nextseq(state(hdlc
)->txseq
);
547 data
[i
++] = state(hdlc
)->rxseq
;
549 if (dce
&& fullrep
) {
551 data
[i
++] = lmi
== LMI_CCITT
? LMI_CCITT_PVCSTAT
:
552 LMI_ANSI_CISCO_PVCSTAT
;
553 data
[i
++] = stat_len
;
555 /* LMI start/restart */
556 if (state(hdlc
)->reliable
&& !pvc
->state
.exist
) {
557 pvc
->state
.exist
= pvc
->state
.new = 1;
558 fr_log_dlci_active(pvc
);
561 /* ifconfig PVC up */
562 if (pvc
->open_count
&& !pvc
->state
.active
&&
563 pvc
->state
.exist
&& !pvc
->state
.new) {
565 pvc
->state
.active
= 1;
566 fr_log_dlci_active(pvc
);
569 if (lmi
== LMI_CISCO
) {
570 data
[i
] = pvc
->dlci
>> 8;
571 data
[i
+ 1] = pvc
->dlci
& 0xFF;
573 data
[i
] = (pvc
->dlci
>> 4) & 0x3F;
574 data
[i
+ 1] = ((pvc
->dlci
<< 3) & 0x78) | 0x80;
580 else if (pvc
->state
.active
)
589 skb
->priority
= TC_PRIO_CONTROL
;
591 skb_reset_network_header(skb
);
598 static void fr_set_link_state(int reliable
, struct net_device
*dev
)
600 hdlc_device
*hdlc
= dev_to_hdlc(dev
);
601 pvc_device
*pvc
= state(hdlc
)->first_pvc
;
603 state(hdlc
)->reliable
= reliable
;
605 netif_dormant_off(dev
);
606 state(hdlc
)->n391cnt
= 0; /* Request full status */
607 state(hdlc
)->dce_changed
= 1;
609 if (state(hdlc
)->settings
.lmi
== LMI_NONE
) {
610 while (pvc
) { /* Activate all PVCs */
612 pvc
->state
.exist
= pvc
->state
.active
= 1;
618 netif_dormant_on(dev
);
619 while (pvc
) { /* Deactivate all PVCs */
621 pvc
->state
.exist
= pvc
->state
.active
= 0;
623 if (!state(hdlc
)->settings
.dce
)
624 pvc
->state
.bandwidth
= 0;
631 static void fr_timer(unsigned long arg
)
633 struct net_device
*dev
= (struct net_device
*)arg
;
634 hdlc_device
*hdlc
= dev_to_hdlc(dev
);
635 int i
, cnt
= 0, reliable
;
638 if (state(hdlc
)->settings
.dce
) {
639 reliable
= state(hdlc
)->request
&&
640 time_before(jiffies
, state(hdlc
)->last_poll
+
641 state(hdlc
)->settings
.t392
* HZ
);
642 state(hdlc
)->request
= 0;
644 state(hdlc
)->last_errors
<<= 1; /* Shift the list */
645 if (state(hdlc
)->request
) {
646 if (state(hdlc
)->reliable
)
647 printk(KERN_INFO
"%s: No LMI status reply "
648 "received\n", dev
->name
);
649 state(hdlc
)->last_errors
|= 1;
652 list
= state(hdlc
)->last_errors
;
653 for (i
= 0; i
< state(hdlc
)->settings
.n393
; i
++, list
>>= 1)
654 cnt
+= (list
& 1); /* errors count */
656 reliable
= (cnt
< state(hdlc
)->settings
.n392
);
659 if (state(hdlc
)->reliable
!= reliable
) {
660 printk(KERN_INFO
"%s: Link %sreliable\n", dev
->name
,
661 reliable
? "" : "un");
662 fr_set_link_state(reliable
, dev
);
665 if (state(hdlc
)->settings
.dce
)
666 state(hdlc
)->timer
.expires
= jiffies
+
667 state(hdlc
)->settings
.t392
* HZ
;
669 if (state(hdlc
)->n391cnt
)
670 state(hdlc
)->n391cnt
--;
672 fr_lmi_send(dev
, state(hdlc
)->n391cnt
== 0);
674 state(hdlc
)->last_poll
= jiffies
;
675 state(hdlc
)->request
= 1;
676 state(hdlc
)->timer
.expires
= jiffies
+
677 state(hdlc
)->settings
.t391
* HZ
;
680 state(hdlc
)->timer
.function
= fr_timer
;
681 state(hdlc
)->timer
.data
= arg
;
682 add_timer(&state(hdlc
)->timer
);
686 static int fr_lmi_recv(struct net_device
*dev
, struct sk_buff
*skb
)
688 hdlc_device
*hdlc
= dev_to_hdlc(dev
);
691 int lmi
= state(hdlc
)->settings
.lmi
;
692 int dce
= state(hdlc
)->settings
.dce
;
693 int stat_len
= (lmi
== LMI_CISCO
) ? 6 : 3, reptype
, error
, no_ram
, i
;
695 if (skb
->len
< (lmi
== LMI_ANSI
? LMI_ANSI_LENGTH
:
696 LMI_CCITT_CISCO_LENGTH
)) {
697 printk(KERN_INFO
"%s: Short LMI frame\n", dev
->name
);
701 if (skb
->data
[3] != (lmi
== LMI_CISCO
? NLPID_CISCO_LMI
:
702 NLPID_CCITT_ANSI_LMI
)) {
703 printk(KERN_INFO
"%s: Received non-LMI frame with LMI DLCI\n",
708 if (skb
->data
[4] != LMI_CALLREF
) {
709 printk(KERN_INFO
"%s: Invalid LMI Call reference (0x%02X)\n",
710 dev
->name
, skb
->data
[4]);
714 if (skb
->data
[5] != (dce
? LMI_STATUS_ENQUIRY
: LMI_STATUS
)) {
715 printk(KERN_INFO
"%s: Invalid LMI Message type (0x%02X)\n",
716 dev
->name
, skb
->data
[5]);
720 if (lmi
== LMI_ANSI
) {
721 if (skb
->data
[6] != LMI_ANSI_LOCKSHIFT
) {
722 printk(KERN_INFO
"%s: Not ANSI locking shift in LMI"
723 " message (0x%02X)\n", dev
->name
, skb
->data
[6]);
730 if (skb
->data
[i
] != (lmi
== LMI_CCITT
? LMI_CCITT_REPTYPE
:
731 LMI_ANSI_CISCO_REPTYPE
)) {
732 printk(KERN_INFO
"%s: Not an LMI Report type IE (0x%02X)\n",
733 dev
->name
, skb
->data
[i
]);
737 if (skb
->data
[++i
] != LMI_REPT_LEN
) {
738 printk(KERN_INFO
"%s: Invalid LMI Report type IE length"
739 " (%u)\n", dev
->name
, skb
->data
[i
]);
743 reptype
= skb
->data
[++i
];
744 if (reptype
!= LMI_INTEGRITY
&& reptype
!= LMI_FULLREP
) {
745 printk(KERN_INFO
"%s: Unsupported LMI Report type (0x%02X)\n",
750 if (skb
->data
[++i
] != (lmi
== LMI_CCITT
? LMI_CCITT_ALIVE
:
751 LMI_ANSI_CISCO_ALIVE
)) {
752 printk(KERN_INFO
"%s: Not an LMI Link integrity verification"
753 " IE (0x%02X)\n", dev
->name
, skb
->data
[i
]);
757 if (skb
->data
[++i
] != LMI_INTEG_LEN
) {
758 printk(KERN_INFO
"%s: Invalid LMI Link integrity verification"
759 " IE length (%u)\n", dev
->name
, skb
->data
[i
]);
764 state(hdlc
)->rxseq
= skb
->data
[i
++]; /* TX sequence from peer */
765 rxseq
= skb
->data
[i
++]; /* Should confirm our sequence */
767 txseq
= state(hdlc
)->txseq
;
770 state(hdlc
)->last_poll
= jiffies
;
773 if (!state(hdlc
)->reliable
)
776 if (rxseq
== 0 || rxseq
!= txseq
) { /* Ask for full report next time */
777 state(hdlc
)->n391cnt
= 0;
782 if (state(hdlc
)->fullrep_sent
&& !error
) {
783 /* Stop sending full report - the last one has been confirmed by DTE */
784 state(hdlc
)->fullrep_sent
= 0;
785 pvc
= state(hdlc
)->first_pvc
;
787 if (pvc
->state
.new) {
790 /* Tell DTE that new PVC is now active */
791 state(hdlc
)->dce_changed
= 1;
797 if (state(hdlc
)->dce_changed
) {
798 reptype
= LMI_FULLREP
;
799 state(hdlc
)->fullrep_sent
= 1;
800 state(hdlc
)->dce_changed
= 0;
803 state(hdlc
)->request
= 1; /* got request */
804 fr_lmi_send(dev
, reptype
== LMI_FULLREP
? 1 : 0);
810 state(hdlc
)->request
= 0; /* got response, no request pending */
815 if (reptype
!= LMI_FULLREP
)
818 pvc
= state(hdlc
)->first_pvc
;
821 pvc
->state
.deleted
= 1;
826 while (skb
->len
>= i
+ 2 + stat_len
) {
829 unsigned int active
, new;
831 if (skb
->data
[i
] != (lmi
== LMI_CCITT
? LMI_CCITT_PVCSTAT
:
832 LMI_ANSI_CISCO_PVCSTAT
)) {
833 printk(KERN_INFO
"%s: Not an LMI PVC status IE"
834 " (0x%02X)\n", dev
->name
, skb
->data
[i
]);
838 if (skb
->data
[++i
] != stat_len
) {
839 printk(KERN_INFO
"%s: Invalid LMI PVC status IE length"
840 " (%u)\n", dev
->name
, skb
->data
[i
]);
845 new = !! (skb
->data
[i
+ 2] & 0x08);
846 active
= !! (skb
->data
[i
+ 2] & 0x02);
847 if (lmi
== LMI_CISCO
) {
848 dlci
= (skb
->data
[i
] << 8) | skb
->data
[i
+ 1];
849 bw
= (skb
->data
[i
+ 3] << 16) |
850 (skb
->data
[i
+ 4] << 8) |
853 dlci
= ((skb
->data
[i
] & 0x3F) << 4) |
854 ((skb
->data
[i
+ 1] & 0x78) >> 3);
858 pvc
= add_pvc(dev
, dlci
);
860 if (!pvc
&& !no_ram
) {
862 "%s: Memory squeeze on fr_lmi_recv()\n",
868 pvc
->state
.exist
= 1;
869 pvc
->state
.deleted
= 0;
870 if (active
!= pvc
->state
.active
||
871 new != pvc
->state
.new ||
872 bw
!= pvc
->state
.bandwidth
||
874 pvc
->state
.new = new;
875 pvc
->state
.active
= active
;
876 pvc
->state
.bandwidth
= bw
;
877 pvc_carrier(active
, pvc
);
878 fr_log_dlci_active(pvc
);
885 pvc
= state(hdlc
)->first_pvc
;
888 if (pvc
->state
.deleted
&& pvc
->state
.exist
) {
890 pvc
->state
.active
= pvc
->state
.new = 0;
891 pvc
->state
.exist
= 0;
892 pvc
->state
.bandwidth
= 0;
893 fr_log_dlci_active(pvc
);
898 /* Next full report after N391 polls */
899 state(hdlc
)->n391cnt
= state(hdlc
)->settings
.n391
;
905 static int fr_rx(struct sk_buff
*skb
)
907 struct net_device
*frad
= skb
->dev
;
908 hdlc_device
*hdlc
= dev_to_hdlc(frad
);
909 fr_hdr
*fh
= (fr_hdr
*)skb
->data
;
910 u8
*data
= skb
->data
;
913 struct net_device
*dev
= NULL
;
915 if (skb
->len
<= 4 || fh
->ea1
|| data
[2] != FR_UI
)
918 dlci
= q922_to_dlci(skb
->data
);
920 if ((dlci
== LMI_CCITT_ANSI_DLCI
&&
921 (state(hdlc
)->settings
.lmi
== LMI_ANSI
||
922 state(hdlc
)->settings
.lmi
== LMI_CCITT
)) ||
923 (dlci
== LMI_CISCO_DLCI
&&
924 state(hdlc
)->settings
.lmi
== LMI_CISCO
)) {
925 if (fr_lmi_recv(frad
, skb
))
927 dev_kfree_skb_any(skb
);
928 return NET_RX_SUCCESS
;
931 pvc
= find_pvc(hdlc
, dlci
);
934 printk(KERN_INFO
"%s: No PVC for received frame's DLCI %d\n",
937 dev_kfree_skb_any(skb
);
941 if (pvc
->state
.fecn
!= fh
->fecn
) {
943 printk(KERN_DEBUG
"%s: DLCI %d FECN O%s\n", frad
->name
,
944 dlci
, fh
->fecn
? "N" : "FF");
946 pvc
->state
.fecn
^= 1;
949 if (pvc
->state
.becn
!= fh
->becn
) {
951 printk(KERN_DEBUG
"%s: DLCI %d BECN O%s\n", frad
->name
,
952 dlci
, fh
->becn
? "N" : "FF");
954 pvc
->state
.becn
^= 1;
958 if ((skb
= skb_share_check(skb
, GFP_ATOMIC
)) == NULL
) {
959 dev_to_hdlc(frad
)->stats
.rx_dropped
++;
963 if (data
[3] == NLPID_IP
) {
964 skb_pull(skb
, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
966 skb
->protocol
= htons(ETH_P_IP
);
968 } else if (data
[3] == NLPID_IPV6
) {
969 skb_pull(skb
, 4); /* Remove 4-byte header (hdr, UI, NLPID) */
971 skb
->protocol
= htons(ETH_P_IPV6
);
973 } else if (skb
->len
> 10 && data
[3] == FR_PAD
&&
974 data
[4] == NLPID_SNAP
&& data
[5] == FR_PAD
) {
975 u16 oui
= ntohs(*(__be16
*)(data
+ 6));
976 u16 pid
= ntohs(*(__be16
*)(data
+ 8));
979 switch ((((u32
)oui
) << 16) | pid
) {
980 case ETH_P_ARP
: /* routed frame with SNAP */
982 case ETH_P_IP
: /* a long variant */
985 skb
->protocol
= htons(pid
);
988 case 0x80C20007: /* bridged Ethernet frame */
989 if ((dev
= pvc
->ether
) != NULL
)
990 skb
->protocol
= eth_type_trans(skb
, dev
);
994 printk(KERN_INFO
"%s: Unsupported protocol, OUI=%x "
995 "PID=%x\n", frad
->name
, oui
, pid
);
996 dev_kfree_skb_any(skb
);
1000 printk(KERN_INFO
"%s: Unsupported protocol, NLPID=%x "
1001 "length = %i\n", frad
->name
, data
[3], skb
->len
);
1002 dev_kfree_skb_any(skb
);
1007 struct net_device_stats
*stats
= pvc_get_stats(dev
);
1008 stats
->rx_packets
++; /* PVC traffic */
1009 stats
->rx_bytes
+= skb
->len
;
1010 if (pvc
->state
.becn
)
1011 stats
->rx_compressed
++;
1013 return NET_RX_SUCCESS
;
1015 dev_kfree_skb_any(skb
);
1020 dev_to_hdlc(frad
)->stats
.rx_errors
++; /* Mark error */
1021 dev_kfree_skb_any(skb
);
1027 static void fr_start(struct net_device
*dev
)
1029 hdlc_device
*hdlc
= dev_to_hdlc(dev
);
1031 printk(KERN_DEBUG
"fr_start\n");
1033 if (state(hdlc
)->settings
.lmi
!= LMI_NONE
) {
1034 state(hdlc
)->reliable
= 0;
1035 state(hdlc
)->dce_changed
= 1;
1036 state(hdlc
)->request
= 0;
1037 state(hdlc
)->fullrep_sent
= 0;
1038 state(hdlc
)->last_errors
= 0xFFFFFFFF;
1039 state(hdlc
)->n391cnt
= 0;
1040 state(hdlc
)->txseq
= state(hdlc
)->rxseq
= 0;
1042 init_timer(&state(hdlc
)->timer
);
1043 /* First poll after 1 s */
1044 state(hdlc
)->timer
.expires
= jiffies
+ HZ
;
1045 state(hdlc
)->timer
.function
= fr_timer
;
1046 state(hdlc
)->timer
.data
= (unsigned long)dev
;
1047 add_timer(&state(hdlc
)->timer
);
1049 fr_set_link_state(1, dev
);
1053 static void fr_stop(struct net_device
*dev
)
1055 hdlc_device
*hdlc
= dev_to_hdlc(dev
);
1057 printk(KERN_DEBUG
"fr_stop\n");
1059 if (state(hdlc
)->settings
.lmi
!= LMI_NONE
)
1060 del_timer_sync(&state(hdlc
)->timer
);
1061 fr_set_link_state(0, dev
);
1065 static void fr_close(struct net_device
*dev
)
1067 hdlc_device
*hdlc
= dev_to_hdlc(dev
);
1068 pvc_device
*pvc
= state(hdlc
)->first_pvc
;
1070 while (pvc
) { /* Shutdown all PVCs for this FRAD */
1072 dev_close(pvc
->main
);
1074 dev_close(pvc
->ether
);
1080 static void pvc_setup(struct net_device
*dev
)
1082 dev
->type
= ARPHRD_DLCI
;
1083 dev
->flags
= IFF_POINTOPOINT
;
1084 dev
->hard_header_len
= 10;
1088 static int fr_add_pvc(struct net_device
*frad
, unsigned int dlci
, int type
)
1090 hdlc_device
*hdlc
= dev_to_hdlc(frad
);
1091 pvc_device
*pvc
= NULL
;
1092 struct net_device
*dev
;
1094 char * prefix
= "pvc%d";
1096 if (type
== ARPHRD_ETHER
)
1097 prefix
= "pvceth%d";
1099 if ((pvc
= add_pvc(frad
, dlci
)) == NULL
) {
1100 printk(KERN_WARNING
"%s: Memory squeeze on fr_add_pvc()\n",
1105 if (*get_dev_p(pvc
, type
))
1108 used
= pvc_is_used(pvc
);
1110 if (type
== ARPHRD_ETHER
)
1111 dev
= alloc_netdev(sizeof(struct pvc_desc
), "pvceth%d",
1114 dev
= alloc_netdev(sizeof(struct pvc_desc
), "pvc%d", pvc_setup
);
1117 printk(KERN_WARNING
"%s: Memory squeeze on fr_pvc()\n",
1119 delete_unused_pvcs(hdlc
);
1123 if (type
== ARPHRD_ETHER
) {
1124 memcpy(dev
->dev_addr
, "\x00\x01", 2);
1125 get_random_bytes(dev
->dev_addr
+ 2, ETH_ALEN
- 2);
1127 *(__be16
*)dev
->dev_addr
= htons(dlci
);
1128 dlci_to_q922(dev
->broadcast
, dlci
);
1130 dev
->hard_start_xmit
= pvc_xmit
;
1131 dev
->get_stats
= pvc_get_stats
;
1132 dev
->open
= pvc_open
;
1133 dev
->stop
= pvc_close
;
1134 dev
->do_ioctl
= pvc_ioctl
;
1135 dev
->change_mtu
= pvc_change_mtu
;
1136 dev
->mtu
= HDLC_MAX_MTU
;
1137 dev
->tx_queue_len
= 0;
1138 pvcdev_to_desc(dev
)->pvc
= pvc
;
1140 result
= dev_alloc_name(dev
, dev
->name
);
1143 delete_unused_pvcs(hdlc
);
1147 if (register_netdevice(dev
) != 0) {
1149 delete_unused_pvcs(hdlc
);
1153 dev
->destructor
= free_netdev
;
1154 *get_dev_p(pvc
, type
) = dev
;
1156 state(hdlc
)->dce_changed
= 1;
1157 state(hdlc
)->dce_pvc_count
++;
1164 static int fr_del_pvc(hdlc_device
*hdlc
, unsigned int dlci
, int type
)
1167 struct net_device
*dev
;
1169 if ((pvc
= find_pvc(hdlc
, dlci
)) == NULL
)
1172 if ((dev
= *get_dev_p(pvc
, type
)) == NULL
)
1175 if (dev
->flags
& IFF_UP
)
1176 return -EBUSY
; /* PVC in use */
1178 unregister_netdevice(dev
); /* the destructor will free_netdev(dev) */
1179 *get_dev_p(pvc
, type
) = NULL
;
1181 if (!pvc_is_used(pvc
)) {
1182 state(hdlc
)->dce_pvc_count
--;
1183 state(hdlc
)->dce_changed
= 1;
1185 delete_unused_pvcs(hdlc
);
1191 static void fr_destroy(struct net_device
*frad
)
1193 hdlc_device
*hdlc
= dev_to_hdlc(frad
);
1194 pvc_device
*pvc
= state(hdlc
)->first_pvc
;
1195 state(hdlc
)->first_pvc
= NULL
; /* All PVCs destroyed */
1196 state(hdlc
)->dce_pvc_count
= 0;
1197 state(hdlc
)->dce_changed
= 1;
1200 pvc_device
*next
= pvc
->next
;
1201 /* destructors will free_netdev() main and ether */
1203 unregister_netdevice(pvc
->main
);
1206 unregister_netdevice(pvc
->ether
);
1214 static struct hdlc_proto proto
= {
1218 .detach
= fr_destroy
,
1221 .module
= THIS_MODULE
,
1225 static int fr_ioctl(struct net_device
*dev
, struct ifreq
*ifr
)
1227 fr_proto __user
*fr_s
= ifr
->ifr_settings
.ifs_ifsu
.fr
;
1228 const size_t size
= sizeof(fr_proto
);
1229 fr_proto new_settings
;
1230 hdlc_device
*hdlc
= dev_to_hdlc(dev
);
1234 switch (ifr
->ifr_settings
.type
) {
1236 if (dev_to_hdlc(dev
)->proto
!= &proto
) /* Different proto */
1238 ifr
->ifr_settings
.type
= IF_PROTO_FR
;
1239 if (ifr
->ifr_settings
.size
< size
) {
1240 ifr
->ifr_settings
.size
= size
; /* data size wanted */
1243 if (copy_to_user(fr_s
, &state(hdlc
)->settings
, size
))
1248 if(!capable(CAP_NET_ADMIN
))
1251 if(dev
->flags
& IFF_UP
)
1254 if (copy_from_user(&new_settings
, fr_s
, size
))
1257 if (new_settings
.lmi
== LMI_DEFAULT
)
1258 new_settings
.lmi
= LMI_ANSI
;
1260 if ((new_settings
.lmi
!= LMI_NONE
&&
1261 new_settings
.lmi
!= LMI_ANSI
&&
1262 new_settings
.lmi
!= LMI_CCITT
&&
1263 new_settings
.lmi
!= LMI_CISCO
) ||
1264 new_settings
.t391
< 1 ||
1265 new_settings
.t392
< 2 ||
1266 new_settings
.n391
< 1 ||
1267 new_settings
.n392
< 1 ||
1268 new_settings
.n393
< new_settings
.n392
||
1269 new_settings
.n393
> 32 ||
1270 (new_settings
.dce
!= 0 &&
1271 new_settings
.dce
!= 1))
1274 result
=hdlc
->attach(dev
, ENCODING_NRZ
,PARITY_CRC16_PR1_CCITT
);
1278 if (dev_to_hdlc(dev
)->proto
!= &proto
) { /* Different proto */
1279 result
= attach_hdlc_protocol(dev
, &proto
,
1280 sizeof(struct frad_state
));
1283 state(hdlc
)->first_pvc
= NULL
;
1284 state(hdlc
)->dce_pvc_count
= 0;
1286 memcpy(&state(hdlc
)->settings
, &new_settings
, size
);
1288 dev
->hard_start_xmit
= hdlc
->xmit
;
1289 dev
->type
= ARPHRD_FRAD
;
1292 case IF_PROTO_FR_ADD_PVC
:
1293 case IF_PROTO_FR_DEL_PVC
:
1294 case IF_PROTO_FR_ADD_ETH_PVC
:
1295 case IF_PROTO_FR_DEL_ETH_PVC
:
1296 if (dev_to_hdlc(dev
)->proto
!= &proto
) /* Different proto */
1299 if(!capable(CAP_NET_ADMIN
))
1302 if (copy_from_user(&pvc
, ifr
->ifr_settings
.ifs_ifsu
.fr_pvc
,
1303 sizeof(fr_proto_pvc
)))
1306 if (pvc
.dlci
<= 0 || pvc
.dlci
>= 1024)
1307 return -EINVAL
; /* Only 10 bits, DLCI 0 reserved */
1309 if (ifr
->ifr_settings
.type
== IF_PROTO_FR_ADD_ETH_PVC
||
1310 ifr
->ifr_settings
.type
== IF_PROTO_FR_DEL_ETH_PVC
)
1311 result
= ARPHRD_ETHER
; /* bridged Ethernet device */
1313 result
= ARPHRD_DLCI
;
1315 if (ifr
->ifr_settings
.type
== IF_PROTO_FR_ADD_PVC
||
1316 ifr
->ifr_settings
.type
== IF_PROTO_FR_ADD_ETH_PVC
)
1317 return fr_add_pvc(dev
, pvc
.dlci
, result
);
1319 return fr_del_pvc(hdlc
, pvc
.dlci
, result
);
1326 static int __init
mod_init(void)
1328 register_hdlc_protocol(&proto
);
1333 static void __exit
mod_exit(void)
1335 unregister_hdlc_protocol(&proto
);
1339 module_init(mod_init
);
1340 module_exit(mod_exit
);
1342 MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
1343 MODULE_DESCRIPTION("Frame-Relay protocol support for generic HDLC");
1344 MODULE_LICENSE("GPL v2");
This page took 0.072715 seconds and 5 git commands to generate.