125763b3cSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2eb2a2fd9SKrzysztof Halasa /*
3eb2a2fd9SKrzysztof Halasa * Generic HDLC support routines for Linux
4eb2a2fd9SKrzysztof Halasa *
540d25142SKrzysztof Halasa * Copyright (C) 1999 - 2008 Krzysztof Halasa <khc@pm.waw.pl>
6eb2a2fd9SKrzysztof Halasa *
7eb2a2fd9SKrzysztof Halasa * Currently supported:
8eb2a2fd9SKrzysztof Halasa * * raw IP-in-HDLC
9eb2a2fd9SKrzysztof Halasa * * Cisco HDLC
10eb2a2fd9SKrzysztof Halasa * * Frame Relay with ANSI or CCITT LMI (both user and network side)
11eb2a2fd9SKrzysztof Halasa * * PPP
12eb2a2fd9SKrzysztof Halasa * * X.25
13eb2a2fd9SKrzysztof Halasa *
14eb2a2fd9SKrzysztof Halasa * Use sethdlc utility to set line parameters, protocol and PVCs
15eb2a2fd9SKrzysztof Halasa *
16eb2a2fd9SKrzysztof Halasa * How does it work:
17eb2a2fd9SKrzysztof Halasa * - proto->open(), close(), start(), stop() calls are serialized.
18eb2a2fd9SKrzysztof Halasa * The order is: open, [ start, stop ... ] close ...
19eb2a2fd9SKrzysztof Halasa * - proto->start() and stop() are called with spin_lock_irq held.
20eb2a2fd9SKrzysztof Halasa */
21eb2a2fd9SKrzysztof Halasa
2212a3bfefSJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
2312a3bfefSJoe Perches
24eb2a2fd9SKrzysztof Halasa #include <linux/errno.h>
25eb2a2fd9SKrzysztof Halasa #include <linux/hdlc.h>
264dfce407SKrzysztof Hałasa #include <linux/if_arp.h>
274dfce407SKrzysztof Hałasa #include <linux/inetdevice.h>
284dfce407SKrzysztof Hałasa #include <linux/init.h>
294dfce407SKrzysztof Hałasa #include <linux/kernel.h>
304dfce407SKrzysztof Hałasa #include <linux/module.h>
314dfce407SKrzysztof Hałasa #include <linux/notifier.h>
324dfce407SKrzysztof Hałasa #include <linux/pkt_sched.h>
334dfce407SKrzysztof Hałasa #include <linux/poll.h>
344dfce407SKrzysztof Hałasa #include <linux/rtnetlink.h>
354dfce407SKrzysztof Hałasa #include <linux/skbuff.h>
364dfce407SKrzysztof Hałasa #include <linux/slab.h>
37e730c155SEric W. Biederman #include <net/net_namespace.h>
38eb2a2fd9SKrzysztof Halasa
3940d25142SKrzysztof Halasa static const char *version = "HDLC support module revision 1.22";
40eb2a2fd9SKrzysztof Halasa
41eb2a2fd9SKrzysztof Halasa #undef DEBUG_LINK
42eb2a2fd9SKrzysztof Halasa
43fa701bd2SKrzysztof Halasa static struct hdlc_proto *first_proto;
44eb2a2fd9SKrzysztof Halasa
hdlc_rcv(struct sk_buff * skb,struct net_device * dev,struct packet_type * p,struct net_device * orig_dev)45eb2a2fd9SKrzysztof Halasa static int hdlc_rcv(struct sk_buff *skb, struct net_device *dev,
46eb2a2fd9SKrzysztof Halasa struct packet_type *p, struct net_device *orig_dev)
47eb2a2fd9SKrzysztof Halasa {
4801c4ceaeSXie He struct hdlc_device *hdlc;
4901c4ceaeSXie He
5001c4ceaeSXie He /* First make sure "dev" is an HDLC device */
5101c4ceaeSXie He if (!(dev->priv_flags & IFF_WAN_HDLC)) {
5201c4ceaeSXie He kfree_skb(skb);
5301c4ceaeSXie He return NET_RX_SUCCESS;
5401c4ceaeSXie He }
5501c4ceaeSXie He
5601c4ceaeSXie He hdlc = dev_to_hdlc(dev);
57e730c155SEric W. Biederman
5809ad9bc7SOctavian Purdila if (!net_eq(dev_net(dev), &init_net)) {
59e730c155SEric W. Biederman kfree_skb(skb);
60e730c155SEric W. Biederman return 0;
61e730c155SEric W. Biederman }
62e730c155SEric W. Biederman
6340d25142SKrzysztof Halasa BUG_ON(!hdlc->proto->netif_rx);
6440d25142SKrzysztof Halasa return hdlc->proto->netif_rx(skb);
65eb2a2fd9SKrzysztof Halasa }
66eb2a2fd9SKrzysztof Halasa
hdlc_start_xmit(struct sk_buff * skb,struct net_device * dev)67d71a6749SStephen Hemminger netdev_tx_t hdlc_start_xmit(struct sk_buff *skb, struct net_device *dev)
68991990a1SKrzysztof Hałasa {
69991990a1SKrzysztof Hałasa hdlc_device *hdlc = dev_to_hdlc(dev);
70eb2a2fd9SKrzysztof Halasa
71991990a1SKrzysztof Hałasa if (hdlc->proto->xmit)
72991990a1SKrzysztof Hałasa return hdlc->proto->xmit(skb, dev);
73991990a1SKrzysztof Hałasa
74991990a1SKrzysztof Hałasa return hdlc->xmit(skb, dev); /* call hardware driver directly */
75991990a1SKrzysztof Hałasa }
7601506939SPeng Li EXPORT_SYMBOL(hdlc_start_xmit);
77eb2a2fd9SKrzysztof Halasa
hdlc_proto_start(struct net_device * dev)78eb2a2fd9SKrzysztof Halasa static inline void hdlc_proto_start(struct net_device *dev)
79eb2a2fd9SKrzysztof Halasa {
80eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev);
8104cc04f0SPeng Li
82eb2a2fd9SKrzysztof Halasa if (hdlc->proto->start)
8340d25142SKrzysztof Halasa hdlc->proto->start(dev);
84eb2a2fd9SKrzysztof Halasa }
85eb2a2fd9SKrzysztof Halasa
hdlc_proto_stop(struct net_device * dev)86eb2a2fd9SKrzysztof Halasa static inline void hdlc_proto_stop(struct net_device *dev)
87eb2a2fd9SKrzysztof Halasa {
88eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev);
8904cc04f0SPeng Li
90eb2a2fd9SKrzysztof Halasa if (hdlc->proto->stop)
9140d25142SKrzysztof Halasa hdlc->proto->stop(dev);
92eb2a2fd9SKrzysztof Halasa }
93eb2a2fd9SKrzysztof Halasa
hdlc_device_event(struct notifier_block * this,unsigned long event,void * ptr)94eb2a2fd9SKrzysztof Halasa static int hdlc_device_event(struct notifier_block *this, unsigned long event,
95eb2a2fd9SKrzysztof Halasa void *ptr)
96eb2a2fd9SKrzysztof Halasa {
97351638e7SJiri Pirko struct net_device *dev = netdev_notifier_info_to_dev(ptr);
98eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc;
99eb2a2fd9SKrzysztof Halasa unsigned long flags;
100eb2a2fd9SKrzysztof Halasa int on;
101eb2a2fd9SKrzysztof Halasa
10209ad9bc7SOctavian Purdila if (!net_eq(dev_net(dev), &init_net))
103e9dc8653SEric W. Biederman return NOTIFY_DONE;
104e9dc8653SEric W. Biederman
1057cdc15f5SKrzysztof Hałasa if (!(dev->priv_flags & IFF_WAN_HDLC))
106eb2a2fd9SKrzysztof Halasa return NOTIFY_DONE; /* not an HDLC device */
107eb2a2fd9SKrzysztof Halasa
108eb2a2fd9SKrzysztof Halasa if (event != NETDEV_CHANGE)
1096f0b31c3SThomas Weber return NOTIFY_DONE; /* Only interested in carrier changes */
110eb2a2fd9SKrzysztof Halasa
111eb2a2fd9SKrzysztof Halasa on = netif_carrier_ok(dev);
112eb2a2fd9SKrzysztof Halasa
113eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK
114eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_device_event NETDEV_CHANGE, carrier %i\n",
115eb2a2fd9SKrzysztof Halasa dev->name, on);
116eb2a2fd9SKrzysztof Halasa #endif
117eb2a2fd9SKrzysztof Halasa
118eb2a2fd9SKrzysztof Halasa hdlc = dev_to_hdlc(dev);
119eb2a2fd9SKrzysztof Halasa spin_lock_irqsave(&hdlc->state_lock, flags);
120eb2a2fd9SKrzysztof Halasa
121eb2a2fd9SKrzysztof Halasa if (hdlc->carrier == on)
122eb2a2fd9SKrzysztof Halasa goto carrier_exit; /* no change in DCD line level */
123eb2a2fd9SKrzysztof Halasa
124eb2a2fd9SKrzysztof Halasa hdlc->carrier = on;
125eb2a2fd9SKrzysztof Halasa
126eb2a2fd9SKrzysztof Halasa if (!hdlc->open)
127eb2a2fd9SKrzysztof Halasa goto carrier_exit;
128eb2a2fd9SKrzysztof Halasa
129eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) {
13012a3bfefSJoe Perches netdev_info(dev, "Carrier detected\n");
131eb2a2fd9SKrzysztof Halasa hdlc_proto_start(dev);
132eb2a2fd9SKrzysztof Halasa } else {
13312a3bfefSJoe Perches netdev_info(dev, "Carrier lost\n");
134eb2a2fd9SKrzysztof Halasa hdlc_proto_stop(dev);
135eb2a2fd9SKrzysztof Halasa }
136eb2a2fd9SKrzysztof Halasa
137eb2a2fd9SKrzysztof Halasa carrier_exit:
138eb2a2fd9SKrzysztof Halasa spin_unlock_irqrestore(&hdlc->state_lock, flags);
139eb2a2fd9SKrzysztof Halasa return NOTIFY_DONE;
140eb2a2fd9SKrzysztof Halasa }
141eb2a2fd9SKrzysztof Halasa
142eb2a2fd9SKrzysztof Halasa /* Must be called by hardware driver when HDLC device is being opened */
hdlc_open(struct net_device * dev)143eb2a2fd9SKrzysztof Halasa int hdlc_open(struct net_device *dev)
144eb2a2fd9SKrzysztof Halasa {
145eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev);
146eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK
147eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_open() carrier %i open %i\n", dev->name,
148eb2a2fd9SKrzysztof Halasa hdlc->carrier, hdlc->open);
149eb2a2fd9SKrzysztof Halasa #endif
150eb2a2fd9SKrzysztof Halasa
151387847f2SPeng Li if (!hdlc->proto)
152eb2a2fd9SKrzysztof Halasa return -ENOSYS; /* no protocol attached */
153eb2a2fd9SKrzysztof Halasa
154eb2a2fd9SKrzysztof Halasa if (hdlc->proto->open) {
155eb2a2fd9SKrzysztof Halasa int result = hdlc->proto->open(dev);
15604cc04f0SPeng Li
157eb2a2fd9SKrzysztof Halasa if (result)
158eb2a2fd9SKrzysztof Halasa return result;
159eb2a2fd9SKrzysztof Halasa }
160eb2a2fd9SKrzysztof Halasa
161eb2a2fd9SKrzysztof Halasa spin_lock_irq(&hdlc->state_lock);
162eb2a2fd9SKrzysztof Halasa
163eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) {
16412a3bfefSJoe Perches netdev_info(dev, "Carrier detected\n");
165eb2a2fd9SKrzysztof Halasa hdlc_proto_start(dev);
1661bb52182SPeng Li } else {
16712a3bfefSJoe Perches netdev_info(dev, "No carrier\n");
1681bb52182SPeng Li }
169eb2a2fd9SKrzysztof Halasa
170eb2a2fd9SKrzysztof Halasa hdlc->open = 1;
171eb2a2fd9SKrzysztof Halasa
172eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock);
173eb2a2fd9SKrzysztof Halasa return 0;
174eb2a2fd9SKrzysztof Halasa }
17501506939SPeng Li EXPORT_SYMBOL(hdlc_open);
176eb2a2fd9SKrzysztof Halasa
177eb2a2fd9SKrzysztof Halasa /* Must be called by hardware driver when HDLC device is being closed */
hdlc_close(struct net_device * dev)178eb2a2fd9SKrzysztof Halasa void hdlc_close(struct net_device *dev)
179eb2a2fd9SKrzysztof Halasa {
180eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev);
181eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK
182eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_close() carrier %i open %i\n", dev->name,
183eb2a2fd9SKrzysztof Halasa hdlc->carrier, hdlc->open);
184eb2a2fd9SKrzysztof Halasa #endif
185eb2a2fd9SKrzysztof Halasa
186eb2a2fd9SKrzysztof Halasa spin_lock_irq(&hdlc->state_lock);
187eb2a2fd9SKrzysztof Halasa
188eb2a2fd9SKrzysztof Halasa hdlc->open = 0;
189eb2a2fd9SKrzysztof Halasa if (hdlc->carrier)
190eb2a2fd9SKrzysztof Halasa hdlc_proto_stop(dev);
191eb2a2fd9SKrzysztof Halasa
192eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock);
193eb2a2fd9SKrzysztof Halasa
194eb2a2fd9SKrzysztof Halasa if (hdlc->proto->close)
195eb2a2fd9SKrzysztof Halasa hdlc->proto->close(dev);
196eb2a2fd9SKrzysztof Halasa }
19701506939SPeng Li EXPORT_SYMBOL(hdlc_close);
198eb2a2fd9SKrzysztof Halasa
hdlc_ioctl(struct net_device * dev,struct if_settings * ifs)199*ad7eab2aSArnd Bergmann int hdlc_ioctl(struct net_device *dev, struct if_settings *ifs)
200eb2a2fd9SKrzysztof Halasa {
201eb2a2fd9SKrzysztof Halasa struct hdlc_proto *proto = first_proto;
202eb2a2fd9SKrzysztof Halasa int result;
203eb2a2fd9SKrzysztof Halasa
204eb2a2fd9SKrzysztof Halasa if (dev_to_hdlc(dev)->proto) {
205*ad7eab2aSArnd Bergmann result = dev_to_hdlc(dev)->proto->ioctl(dev, ifs);
206eb2a2fd9SKrzysztof Halasa if (result != -EINVAL)
207eb2a2fd9SKrzysztof Halasa return result;
208eb2a2fd9SKrzysztof Halasa }
209eb2a2fd9SKrzysztof Halasa
210eb2a2fd9SKrzysztof Halasa /* Not handled by currently attached protocol (if any) */
211eb2a2fd9SKrzysztof Halasa
212eb2a2fd9SKrzysztof Halasa while (proto) {
213*ad7eab2aSArnd Bergmann result = proto->ioctl(dev, ifs);
214e50eb6c3SPeng Li if (result != -EINVAL)
215eb2a2fd9SKrzysztof Halasa return result;
216eb2a2fd9SKrzysztof Halasa proto = proto->next;
217eb2a2fd9SKrzysztof Halasa }
218eb2a2fd9SKrzysztof Halasa return -EINVAL;
219eb2a2fd9SKrzysztof Halasa }
22001506939SPeng Li EXPORT_SYMBOL(hdlc_ioctl);
221eb2a2fd9SKrzysztof Halasa
2223b04dddeSStephen Hemminger static const struct header_ops hdlc_null_ops;
2233b04dddeSStephen Hemminger
hdlc_setup_dev(struct net_device * dev)224b5284e5aSKrzysztof Halasa static void hdlc_setup_dev(struct net_device *dev)
225b5284e5aSKrzysztof Halasa {
226b5284e5aSKrzysztof Halasa /* Re-init all variables changed by HDLC protocol drivers,
227b5284e5aSKrzysztof Halasa * including ether_setup() called from hdlc_raw_eth.c.
228b5284e5aSKrzysztof Halasa */
229b5284e5aSKrzysztof Halasa dev->flags = IFF_POINTOPOINT | IFF_NOARP;
2307cdc15f5SKrzysztof Hałasa dev->priv_flags = IFF_WAN_HDLC;
231b5284e5aSKrzysztof Halasa dev->mtu = HDLC_MAX_MTU;
2328b6b4135SJarod Wilson dev->min_mtu = 68;
2338b6b4135SJarod Wilson dev->max_mtu = HDLC_MAX_MTU;
234b5284e5aSKrzysztof Halasa dev->type = ARPHRD_RAWHDLC;
2352b7bcd96SXie He dev->hard_header_len = 0;
23677b981c8SXie He dev->needed_headroom = 0;
237b5284e5aSKrzysztof Halasa dev->addr_len = 0;
2383b04dddeSStephen Hemminger dev->header_ops = &hdlc_null_ops;
239b5284e5aSKrzysztof Halasa }
240b5284e5aSKrzysztof Halasa
hdlc_setup(struct net_device * dev)2410bf94fafSAdrian Bunk static void hdlc_setup(struct net_device *dev)
242eb2a2fd9SKrzysztof Halasa {
243eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev);
244eb2a2fd9SKrzysztof Halasa
245b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev);
246eb2a2fd9SKrzysztof Halasa hdlc->carrier = 1;
247eb2a2fd9SKrzysztof Halasa hdlc->open = 0;
248eb2a2fd9SKrzysztof Halasa spin_lock_init(&hdlc->state_lock);
249eb2a2fd9SKrzysztof Halasa }
250eb2a2fd9SKrzysztof Halasa
alloc_hdlcdev(void * priv)251eb2a2fd9SKrzysztof Halasa struct net_device *alloc_hdlcdev(void *priv)
252eb2a2fd9SKrzysztof Halasa {
253eb2a2fd9SKrzysztof Halasa struct net_device *dev;
25404cc04f0SPeng Li
255c835a677STom Gundersen dev = alloc_netdev(sizeof(struct hdlc_device), "hdlc%d",
256c835a677STom Gundersen NET_NAME_UNKNOWN, hdlc_setup);
257eb2a2fd9SKrzysztof Halasa if (dev)
258eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->priv = priv;
259eb2a2fd9SKrzysztof Halasa return dev;
260eb2a2fd9SKrzysztof Halasa }
26101506939SPeng Li EXPORT_SYMBOL(alloc_hdlcdev);
262eb2a2fd9SKrzysztof Halasa
unregister_hdlc_device(struct net_device * dev)263eb2a2fd9SKrzysztof Halasa void unregister_hdlc_device(struct net_device *dev)
264eb2a2fd9SKrzysztof Halasa {
265eb2a2fd9SKrzysztof Halasa rtnl_lock();
266eb2a2fd9SKrzysztof Halasa detach_hdlc_protocol(dev);
267ff351644SAndrew Lunn unregister_netdevice(dev);
268eb2a2fd9SKrzysztof Halasa rtnl_unlock();
269eb2a2fd9SKrzysztof Halasa }
27001506939SPeng Li EXPORT_SYMBOL(unregister_hdlc_device);
271eb2a2fd9SKrzysztof Halasa
attach_hdlc_protocol(struct net_device * dev,struct hdlc_proto * proto,size_t size)272eb2a2fd9SKrzysztof Halasa int attach_hdlc_protocol(struct net_device *dev, struct hdlc_proto *proto,
27340d25142SKrzysztof Halasa size_t size)
274eb2a2fd9SKrzysztof Halasa {
2752f8364a2SAndrew Lunn int err;
2762f8364a2SAndrew Lunn
2772f8364a2SAndrew Lunn err = detach_hdlc_protocol(dev);
2782f8364a2SAndrew Lunn if (err)
2792f8364a2SAndrew Lunn return err;
280eb2a2fd9SKrzysztof Halasa
281eb2a2fd9SKrzysztof Halasa if (!try_module_get(proto->module))
282eb2a2fd9SKrzysztof Halasa return -ENOSYS;
283eb2a2fd9SKrzysztof Halasa
2841d5d1fdcSJoe Perches if (size) {
2851d5d1fdcSJoe Perches dev_to_hdlc(dev)->state = kmalloc(size, GFP_KERNEL);
286387847f2SPeng Li if (!dev_to_hdlc(dev)->state) {
287eb2a2fd9SKrzysztof Halasa module_put(proto->module);
288eb2a2fd9SKrzysztof Halasa return -ENOBUFS;
289eb2a2fd9SKrzysztof Halasa }
2901d5d1fdcSJoe Perches }
291eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->proto = proto;
2922f8364a2SAndrew Lunn
293eb2a2fd9SKrzysztof Halasa return 0;
294eb2a2fd9SKrzysztof Halasa }
29501506939SPeng Li EXPORT_SYMBOL(attach_hdlc_protocol);
296eb2a2fd9SKrzysztof Halasa
detach_hdlc_protocol(struct net_device * dev)2972f8364a2SAndrew Lunn int detach_hdlc_protocol(struct net_device *dev)
298eb2a2fd9SKrzysztof Halasa {
299eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev);
3002f8364a2SAndrew Lunn int err;
301eb2a2fd9SKrzysztof Halasa
302eb2a2fd9SKrzysztof Halasa if (hdlc->proto) {
3032f8364a2SAndrew Lunn err = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE, dev);
3042f8364a2SAndrew Lunn err = notifier_to_errno(err);
3052f8364a2SAndrew Lunn if (err) {
3062f8364a2SAndrew Lunn netdev_err(dev, "Refused to change device type\n");
3072f8364a2SAndrew Lunn return err;
3082f8364a2SAndrew Lunn }
3092f8364a2SAndrew Lunn
310eb2a2fd9SKrzysztof Halasa if (hdlc->proto->detach)
311eb2a2fd9SKrzysztof Halasa hdlc->proto->detach(dev);
312eb2a2fd9SKrzysztof Halasa module_put(hdlc->proto->module);
313eb2a2fd9SKrzysztof Halasa hdlc->proto = NULL;
314eb2a2fd9SKrzysztof Halasa }
315eb2a2fd9SKrzysztof Halasa kfree(hdlc->state);
316eb2a2fd9SKrzysztof Halasa hdlc->state = NULL;
317b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev);
3182f8364a2SAndrew Lunn
3192f8364a2SAndrew Lunn return 0;
320eb2a2fd9SKrzysztof Halasa }
32101506939SPeng Li EXPORT_SYMBOL(detach_hdlc_protocol);
322eb2a2fd9SKrzysztof Halasa
register_hdlc_protocol(struct hdlc_proto * proto)323eb2a2fd9SKrzysztof Halasa void register_hdlc_protocol(struct hdlc_proto *proto)
324eb2a2fd9SKrzysztof Halasa {
325fa701bd2SKrzysztof Halasa rtnl_lock();
326eb2a2fd9SKrzysztof Halasa proto->next = first_proto;
327eb2a2fd9SKrzysztof Halasa first_proto = proto;
328fa701bd2SKrzysztof Halasa rtnl_unlock();
329eb2a2fd9SKrzysztof Halasa }
33001506939SPeng Li EXPORT_SYMBOL(register_hdlc_protocol);
331eb2a2fd9SKrzysztof Halasa
unregister_hdlc_protocol(struct hdlc_proto * proto)332eb2a2fd9SKrzysztof Halasa void unregister_hdlc_protocol(struct hdlc_proto *proto)
333eb2a2fd9SKrzysztof Halasa {
334fa701bd2SKrzysztof Halasa struct hdlc_proto **p;
335fa701bd2SKrzysztof Halasa
336fa701bd2SKrzysztof Halasa rtnl_lock();
337fa701bd2SKrzysztof Halasa p = &first_proto;
338fa701bd2SKrzysztof Halasa while (*p != proto) {
339fa701bd2SKrzysztof Halasa BUG_ON(!*p);
340eb2a2fd9SKrzysztof Halasa p = &((*p)->next);
341eb2a2fd9SKrzysztof Halasa }
342fa701bd2SKrzysztof Halasa *p = proto->next;
343fa701bd2SKrzysztof Halasa rtnl_unlock();
344eb2a2fd9SKrzysztof Halasa }
34501506939SPeng Li EXPORT_SYMBOL(unregister_hdlc_protocol);
346eb2a2fd9SKrzysztof Halasa
347eb2a2fd9SKrzysztof Halasa MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
348eb2a2fd9SKrzysztof Halasa MODULE_DESCRIPTION("HDLC support module");
349eb2a2fd9SKrzysztof Halasa MODULE_LICENSE("GPL v2");
350eb2a2fd9SKrzysztof Halasa
3517546dd97SStephen Hemminger static struct packet_type hdlc_packet_type __read_mostly = {
35209640e63SHarvey Harrison .type = cpu_to_be16(ETH_P_HDLC),
353eb2a2fd9SKrzysztof Halasa .func = hdlc_rcv,
354eb2a2fd9SKrzysztof Halasa };
355eb2a2fd9SKrzysztof Halasa
356eb2a2fd9SKrzysztof Halasa static struct notifier_block hdlc_notifier = {
357eb2a2fd9SKrzysztof Halasa .notifier_call = hdlc_device_event,
358eb2a2fd9SKrzysztof Halasa };
359eb2a2fd9SKrzysztof Halasa
hdlc_module_init(void)360eb2a2fd9SKrzysztof Halasa static int __init hdlc_module_init(void)
361eb2a2fd9SKrzysztof Halasa {
362eb2a2fd9SKrzysztof Halasa int result;
363eb2a2fd9SKrzysztof Halasa
36412a3bfefSJoe Perches pr_info("%s\n", version);
365e50eb6c3SPeng Li result = register_netdevice_notifier(&hdlc_notifier);
366e50eb6c3SPeng Li if (result)
367eb2a2fd9SKrzysztof Halasa return result;
368eb2a2fd9SKrzysztof Halasa dev_add_pack(&hdlc_packet_type);
369eb2a2fd9SKrzysztof Halasa return 0;
370eb2a2fd9SKrzysztof Halasa }
371eb2a2fd9SKrzysztof Halasa
hdlc_module_exit(void)372eb2a2fd9SKrzysztof Halasa static void __exit hdlc_module_exit(void)
373eb2a2fd9SKrzysztof Halasa {
374eb2a2fd9SKrzysztof Halasa dev_remove_pack(&hdlc_packet_type);
375eb2a2fd9SKrzysztof Halasa unregister_netdevice_notifier(&hdlc_notifier);
376eb2a2fd9SKrzysztof Halasa }
377eb2a2fd9SKrzysztof Halasa
378eb2a2fd9SKrzysztof Halasa module_init(hdlc_module_init);
379eb2a2fd9SKrzysztof Halasa module_exit(hdlc_module_exit);
380