blob: 51f6cee8aab2d805147b9741ea49fad3747d7cfa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Generic HDLC support routines for Linux
3 *
Krzysztof Halasa40d25142008-02-01 22:37:12 +01004 * Copyright (C) 1999 - 2008 Krzysztof Halasa <khc@pm.waw.pl>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
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.
9 *
10 * Currently supported:
11 * * raw IP-in-HDLC
12 * * Cisco HDLC
13 * * Frame Relay with ANSI or CCITT LMI (both user and network side)
14 * * PPP
15 * * X.25
16 *
17 * Use sethdlc utility to set line parameters, protocol and PVCs
18 *
19 * How does it work:
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +020020 * - proto->open(), close(), start(), stop() calls are serialized.
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 * The order is: open, [ start, stop ... ] close ...
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +020022 * - proto->start() and stop() are called with spin_lock_irq held.
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 */
24
Joe Perches12a3bfe2011-06-26 19:01:28 +000025#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/hdlc.h>
Krzysztof Hałasa4dfce402008-06-30 19:06:40 +020029#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>
Eric W. Biedermane730c152007-09-17 11:53:39 -070040#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42
Krzysztof Halasa40d25142008-02-01 22:37:12 +010043static const char* version = "HDLC support module revision 1.22";
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#undef DEBUG_LINK
46
Krzysztof Halasafa701bd2008-05-19 19:00:51 +020047static struct hdlc_proto *first_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Krzysztof Hałasa991990a2009-01-08 22:52:11 +010049int hdlc_change_mtu(struct net_device *dev, int new_mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050{
51 if ((new_mtu < 68) || (new_mtu > HDLC_MAX_MTU))
52 return -EINVAL;
53 dev->mtu = new_mtu;
54 return 0;
55}
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static int hdlc_rcv(struct sk_buff *skb, struct net_device *dev,
David S. Millerf2ccd8f2005-08-09 19:34:12 -070058 struct packet_type *p, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070059{
Krzysztof Halasa40d25142008-02-01 22:37:12 +010060 struct hdlc_device *hdlc = dev_to_hdlc(dev);
Eric W. Biedermane730c152007-09-17 11:53:39 -070061
Octavian Purdila09ad9bc2009-11-25 15:14:13 -080062 if (!net_eq(dev_net(dev), &init_net)) {
Eric W. Biedermane730c152007-09-17 11:53:39 -070063 kfree_skb(skb);
64 return 0;
65 }
66
Krzysztof Halasa40d25142008-02-01 22:37:12 +010067 BUG_ON(!hdlc->proto->netif_rx);
68 return hdlc->proto->netif_rx(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069}
70
Stephen Hemmingerd71a6742009-08-31 19:50:47 +000071netdev_tx_t hdlc_start_xmit(struct sk_buff *skb, struct net_device *dev)
Krzysztof Hałasa991990a2009-01-08 22:52:11 +010072{
73 hdlc_device *hdlc = dev_to_hdlc(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
Krzysztof Hałasa991990a2009-01-08 22:52:11 +010075 if (hdlc->proto->xmit)
76 return hdlc->proto->xmit(skb, dev);
77
78 return hdlc->xmit(skb, dev); /* call hardware driver directly */
79}
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
Krzysztof Halasac2ce9202006-07-12 13:46:12 -070081static inline void hdlc_proto_start(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082{
83 hdlc_device *hdlc = dev_to_hdlc(dev);
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +020084 if (hdlc->proto->start)
Krzysztof Halasa40d25142008-02-01 22:37:12 +010085 hdlc->proto->start(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086}
87
88
89
Krzysztof Halasac2ce9202006-07-12 13:46:12 -070090static inline void hdlc_proto_stop(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
92 hdlc_device *hdlc = dev_to_hdlc(dev);
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +020093 if (hdlc->proto->stop)
Krzysztof Halasa40d25142008-02-01 22:37:12 +010094 hdlc->proto->stop(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095}
96
97
98
Krzysztof Halasac2ce9202006-07-12 13:46:12 -070099static int hdlc_device_event(struct notifier_block *this, unsigned long event,
100 void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Jiri Pirko351638e2013-05-28 01:30:21 +0000102 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700103 hdlc_device *hdlc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 unsigned long flags;
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700105 int on;
Krzysztof Hałasadff3fde2009-01-08 19:55:57 +0100106
Octavian Purdila09ad9bc2009-11-25 15:14:13 -0800107 if (!net_eq(dev_net(dev), &init_net))
Eric W. Biedermane9dc8652007-09-12 13:02:17 +0200108 return NOTIFY_DONE;
109
Krzysztof Hałasa7cdc15f2009-01-08 19:46:54 +0100110 if (!(dev->priv_flags & IFF_WAN_HDLC))
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700111 return NOTIFY_DONE; /* not an HDLC device */
Krzysztof Hałasa4dfce402008-06-30 19:06:40 +0200112
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700113 if (event != NETDEV_CHANGE)
Thomas Weber6f0b31c2010-09-20 16:30:54 +0200114 return NOTIFY_DONE; /* Only interested in carrier changes */
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700115
116 on = netif_carrier_ok(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118#ifdef DEBUG_LINK
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700119 printk(KERN_DEBUG "%s: hdlc_device_event NETDEV_CHANGE, carrier %i\n",
120 dev->name, on);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121#endif
122
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700123 hdlc = dev_to_hdlc(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 spin_lock_irqsave(&hdlc->state_lock, flags);
125
126 if (hdlc->carrier == on)
127 goto carrier_exit; /* no change in DCD line level */
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 hdlc->carrier = on;
130
131 if (!hdlc->open)
132 goto carrier_exit;
133
Krzysztof Halasab3dd65f2005-04-21 15:57:25 +0200134 if (hdlc->carrier) {
Joe Perches12a3bfe2011-06-26 19:01:28 +0000135 netdev_info(dev, "Carrier detected\n");
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700136 hdlc_proto_start(dev);
Krzysztof Halasab3dd65f2005-04-21 15:57:25 +0200137 } else {
Joe Perches12a3bfe2011-06-26 19:01:28 +0000138 netdev_info(dev, "Carrier lost\n");
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700139 hdlc_proto_stop(dev);
Krzysztof Halasab3dd65f2005-04-21 15:57:25 +0200140 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
142carrier_exit:
143 spin_unlock_irqrestore(&hdlc->state_lock, flags);
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700144 return NOTIFY_DONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145}
146
147
148
149/* Must be called by hardware driver when HDLC device is being opened */
150int hdlc_open(struct net_device *dev)
151{
152 hdlc_device *hdlc = dev_to_hdlc(dev);
153#ifdef DEBUG_LINK
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200154 printk(KERN_DEBUG "%s: hdlc_open() carrier %i open %i\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 hdlc->carrier, hdlc->open);
156#endif
157
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200158 if (hdlc->proto == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 return -ENOSYS; /* no protocol attached */
160
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200161 if (hdlc->proto->open) {
162 int result = hdlc->proto->open(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 if (result)
164 return result;
165 }
166
167 spin_lock_irq(&hdlc->state_lock);
168
Krzysztof Halasab3dd65f2005-04-21 15:57:25 +0200169 if (hdlc->carrier) {
Joe Perches12a3bfe2011-06-26 19:01:28 +0000170 netdev_info(dev, "Carrier detected\n");
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700171 hdlc_proto_start(dev);
Krzysztof Halasab3dd65f2005-04-21 15:57:25 +0200172 } else
Joe Perches12a3bfe2011-06-26 19:01:28 +0000173 netdev_info(dev, "No carrier\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
175 hdlc->open = 1;
176
177 spin_unlock_irq(&hdlc->state_lock);
178 return 0;
179}
180
181
182
183/* Must be called by hardware driver when HDLC device is being closed */
184void hdlc_close(struct net_device *dev)
185{
186 hdlc_device *hdlc = dev_to_hdlc(dev);
187#ifdef DEBUG_LINK
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200188 printk(KERN_DEBUG "%s: hdlc_close() carrier %i open %i\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 hdlc->carrier, hdlc->open);
190#endif
191
192 spin_lock_irq(&hdlc->state_lock);
193
194 hdlc->open = 0;
195 if (hdlc->carrier)
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700196 hdlc_proto_stop(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198 spin_unlock_irq(&hdlc->state_lock);
199
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200200 if (hdlc->proto->close)
201 hdlc->proto->close(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
204
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206int hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
207{
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200208 struct hdlc_proto *proto = first_proto;
209 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 if (cmd != SIOCWANDEV)
212 return -EINVAL;
213
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200214 if (dev_to_hdlc(dev)->proto) {
215 result = dev_to_hdlc(dev)->proto->ioctl(dev, ifr);
216 if (result != -EINVAL)
217 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 }
219
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200220 /* Not handled by currently attached protocol (if any) */
221
222 while (proto) {
223 if ((result = proto->ioctl(dev, ifr)) != -EINVAL)
224 return result;
225 proto = proto->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 }
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200227 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228}
229
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700230static const struct header_ops hdlc_null_ops;
231
Krzysztof Halasab5284e52007-03-02 15:52:22 -0800232static void hdlc_setup_dev(struct net_device *dev)
233{
234 /* Re-init all variables changed by HDLC protocol drivers,
235 * including ether_setup() called from hdlc_raw_eth.c.
236 */
Krzysztof Halasab5284e52007-03-02 15:52:22 -0800237 dev->flags = IFF_POINTOPOINT | IFF_NOARP;
Krzysztof Hałasa7cdc15f2009-01-08 19:46:54 +0100238 dev->priv_flags = IFF_WAN_HDLC;
Krzysztof Halasab5284e52007-03-02 15:52:22 -0800239 dev->mtu = HDLC_MAX_MTU;
240 dev->type = ARPHRD_RAWHDLC;
241 dev->hard_header_len = 16;
242 dev->addr_len = 0;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700243 dev->header_ops = &hdlc_null_ops;
Krzysztof Halasab5284e52007-03-02 15:52:22 -0800244}
245
Adrian Bunk0bf94fa2007-01-11 14:48:59 +0100246static void hdlc_setup(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
248 hdlc_device *hdlc = dev_to_hdlc(dev);
249
Krzysztof Halasab5284e52007-03-02 15:52:22 -0800250 hdlc_setup_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 hdlc->carrier = 1;
252 hdlc->open = 0;
253 spin_lock_init(&hdlc->state_lock);
254}
255
256struct net_device *alloc_hdlcdev(void *priv)
257{
258 struct net_device *dev;
Tom Gundersenc835a672014-07-14 16:37:24 +0200259 dev = alloc_netdev(sizeof(struct hdlc_device), "hdlc%d",
260 NET_NAME_UNKNOWN, hdlc_setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 if (dev)
262 dev_to_hdlc(dev)->priv = priv;
263 return dev;
264}
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266void unregister_hdlc_device(struct net_device *dev)
267{
268 rtnl_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 unregister_netdevice(dev);
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200270 detach_hdlc_protocol(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 rtnl_unlock();
272}
273
274
275
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200276int attach_hdlc_protocol(struct net_device *dev, struct hdlc_proto *proto,
Krzysztof Halasa40d25142008-02-01 22:37:12 +0100277 size_t size)
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200278{
279 detach_hdlc_protocol(dev);
280
281 if (!try_module_get(proto->module))
282 return -ENOSYS;
283
Joe Perches1d5d1fd2013-02-03 17:28:12 +0000284 if (size) {
285 dev_to_hdlc(dev)->state = kmalloc(size, GFP_KERNEL);
286 if (dev_to_hdlc(dev)->state == NULL) {
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200287 module_put(proto->module);
288 return -ENOBUFS;
289 }
Joe Perches1d5d1fd2013-02-03 17:28:12 +0000290 }
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200291 dev_to_hdlc(dev)->proto = proto;
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200292 return 0;
293}
294
295
296void detach_hdlc_protocol(struct net_device *dev)
297{
298 hdlc_device *hdlc = dev_to_hdlc(dev);
299
300 if (hdlc->proto) {
301 if (hdlc->proto->detach)
302 hdlc->proto->detach(dev);
303 module_put(hdlc->proto->module);
304 hdlc->proto = NULL;
305 }
306 kfree(hdlc->state);
307 hdlc->state = NULL;
Krzysztof Halasab5284e52007-03-02 15:52:22 -0800308 hdlc_setup_dev(dev);
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200309}
310
311
312void register_hdlc_protocol(struct hdlc_proto *proto)
313{
Krzysztof Halasafa701bd2008-05-19 19:00:51 +0200314 rtnl_lock();
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200315 proto->next = first_proto;
316 first_proto = proto;
Krzysztof Halasafa701bd2008-05-19 19:00:51 +0200317 rtnl_unlock();
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200318}
319
320
321void unregister_hdlc_protocol(struct hdlc_proto *proto)
322{
Krzysztof Halasafa701bd2008-05-19 19:00:51 +0200323 struct hdlc_proto **p;
324
325 rtnl_lock();
326 p = &first_proto;
327 while (*p != proto) {
328 BUG_ON(!*p);
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200329 p = &((*p)->next);
330 }
Krzysztof Halasafa701bd2008-05-19 19:00:51 +0200331 *p = proto->next;
332 rtnl_unlock();
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200333}
334
335
336
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
338MODULE_DESCRIPTION("HDLC support module");
339MODULE_LICENSE("GPL v2");
340
Krzysztof Hałasa991990a2009-01-08 22:52:11 +0100341EXPORT_SYMBOL(hdlc_change_mtu);
342EXPORT_SYMBOL(hdlc_start_xmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343EXPORT_SYMBOL(hdlc_open);
344EXPORT_SYMBOL(hdlc_close);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345EXPORT_SYMBOL(hdlc_ioctl);
346EXPORT_SYMBOL(alloc_hdlcdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347EXPORT_SYMBOL(unregister_hdlc_device);
Krzysztof Halasaeb2a2fd2006-09-26 23:23:45 +0200348EXPORT_SYMBOL(register_hdlc_protocol);
349EXPORT_SYMBOL(unregister_hdlc_protocol);
350EXPORT_SYMBOL(attach_hdlc_protocol);
351EXPORT_SYMBOL(detach_hdlc_protocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Stephen Hemminger7546dd92009-03-09 08:18:29 +0000353static struct packet_type hdlc_packet_type __read_mostly = {
Harvey Harrison09640e62009-02-01 00:45:17 -0800354 .type = cpu_to_be16(ETH_P_HDLC),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 .func = hdlc_rcv,
356};
357
358
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700359static struct notifier_block hdlc_notifier = {
Krzysztof Hałasa4dfce402008-06-30 19:06:40 +0200360 .notifier_call = hdlc_device_event,
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700361};
362
363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364static int __init hdlc_module_init(void)
365{
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700366 int result;
367
Joe Perches12a3bfe2011-06-26 19:01:28 +0000368 pr_info("%s\n", version);
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700369 if ((result = register_netdevice_notifier(&hdlc_notifier)) != 0)
Krzysztof Hałasa4dfce402008-06-30 19:06:40 +0200370 return result;
371 dev_add_pack(&hdlc_packet_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 return 0;
373}
374
375
376
377static void __exit hdlc_module_exit(void)
378{
379 dev_remove_pack(&hdlc_packet_type);
Krzysztof Halasac2ce9202006-07-12 13:46:12 -0700380 unregister_netdevice_notifier(&hdlc_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381}
382
383
384module_init(hdlc_module_init);
385module_exit(hdlc_module_exit);