2
* Generic HDLC support routines for Linux
4
* Copyright (C) 1999 - 2008 Krzysztof Halasa <khc@pm.waw.pl>
6
* This program is free software; you can redistribute it and/or modify it
7
* under the terms of version 2 of the GNU General Public License
8
* as published by the Free Software Foundation.
10
* Currently supported:
13
* * Frame Relay with ANSI or CCITT LMI (both user and network side)
17
* Use sethdlc utility to set line parameters, protocol and PVCs
20
* - proto->open(), close(), start(), stop() calls are serialized.
21
* The order is: open, [ start, stop ... ] close ...
22
* - proto->start() and stop() are called with spin_lock_irq held.
25
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
#include <linux/errno.h>
28
#include <linux/hdlc.h>
29
#include <linux/if_arp.h>
30
#include <linux/inetdevice.h>
31
#include <linux/init.h>
32
#include <linux/kernel.h>
33
#include <linux/module.h>
34
#include <linux/notifier.h>
35
#include <linux/pkt_sched.h>
36
#include <linux/poll.h>
37
#include <linux/rtnetlink.h>
38
#include <linux/skbuff.h>
39
#include <linux/slab.h>
40
#include <net/net_namespace.h>
43
static const char* version = "HDLC support module revision 1.22";
47
static struct hdlc_proto *first_proto;
49
int hdlc_change_mtu(struct net_device *dev, int new_mtu)
51
if ((new_mtu < 68) || (new_mtu > HDLC_MAX_MTU))
57
static int hdlc_rcv(struct sk_buff *skb, struct net_device *dev,
58
struct packet_type *p, struct net_device *orig_dev)
60
struct hdlc_device *hdlc = dev_to_hdlc(dev);
62
if (!net_eq(dev_net(dev), &init_net)) {
67
BUG_ON(!hdlc->proto->netif_rx);
68
return hdlc->proto->netif_rx(skb);
71
netdev_tx_t hdlc_start_xmit(struct sk_buff *skb, struct net_device *dev)
73
hdlc_device *hdlc = dev_to_hdlc(dev);
75
if (hdlc->proto->xmit)
76
return hdlc->proto->xmit(skb, dev);
78
return hdlc->xmit(skb, dev); /* call hardware driver directly */
81
static inline void hdlc_proto_start(struct net_device *dev)
83
hdlc_device *hdlc = dev_to_hdlc(dev);
84
if (hdlc->proto->start)
85
hdlc->proto->start(dev);
90
static inline void hdlc_proto_stop(struct net_device *dev)
92
hdlc_device *hdlc = dev_to_hdlc(dev);
93
if (hdlc->proto->stop)
94
hdlc->proto->stop(dev);
99
static int hdlc_device_event(struct notifier_block *this, unsigned long event,
102
struct net_device *dev = ptr;
107
if (!net_eq(dev_net(dev), &init_net))
110
if (!(dev->priv_flags & IFF_WAN_HDLC))
111
return NOTIFY_DONE; /* not an HDLC device */
113
if (event != NETDEV_CHANGE)
114
return NOTIFY_DONE; /* Only interested in carrier changes */
116
on = netif_carrier_ok(dev);
119
printk(KERN_DEBUG "%s: hdlc_device_event NETDEV_CHANGE, carrier %i\n",
123
hdlc = dev_to_hdlc(dev);
124
spin_lock_irqsave(&hdlc->state_lock, flags);
126
if (hdlc->carrier == on)
127
goto carrier_exit; /* no change in DCD line level */
135
netdev_info(dev, "Carrier detected\n");
136
hdlc_proto_start(dev);
138
netdev_info(dev, "Carrier lost\n");
139
hdlc_proto_stop(dev);
143
spin_unlock_irqrestore(&hdlc->state_lock, flags);
149
/* Must be called by hardware driver when HDLC device is being opened */
150
int hdlc_open(struct net_device *dev)
152
hdlc_device *hdlc = dev_to_hdlc(dev);
154
printk(KERN_DEBUG "%s: hdlc_open() carrier %i open %i\n", dev->name,
155
hdlc->carrier, hdlc->open);
158
if (hdlc->proto == NULL)
159
return -ENOSYS; /* no protocol attached */
161
if (hdlc->proto->open) {
162
int result = hdlc->proto->open(dev);
167
spin_lock_irq(&hdlc->state_lock);
170
netdev_info(dev, "Carrier detected\n");
171
hdlc_proto_start(dev);
173
netdev_info(dev, "No carrier\n");
177
spin_unlock_irq(&hdlc->state_lock);
183
/* Must be called by hardware driver when HDLC device is being closed */
184
void hdlc_close(struct net_device *dev)
186
hdlc_device *hdlc = dev_to_hdlc(dev);
188
printk(KERN_DEBUG "%s: hdlc_close() carrier %i open %i\n", dev->name,
189
hdlc->carrier, hdlc->open);
192
spin_lock_irq(&hdlc->state_lock);
196
hdlc_proto_stop(dev);
198
spin_unlock_irq(&hdlc->state_lock);
200
if (hdlc->proto->close)
201
hdlc->proto->close(dev);
206
int hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
208
struct hdlc_proto *proto = first_proto;
211
if (cmd != SIOCWANDEV)
214
if (dev_to_hdlc(dev)->proto) {
215
result = dev_to_hdlc(dev)->proto->ioctl(dev, ifr);
216
if (result != -EINVAL)
220
/* Not handled by currently attached protocol (if any) */
223
if ((result = proto->ioctl(dev, ifr)) != -EINVAL)
230
static const struct header_ops hdlc_null_ops;
232
static void hdlc_setup_dev(struct net_device *dev)
234
/* Re-init all variables changed by HDLC protocol drivers,
235
* including ether_setup() called from hdlc_raw_eth.c.
237
dev->flags = IFF_POINTOPOINT | IFF_NOARP;
238
dev->priv_flags = IFF_WAN_HDLC;
239
dev->mtu = HDLC_MAX_MTU;
240
dev->type = ARPHRD_RAWHDLC;
241
dev->hard_header_len = 16;
243
dev->header_ops = &hdlc_null_ops;
246
static void hdlc_setup(struct net_device *dev)
248
hdlc_device *hdlc = dev_to_hdlc(dev);
253
spin_lock_init(&hdlc->state_lock);
256
struct net_device *alloc_hdlcdev(void *priv)
258
struct net_device *dev;
259
dev = alloc_netdev(sizeof(struct hdlc_device), "hdlc%d", hdlc_setup);
261
dev_to_hdlc(dev)->priv = priv;
265
void unregister_hdlc_device(struct net_device *dev)
268
unregister_netdevice(dev);
269
detach_hdlc_protocol(dev);
275
int attach_hdlc_protocol(struct net_device *dev, struct hdlc_proto *proto,
278
detach_hdlc_protocol(dev);
280
if (!try_module_get(proto->module))
284
if ((dev_to_hdlc(dev)->state = kmalloc(size,
285
GFP_KERNEL)) == NULL) {
287
"Memory squeeze on hdlc_proto_attach()\n");
288
module_put(proto->module);
291
dev_to_hdlc(dev)->proto = proto;
296
void detach_hdlc_protocol(struct net_device *dev)
298
hdlc_device *hdlc = dev_to_hdlc(dev);
301
if (hdlc->proto->detach)
302
hdlc->proto->detach(dev);
303
module_put(hdlc->proto->module);
312
void register_hdlc_protocol(struct hdlc_proto *proto)
315
proto->next = first_proto;
321
void unregister_hdlc_protocol(struct hdlc_proto *proto)
323
struct hdlc_proto **p;
327
while (*p != proto) {
337
MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
338
MODULE_DESCRIPTION("HDLC support module");
339
MODULE_LICENSE("GPL v2");
341
EXPORT_SYMBOL(hdlc_change_mtu);
342
EXPORT_SYMBOL(hdlc_start_xmit);
343
EXPORT_SYMBOL(hdlc_open);
344
EXPORT_SYMBOL(hdlc_close);
345
EXPORT_SYMBOL(hdlc_ioctl);
346
EXPORT_SYMBOL(alloc_hdlcdev);
347
EXPORT_SYMBOL(unregister_hdlc_device);
348
EXPORT_SYMBOL(register_hdlc_protocol);
349
EXPORT_SYMBOL(unregister_hdlc_protocol);
350
EXPORT_SYMBOL(attach_hdlc_protocol);
351
EXPORT_SYMBOL(detach_hdlc_protocol);
353
static struct packet_type hdlc_packet_type __read_mostly = {
354
.type = cpu_to_be16(ETH_P_HDLC),
359
static struct notifier_block hdlc_notifier = {
360
.notifier_call = hdlc_device_event,
364
static int __init hdlc_module_init(void)
368
pr_info("%s\n", version);
369
if ((result = register_netdevice_notifier(&hdlc_notifier)) != 0)
371
dev_add_pack(&hdlc_packet_type);
377
static void __exit hdlc_module_exit(void)
379
dev_remove_pack(&hdlc_packet_type);
380
unregister_netdevice_notifier(&hdlc_notifier);
384
module_init(hdlc_module_init);
385
module_exit(hdlc_module_exit);