1eb2a2fd9SKrzysztof Halasa /* 2eb2a2fd9SKrzysztof Halasa * Generic HDLC support routines for Linux 3eb2a2fd9SKrzysztof Halasa * 440d25142SKrzysztof Halasa * Copyright (C) 1999 - 2008 Krzysztof Halasa <khc@pm.waw.pl> 5eb2a2fd9SKrzysztof Halasa * 6eb2a2fd9SKrzysztof Halasa * This program is free software; you can redistribute it and/or modify it 7eb2a2fd9SKrzysztof Halasa * under the terms of version 2 of the GNU General Public License 8eb2a2fd9SKrzysztof Halasa * as published by the Free Software Foundation. 9eb2a2fd9SKrzysztof Halasa * 10eb2a2fd9SKrzysztof Halasa * Currently supported: 11eb2a2fd9SKrzysztof Halasa * * raw IP-in-HDLC 12eb2a2fd9SKrzysztof Halasa * * Cisco HDLC 13eb2a2fd9SKrzysztof Halasa * * Frame Relay with ANSI or CCITT LMI (both user and network side) 14eb2a2fd9SKrzysztof Halasa * * PPP 15eb2a2fd9SKrzysztof Halasa * * X.25 16eb2a2fd9SKrzysztof Halasa * 17eb2a2fd9SKrzysztof Halasa * Use sethdlc utility to set line parameters, protocol and PVCs 18eb2a2fd9SKrzysztof Halasa * 19eb2a2fd9SKrzysztof Halasa * How does it work: 20eb2a2fd9SKrzysztof Halasa * - proto->open(), close(), start(), stop() calls are serialized. 21eb2a2fd9SKrzysztof Halasa * The order is: open, [ start, stop ... ] close ... 22eb2a2fd9SKrzysztof Halasa * - proto->start() and stop() are called with spin_lock_irq held. 23eb2a2fd9SKrzysztof Halasa */ 24eb2a2fd9SKrzysztof Halasa 2512a3bfefSJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 2612a3bfefSJoe Perches 27eb2a2fd9SKrzysztof Halasa #include <linux/errno.h> 28eb2a2fd9SKrzysztof Halasa #include <linux/hdlc.h> 294dfce407SKrzysztof Hałasa #include <linux/if_arp.h> 304dfce407SKrzysztof Hałasa #include <linux/inetdevice.h> 314dfce407SKrzysztof Hałasa #include <linux/init.h> 324dfce407SKrzysztof Hałasa #include <linux/kernel.h> 334dfce407SKrzysztof Hałasa #include <linux/module.h> 344dfce407SKrzysztof Hałasa #include <linux/notifier.h> 354dfce407SKrzysztof Hałasa #include <linux/pkt_sched.h> 364dfce407SKrzysztof Hałasa #include <linux/poll.h> 374dfce407SKrzysztof Hałasa #include <linux/rtnetlink.h> 384dfce407SKrzysztof Hałasa #include <linux/skbuff.h> 394dfce407SKrzysztof Hałasa #include <linux/slab.h> 40e730c155SEric W. Biederman #include <net/net_namespace.h> 41eb2a2fd9SKrzysztof Halasa 42eb2a2fd9SKrzysztof Halasa 4340d25142SKrzysztof Halasa static const char* version = "HDLC support module revision 1.22"; 44eb2a2fd9SKrzysztof Halasa 45eb2a2fd9SKrzysztof Halasa #undef DEBUG_LINK 46eb2a2fd9SKrzysztof Halasa 47fa701bd2SKrzysztof Halasa static struct hdlc_proto *first_proto; 48eb2a2fd9SKrzysztof Halasa 49991990a1SKrzysztof Hałasa int hdlc_change_mtu(struct net_device *dev, int new_mtu) 50eb2a2fd9SKrzysztof Halasa { 51eb2a2fd9SKrzysztof Halasa if ((new_mtu < 68) || (new_mtu > HDLC_MAX_MTU)) 52eb2a2fd9SKrzysztof Halasa return -EINVAL; 53eb2a2fd9SKrzysztof Halasa dev->mtu = new_mtu; 54eb2a2fd9SKrzysztof Halasa return 0; 55eb2a2fd9SKrzysztof Halasa } 56eb2a2fd9SKrzysztof Halasa 57eb2a2fd9SKrzysztof Halasa static int hdlc_rcv(struct sk_buff *skb, struct net_device *dev, 58eb2a2fd9SKrzysztof Halasa struct packet_type *p, struct net_device *orig_dev) 59eb2a2fd9SKrzysztof Halasa { 6040d25142SKrzysztof Halasa struct hdlc_device *hdlc = dev_to_hdlc(dev); 61e730c155SEric W. Biederman 6209ad9bc7SOctavian Purdila if (!net_eq(dev_net(dev), &init_net)) { 63e730c155SEric W. Biederman kfree_skb(skb); 64e730c155SEric W. Biederman return 0; 65e730c155SEric W. Biederman } 66e730c155SEric W. Biederman 6740d25142SKrzysztof Halasa BUG_ON(!hdlc->proto->netif_rx); 6840d25142SKrzysztof Halasa return hdlc->proto->netif_rx(skb); 69eb2a2fd9SKrzysztof Halasa } 70eb2a2fd9SKrzysztof Halasa 71d71a6749SStephen Hemminger netdev_tx_t hdlc_start_xmit(struct sk_buff *skb, struct net_device *dev) 72991990a1SKrzysztof Hałasa { 73991990a1SKrzysztof Hałasa hdlc_device *hdlc = dev_to_hdlc(dev); 74eb2a2fd9SKrzysztof Halasa 75991990a1SKrzysztof Hałasa if (hdlc->proto->xmit) 76991990a1SKrzysztof Hałasa return hdlc->proto->xmit(skb, dev); 77991990a1SKrzysztof Hałasa 78991990a1SKrzysztof Hałasa return hdlc->xmit(skb, dev); /* call hardware driver directly */ 79991990a1SKrzysztof Hałasa } 80eb2a2fd9SKrzysztof Halasa 81eb2a2fd9SKrzysztof Halasa static inline void hdlc_proto_start(struct net_device *dev) 82eb2a2fd9SKrzysztof Halasa { 83eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 84eb2a2fd9SKrzysztof Halasa if (hdlc->proto->start) 8540d25142SKrzysztof Halasa hdlc->proto->start(dev); 86eb2a2fd9SKrzysztof Halasa } 87eb2a2fd9SKrzysztof Halasa 88eb2a2fd9SKrzysztof Halasa 89eb2a2fd9SKrzysztof Halasa 90eb2a2fd9SKrzysztof Halasa static inline void hdlc_proto_stop(struct net_device *dev) 91eb2a2fd9SKrzysztof Halasa { 92eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 93eb2a2fd9SKrzysztof Halasa if (hdlc->proto->stop) 9440d25142SKrzysztof Halasa hdlc->proto->stop(dev); 95eb2a2fd9SKrzysztof Halasa } 96eb2a2fd9SKrzysztof Halasa 97eb2a2fd9SKrzysztof Halasa 98eb2a2fd9SKrzysztof Halasa 99eb2a2fd9SKrzysztof Halasa static int hdlc_device_event(struct notifier_block *this, unsigned long event, 100eb2a2fd9SKrzysztof Halasa void *ptr) 101eb2a2fd9SKrzysztof Halasa { 102351638e7SJiri Pirko struct net_device *dev = netdev_notifier_info_to_dev(ptr); 103eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc; 104eb2a2fd9SKrzysztof Halasa unsigned long flags; 105eb2a2fd9SKrzysztof Halasa int on; 106eb2a2fd9SKrzysztof Halasa 10709ad9bc7SOctavian Purdila if (!net_eq(dev_net(dev), &init_net)) 108e9dc8653SEric W. Biederman return NOTIFY_DONE; 109e9dc8653SEric W. Biederman 1107cdc15f5SKrzysztof Hałasa if (!(dev->priv_flags & IFF_WAN_HDLC)) 111eb2a2fd9SKrzysztof Halasa return NOTIFY_DONE; /* not an HDLC device */ 112eb2a2fd9SKrzysztof Halasa 113eb2a2fd9SKrzysztof Halasa if (event != NETDEV_CHANGE) 1146f0b31c3SThomas Weber return NOTIFY_DONE; /* Only interested in carrier changes */ 115eb2a2fd9SKrzysztof Halasa 116eb2a2fd9SKrzysztof Halasa on = netif_carrier_ok(dev); 117eb2a2fd9SKrzysztof Halasa 118eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK 119eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_device_event NETDEV_CHANGE, carrier %i\n", 120eb2a2fd9SKrzysztof Halasa dev->name, on); 121eb2a2fd9SKrzysztof Halasa #endif 122eb2a2fd9SKrzysztof Halasa 123eb2a2fd9SKrzysztof Halasa hdlc = dev_to_hdlc(dev); 124eb2a2fd9SKrzysztof Halasa spin_lock_irqsave(&hdlc->state_lock, flags); 125eb2a2fd9SKrzysztof Halasa 126eb2a2fd9SKrzysztof Halasa if (hdlc->carrier == on) 127eb2a2fd9SKrzysztof Halasa goto carrier_exit; /* no change in DCD line level */ 128eb2a2fd9SKrzysztof Halasa 129eb2a2fd9SKrzysztof Halasa hdlc->carrier = on; 130eb2a2fd9SKrzysztof Halasa 131eb2a2fd9SKrzysztof Halasa if (!hdlc->open) 132eb2a2fd9SKrzysztof Halasa goto carrier_exit; 133eb2a2fd9SKrzysztof Halasa 134eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) { 13512a3bfefSJoe Perches netdev_info(dev, "Carrier detected\n"); 136eb2a2fd9SKrzysztof Halasa hdlc_proto_start(dev); 137eb2a2fd9SKrzysztof Halasa } else { 13812a3bfefSJoe Perches netdev_info(dev, "Carrier lost\n"); 139eb2a2fd9SKrzysztof Halasa hdlc_proto_stop(dev); 140eb2a2fd9SKrzysztof Halasa } 141eb2a2fd9SKrzysztof Halasa 142eb2a2fd9SKrzysztof Halasa carrier_exit: 143eb2a2fd9SKrzysztof Halasa spin_unlock_irqrestore(&hdlc->state_lock, flags); 144eb2a2fd9SKrzysztof Halasa return NOTIFY_DONE; 145eb2a2fd9SKrzysztof Halasa } 146eb2a2fd9SKrzysztof Halasa 147eb2a2fd9SKrzysztof Halasa 148eb2a2fd9SKrzysztof Halasa 149eb2a2fd9SKrzysztof Halasa /* Must be called by hardware driver when HDLC device is being opened */ 150eb2a2fd9SKrzysztof Halasa int hdlc_open(struct net_device *dev) 151eb2a2fd9SKrzysztof Halasa { 152eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 153eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK 154eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_open() carrier %i open %i\n", dev->name, 155eb2a2fd9SKrzysztof Halasa hdlc->carrier, hdlc->open); 156eb2a2fd9SKrzysztof Halasa #endif 157eb2a2fd9SKrzysztof Halasa 158eb2a2fd9SKrzysztof Halasa if (hdlc->proto == NULL) 159eb2a2fd9SKrzysztof Halasa return -ENOSYS; /* no protocol attached */ 160eb2a2fd9SKrzysztof Halasa 161eb2a2fd9SKrzysztof Halasa if (hdlc->proto->open) { 162eb2a2fd9SKrzysztof Halasa int result = hdlc->proto->open(dev); 163eb2a2fd9SKrzysztof Halasa if (result) 164eb2a2fd9SKrzysztof Halasa return result; 165eb2a2fd9SKrzysztof Halasa } 166eb2a2fd9SKrzysztof Halasa 167eb2a2fd9SKrzysztof Halasa spin_lock_irq(&hdlc->state_lock); 168eb2a2fd9SKrzysztof Halasa 169eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) { 17012a3bfefSJoe Perches netdev_info(dev, "Carrier detected\n"); 171eb2a2fd9SKrzysztof Halasa hdlc_proto_start(dev); 172eb2a2fd9SKrzysztof Halasa } else 17312a3bfefSJoe Perches netdev_info(dev, "No carrier\n"); 174eb2a2fd9SKrzysztof Halasa 175eb2a2fd9SKrzysztof Halasa hdlc->open = 1; 176eb2a2fd9SKrzysztof Halasa 177eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock); 178eb2a2fd9SKrzysztof Halasa return 0; 179eb2a2fd9SKrzysztof Halasa } 180eb2a2fd9SKrzysztof Halasa 181eb2a2fd9SKrzysztof Halasa 182eb2a2fd9SKrzysztof Halasa 183eb2a2fd9SKrzysztof Halasa /* Must be called by hardware driver when HDLC device is being closed */ 184eb2a2fd9SKrzysztof Halasa void hdlc_close(struct net_device *dev) 185eb2a2fd9SKrzysztof Halasa { 186eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 187eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK 188eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_close() carrier %i open %i\n", dev->name, 189eb2a2fd9SKrzysztof Halasa hdlc->carrier, hdlc->open); 190eb2a2fd9SKrzysztof Halasa #endif 191eb2a2fd9SKrzysztof Halasa 192eb2a2fd9SKrzysztof Halasa spin_lock_irq(&hdlc->state_lock); 193eb2a2fd9SKrzysztof Halasa 194eb2a2fd9SKrzysztof Halasa hdlc->open = 0; 195eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) 196eb2a2fd9SKrzysztof Halasa hdlc_proto_stop(dev); 197eb2a2fd9SKrzysztof Halasa 198eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock); 199eb2a2fd9SKrzysztof Halasa 200eb2a2fd9SKrzysztof Halasa if (hdlc->proto->close) 201eb2a2fd9SKrzysztof Halasa hdlc->proto->close(dev); 202eb2a2fd9SKrzysztof Halasa } 203eb2a2fd9SKrzysztof Halasa 204eb2a2fd9SKrzysztof Halasa 205eb2a2fd9SKrzysztof Halasa 206eb2a2fd9SKrzysztof Halasa int hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 207eb2a2fd9SKrzysztof Halasa { 208eb2a2fd9SKrzysztof Halasa struct hdlc_proto *proto = first_proto; 209eb2a2fd9SKrzysztof Halasa int result; 210eb2a2fd9SKrzysztof Halasa 211eb2a2fd9SKrzysztof Halasa if (cmd != SIOCWANDEV) 212eb2a2fd9SKrzysztof Halasa return -EINVAL; 213eb2a2fd9SKrzysztof Halasa 214eb2a2fd9SKrzysztof Halasa if (dev_to_hdlc(dev)->proto) { 215eb2a2fd9SKrzysztof Halasa result = dev_to_hdlc(dev)->proto->ioctl(dev, ifr); 216eb2a2fd9SKrzysztof Halasa if (result != -EINVAL) 217eb2a2fd9SKrzysztof Halasa return result; 218eb2a2fd9SKrzysztof Halasa } 219eb2a2fd9SKrzysztof Halasa 220eb2a2fd9SKrzysztof Halasa /* Not handled by currently attached protocol (if any) */ 221eb2a2fd9SKrzysztof Halasa 222eb2a2fd9SKrzysztof Halasa while (proto) { 223eb2a2fd9SKrzysztof Halasa if ((result = proto->ioctl(dev, ifr)) != -EINVAL) 224eb2a2fd9SKrzysztof Halasa return result; 225eb2a2fd9SKrzysztof Halasa proto = proto->next; 226eb2a2fd9SKrzysztof Halasa } 227eb2a2fd9SKrzysztof Halasa return -EINVAL; 228eb2a2fd9SKrzysztof Halasa } 229eb2a2fd9SKrzysztof Halasa 2303b04dddeSStephen Hemminger static const struct header_ops hdlc_null_ops; 2313b04dddeSStephen Hemminger 232b5284e5aSKrzysztof Halasa static void hdlc_setup_dev(struct net_device *dev) 233b5284e5aSKrzysztof Halasa { 234b5284e5aSKrzysztof Halasa /* Re-init all variables changed by HDLC protocol drivers, 235b5284e5aSKrzysztof Halasa * including ether_setup() called from hdlc_raw_eth.c. 236b5284e5aSKrzysztof Halasa */ 237b5284e5aSKrzysztof Halasa dev->flags = IFF_POINTOPOINT | IFF_NOARP; 2387cdc15f5SKrzysztof Hałasa dev->priv_flags = IFF_WAN_HDLC; 239b5284e5aSKrzysztof Halasa dev->mtu = HDLC_MAX_MTU; 240b5284e5aSKrzysztof Halasa dev->type = ARPHRD_RAWHDLC; 241b5284e5aSKrzysztof Halasa dev->hard_header_len = 16; 242b5284e5aSKrzysztof Halasa dev->addr_len = 0; 2433b04dddeSStephen Hemminger dev->header_ops = &hdlc_null_ops; 244b5284e5aSKrzysztof Halasa } 245b5284e5aSKrzysztof Halasa 2460bf94fafSAdrian Bunk static void hdlc_setup(struct net_device *dev) 247eb2a2fd9SKrzysztof Halasa { 248eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 249eb2a2fd9SKrzysztof Halasa 250b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev); 251eb2a2fd9SKrzysztof Halasa hdlc->carrier = 1; 252eb2a2fd9SKrzysztof Halasa hdlc->open = 0; 253eb2a2fd9SKrzysztof Halasa spin_lock_init(&hdlc->state_lock); 254eb2a2fd9SKrzysztof Halasa } 255eb2a2fd9SKrzysztof Halasa 256eb2a2fd9SKrzysztof Halasa struct net_device *alloc_hdlcdev(void *priv) 257eb2a2fd9SKrzysztof Halasa { 258eb2a2fd9SKrzysztof Halasa struct net_device *dev; 259c835a677STom Gundersen dev = alloc_netdev(sizeof(struct hdlc_device), "hdlc%d", 260c835a677STom Gundersen NET_NAME_UNKNOWN, hdlc_setup); 261eb2a2fd9SKrzysztof Halasa if (dev) 262eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->priv = priv; 263eb2a2fd9SKrzysztof Halasa return dev; 264eb2a2fd9SKrzysztof Halasa } 265eb2a2fd9SKrzysztof Halasa 266eb2a2fd9SKrzysztof Halasa void unregister_hdlc_device(struct net_device *dev) 267eb2a2fd9SKrzysztof Halasa { 268eb2a2fd9SKrzysztof Halasa rtnl_lock(); 269eb2a2fd9SKrzysztof Halasa unregister_netdevice(dev); 270eb2a2fd9SKrzysztof Halasa detach_hdlc_protocol(dev); 271eb2a2fd9SKrzysztof Halasa rtnl_unlock(); 272eb2a2fd9SKrzysztof Halasa } 273eb2a2fd9SKrzysztof Halasa 274eb2a2fd9SKrzysztof Halasa 275eb2a2fd9SKrzysztof Halasa 276eb2a2fd9SKrzysztof Halasa int attach_hdlc_protocol(struct net_device *dev, struct hdlc_proto *proto, 27740d25142SKrzysztof Halasa size_t size) 278eb2a2fd9SKrzysztof Halasa { 279eb2a2fd9SKrzysztof Halasa detach_hdlc_protocol(dev); 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); 2861d5d1fdcSJoe Perches if (dev_to_hdlc(dev)->state == NULL) { 287eb2a2fd9SKrzysztof Halasa module_put(proto->module); 288eb2a2fd9SKrzysztof Halasa return -ENOBUFS; 289eb2a2fd9SKrzysztof Halasa } 2901d5d1fdcSJoe Perches } 291eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->proto = proto; 292eb2a2fd9SKrzysztof Halasa return 0; 293eb2a2fd9SKrzysztof Halasa } 294eb2a2fd9SKrzysztof Halasa 295eb2a2fd9SKrzysztof Halasa 296eb2a2fd9SKrzysztof Halasa void detach_hdlc_protocol(struct net_device *dev) 297eb2a2fd9SKrzysztof Halasa { 298eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 299eb2a2fd9SKrzysztof Halasa 300eb2a2fd9SKrzysztof Halasa if (hdlc->proto) { 301eb2a2fd9SKrzysztof Halasa if (hdlc->proto->detach) 302eb2a2fd9SKrzysztof Halasa hdlc->proto->detach(dev); 303eb2a2fd9SKrzysztof Halasa module_put(hdlc->proto->module); 304eb2a2fd9SKrzysztof Halasa hdlc->proto = NULL; 305eb2a2fd9SKrzysztof Halasa } 306eb2a2fd9SKrzysztof Halasa kfree(hdlc->state); 307eb2a2fd9SKrzysztof Halasa hdlc->state = NULL; 308b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev); 309eb2a2fd9SKrzysztof Halasa } 310eb2a2fd9SKrzysztof Halasa 311eb2a2fd9SKrzysztof Halasa 312eb2a2fd9SKrzysztof Halasa void register_hdlc_protocol(struct hdlc_proto *proto) 313eb2a2fd9SKrzysztof Halasa { 314fa701bd2SKrzysztof Halasa rtnl_lock(); 315eb2a2fd9SKrzysztof Halasa proto->next = first_proto; 316eb2a2fd9SKrzysztof Halasa first_proto = proto; 317fa701bd2SKrzysztof Halasa rtnl_unlock(); 318eb2a2fd9SKrzysztof Halasa } 319eb2a2fd9SKrzysztof Halasa 320eb2a2fd9SKrzysztof Halasa 321eb2a2fd9SKrzysztof Halasa void unregister_hdlc_protocol(struct hdlc_proto *proto) 322eb2a2fd9SKrzysztof Halasa { 323fa701bd2SKrzysztof Halasa struct hdlc_proto **p; 324fa701bd2SKrzysztof Halasa 325fa701bd2SKrzysztof Halasa rtnl_lock(); 326fa701bd2SKrzysztof Halasa p = &first_proto; 327fa701bd2SKrzysztof Halasa while (*p != proto) { 328fa701bd2SKrzysztof Halasa BUG_ON(!*p); 329eb2a2fd9SKrzysztof Halasa p = &((*p)->next); 330eb2a2fd9SKrzysztof Halasa } 331fa701bd2SKrzysztof Halasa *p = proto->next; 332fa701bd2SKrzysztof Halasa rtnl_unlock(); 333eb2a2fd9SKrzysztof Halasa } 334eb2a2fd9SKrzysztof Halasa 335eb2a2fd9SKrzysztof Halasa 336eb2a2fd9SKrzysztof Halasa 337eb2a2fd9SKrzysztof Halasa MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>"); 338eb2a2fd9SKrzysztof Halasa MODULE_DESCRIPTION("HDLC support module"); 339eb2a2fd9SKrzysztof Halasa MODULE_LICENSE("GPL v2"); 340eb2a2fd9SKrzysztof Halasa 341991990a1SKrzysztof Hałasa EXPORT_SYMBOL(hdlc_change_mtu); 342991990a1SKrzysztof Hałasa EXPORT_SYMBOL(hdlc_start_xmit); 343eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(hdlc_open); 344eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(hdlc_close); 345eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(hdlc_ioctl); 346eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(alloc_hdlcdev); 347eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(unregister_hdlc_device); 348eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(register_hdlc_protocol); 349eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(unregister_hdlc_protocol); 350eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(attach_hdlc_protocol); 351eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(detach_hdlc_protocol); 352eb2a2fd9SKrzysztof Halasa 3537546dd97SStephen Hemminger static struct packet_type hdlc_packet_type __read_mostly = { 35409640e63SHarvey Harrison .type = cpu_to_be16(ETH_P_HDLC), 355eb2a2fd9SKrzysztof Halasa .func = hdlc_rcv, 356eb2a2fd9SKrzysztof Halasa }; 357eb2a2fd9SKrzysztof Halasa 358eb2a2fd9SKrzysztof Halasa 359eb2a2fd9SKrzysztof Halasa static struct notifier_block hdlc_notifier = { 360eb2a2fd9SKrzysztof Halasa .notifier_call = hdlc_device_event, 361eb2a2fd9SKrzysztof Halasa }; 362eb2a2fd9SKrzysztof Halasa 363eb2a2fd9SKrzysztof Halasa 364eb2a2fd9SKrzysztof Halasa static int __init hdlc_module_init(void) 365eb2a2fd9SKrzysztof Halasa { 366eb2a2fd9SKrzysztof Halasa int result; 367eb2a2fd9SKrzysztof Halasa 36812a3bfefSJoe Perches pr_info("%s\n", version); 369eb2a2fd9SKrzysztof Halasa if ((result = register_netdevice_notifier(&hdlc_notifier)) != 0) 370eb2a2fd9SKrzysztof Halasa return result; 371eb2a2fd9SKrzysztof Halasa dev_add_pack(&hdlc_packet_type); 372eb2a2fd9SKrzysztof Halasa return 0; 373eb2a2fd9SKrzysztof Halasa } 374eb2a2fd9SKrzysztof Halasa 375eb2a2fd9SKrzysztof Halasa 376eb2a2fd9SKrzysztof Halasa 377eb2a2fd9SKrzysztof Halasa static void __exit hdlc_module_exit(void) 378eb2a2fd9SKrzysztof Halasa { 379eb2a2fd9SKrzysztof Halasa dev_remove_pack(&hdlc_packet_type); 380eb2a2fd9SKrzysztof Halasa unregister_netdevice_notifier(&hdlc_notifier); 381eb2a2fd9SKrzysztof Halasa } 382eb2a2fd9SKrzysztof Halasa 383eb2a2fd9SKrzysztof Halasa 384eb2a2fd9SKrzysztof Halasa module_init(hdlc_module_init); 385eb2a2fd9SKrzysztof Halasa module_exit(hdlc_module_exit); 386