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 25eb2a2fd9SKrzysztof Halasa #include <linux/errno.h> 26eb2a2fd9SKrzysztof Halasa #include <linux/hdlc.h> 274dfce407SKrzysztof Hałasa #include <linux/if_arp.h> 284dfce407SKrzysztof Hałasa #include <linux/inetdevice.h> 294dfce407SKrzysztof Hałasa #include <linux/init.h> 304dfce407SKrzysztof Hałasa #include <linux/kernel.h> 314dfce407SKrzysztof Hałasa #include <linux/module.h> 324dfce407SKrzysztof Hałasa #include <linux/notifier.h> 334dfce407SKrzysztof Hałasa #include <linux/pkt_sched.h> 344dfce407SKrzysztof Hałasa #include <linux/poll.h> 354dfce407SKrzysztof Hałasa #include <linux/rtnetlink.h> 364dfce407SKrzysztof Hałasa #include <linux/skbuff.h> 374dfce407SKrzysztof Hałasa #include <linux/slab.h> 38e730c155SEric W. Biederman #include <net/net_namespace.h> 39eb2a2fd9SKrzysztof Halasa 40eb2a2fd9SKrzysztof Halasa 4140d25142SKrzysztof Halasa static const char* version = "HDLC support module revision 1.22"; 42eb2a2fd9SKrzysztof Halasa 43eb2a2fd9SKrzysztof Halasa #undef DEBUG_LINK 44eb2a2fd9SKrzysztof Halasa 45fa701bd2SKrzysztof Halasa static struct hdlc_proto *first_proto; 46eb2a2fd9SKrzysztof Halasa 47991990a1SKrzysztof Hałasa int hdlc_change_mtu(struct net_device *dev, int new_mtu) 48eb2a2fd9SKrzysztof Halasa { 49eb2a2fd9SKrzysztof Halasa if ((new_mtu < 68) || (new_mtu > HDLC_MAX_MTU)) 50eb2a2fd9SKrzysztof Halasa return -EINVAL; 51eb2a2fd9SKrzysztof Halasa dev->mtu = new_mtu; 52eb2a2fd9SKrzysztof Halasa return 0; 53eb2a2fd9SKrzysztof Halasa } 54eb2a2fd9SKrzysztof Halasa 55eb2a2fd9SKrzysztof Halasa static int hdlc_rcv(struct sk_buff *skb, struct net_device *dev, 56eb2a2fd9SKrzysztof Halasa struct packet_type *p, struct net_device *orig_dev) 57eb2a2fd9SKrzysztof Halasa { 5840d25142SKrzysztof Halasa struct hdlc_device *hdlc = dev_to_hdlc(dev); 59e730c155SEric W. Biederman 6009ad9bc7SOctavian Purdila if (!net_eq(dev_net(dev), &init_net)) { 61e730c155SEric W. Biederman kfree_skb(skb); 62e730c155SEric W. Biederman return 0; 63e730c155SEric W. Biederman } 64e730c155SEric W. Biederman 6540d25142SKrzysztof Halasa BUG_ON(!hdlc->proto->netif_rx); 6640d25142SKrzysztof Halasa return hdlc->proto->netif_rx(skb); 67eb2a2fd9SKrzysztof Halasa } 68eb2a2fd9SKrzysztof Halasa 69d71a6749SStephen Hemminger netdev_tx_t hdlc_start_xmit(struct sk_buff *skb, struct net_device *dev) 70991990a1SKrzysztof Hałasa { 71991990a1SKrzysztof Hałasa hdlc_device *hdlc = dev_to_hdlc(dev); 72eb2a2fd9SKrzysztof Halasa 73991990a1SKrzysztof Hałasa if (hdlc->proto->xmit) 74991990a1SKrzysztof Hałasa return hdlc->proto->xmit(skb, dev); 75991990a1SKrzysztof Hałasa 76991990a1SKrzysztof Hałasa return hdlc->xmit(skb, dev); /* call hardware driver directly */ 77991990a1SKrzysztof Hałasa } 78eb2a2fd9SKrzysztof Halasa 79eb2a2fd9SKrzysztof Halasa static inline void hdlc_proto_start(struct net_device *dev) 80eb2a2fd9SKrzysztof Halasa { 81eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 82eb2a2fd9SKrzysztof Halasa if (hdlc->proto->start) 8340d25142SKrzysztof Halasa hdlc->proto->start(dev); 84eb2a2fd9SKrzysztof Halasa } 85eb2a2fd9SKrzysztof Halasa 86eb2a2fd9SKrzysztof Halasa 87eb2a2fd9SKrzysztof Halasa 88eb2a2fd9SKrzysztof Halasa static inline void hdlc_proto_stop(struct net_device *dev) 89eb2a2fd9SKrzysztof Halasa { 90eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 91eb2a2fd9SKrzysztof Halasa if (hdlc->proto->stop) 9240d25142SKrzysztof Halasa hdlc->proto->stop(dev); 93eb2a2fd9SKrzysztof Halasa } 94eb2a2fd9SKrzysztof Halasa 95eb2a2fd9SKrzysztof Halasa 96eb2a2fd9SKrzysztof Halasa 97eb2a2fd9SKrzysztof Halasa static int hdlc_device_event(struct notifier_block *this, unsigned long event, 98eb2a2fd9SKrzysztof Halasa void *ptr) 99eb2a2fd9SKrzysztof Halasa { 100eb2a2fd9SKrzysztof Halasa struct net_device *dev = ptr; 101eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc; 102eb2a2fd9SKrzysztof Halasa unsigned long flags; 103eb2a2fd9SKrzysztof Halasa int on; 104eb2a2fd9SKrzysztof Halasa 10509ad9bc7SOctavian Purdila if (!net_eq(dev_net(dev), &init_net)) 106e9dc8653SEric W. Biederman return NOTIFY_DONE; 107e9dc8653SEric W. Biederman 1087cdc15f5SKrzysztof Hałasa if (!(dev->priv_flags & IFF_WAN_HDLC)) 109eb2a2fd9SKrzysztof Halasa return NOTIFY_DONE; /* not an HDLC device */ 110eb2a2fd9SKrzysztof Halasa 111eb2a2fd9SKrzysztof Halasa if (event != NETDEV_CHANGE) 112eb2a2fd9SKrzysztof Halasa return NOTIFY_DONE; /* Only interrested in carrier changes */ 113eb2a2fd9SKrzysztof Halasa 114eb2a2fd9SKrzysztof Halasa on = netif_carrier_ok(dev); 115eb2a2fd9SKrzysztof Halasa 116eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK 117eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_device_event NETDEV_CHANGE, carrier %i\n", 118eb2a2fd9SKrzysztof Halasa dev->name, on); 119eb2a2fd9SKrzysztof Halasa #endif 120eb2a2fd9SKrzysztof Halasa 121eb2a2fd9SKrzysztof Halasa hdlc = dev_to_hdlc(dev); 122eb2a2fd9SKrzysztof Halasa spin_lock_irqsave(&hdlc->state_lock, flags); 123eb2a2fd9SKrzysztof Halasa 124eb2a2fd9SKrzysztof Halasa if (hdlc->carrier == on) 125eb2a2fd9SKrzysztof Halasa goto carrier_exit; /* no change in DCD line level */ 126eb2a2fd9SKrzysztof Halasa 127eb2a2fd9SKrzysztof Halasa hdlc->carrier = on; 128eb2a2fd9SKrzysztof Halasa 129eb2a2fd9SKrzysztof Halasa if (!hdlc->open) 130eb2a2fd9SKrzysztof Halasa goto carrier_exit; 131eb2a2fd9SKrzysztof Halasa 132eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) { 133eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s: Carrier detected\n", dev->name); 134eb2a2fd9SKrzysztof Halasa hdlc_proto_start(dev); 135eb2a2fd9SKrzysztof Halasa } else { 136eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s: Carrier lost\n", dev->name); 137eb2a2fd9SKrzysztof Halasa hdlc_proto_stop(dev); 138eb2a2fd9SKrzysztof Halasa } 139eb2a2fd9SKrzysztof Halasa 140eb2a2fd9SKrzysztof Halasa carrier_exit: 141eb2a2fd9SKrzysztof Halasa spin_unlock_irqrestore(&hdlc->state_lock, flags); 142eb2a2fd9SKrzysztof Halasa return NOTIFY_DONE; 143eb2a2fd9SKrzysztof Halasa } 144eb2a2fd9SKrzysztof Halasa 145eb2a2fd9SKrzysztof Halasa 146eb2a2fd9SKrzysztof Halasa 147eb2a2fd9SKrzysztof Halasa /* Must be called by hardware driver when HDLC device is being opened */ 148eb2a2fd9SKrzysztof Halasa int hdlc_open(struct net_device *dev) 149eb2a2fd9SKrzysztof Halasa { 150eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 151eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK 152eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_open() carrier %i open %i\n", dev->name, 153eb2a2fd9SKrzysztof Halasa hdlc->carrier, hdlc->open); 154eb2a2fd9SKrzysztof Halasa #endif 155eb2a2fd9SKrzysztof Halasa 156eb2a2fd9SKrzysztof Halasa if (hdlc->proto == NULL) 157eb2a2fd9SKrzysztof Halasa return -ENOSYS; /* no protocol attached */ 158eb2a2fd9SKrzysztof Halasa 159eb2a2fd9SKrzysztof Halasa if (hdlc->proto->open) { 160eb2a2fd9SKrzysztof Halasa int result = hdlc->proto->open(dev); 161eb2a2fd9SKrzysztof Halasa if (result) 162eb2a2fd9SKrzysztof Halasa return result; 163eb2a2fd9SKrzysztof Halasa } 164eb2a2fd9SKrzysztof Halasa 165eb2a2fd9SKrzysztof Halasa spin_lock_irq(&hdlc->state_lock); 166eb2a2fd9SKrzysztof Halasa 167eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) { 168eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s: Carrier detected\n", dev->name); 169eb2a2fd9SKrzysztof Halasa hdlc_proto_start(dev); 170eb2a2fd9SKrzysztof Halasa } else 171eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s: No carrier\n", dev->name); 172eb2a2fd9SKrzysztof Halasa 173eb2a2fd9SKrzysztof Halasa hdlc->open = 1; 174eb2a2fd9SKrzysztof Halasa 175eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock); 176eb2a2fd9SKrzysztof Halasa return 0; 177eb2a2fd9SKrzysztof Halasa } 178eb2a2fd9SKrzysztof Halasa 179eb2a2fd9SKrzysztof Halasa 180eb2a2fd9SKrzysztof Halasa 181eb2a2fd9SKrzysztof Halasa /* Must be called by hardware driver when HDLC device is being closed */ 182eb2a2fd9SKrzysztof Halasa void hdlc_close(struct net_device *dev) 183eb2a2fd9SKrzysztof Halasa { 184eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 185eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK 186eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_close() carrier %i open %i\n", dev->name, 187eb2a2fd9SKrzysztof Halasa hdlc->carrier, hdlc->open); 188eb2a2fd9SKrzysztof Halasa #endif 189eb2a2fd9SKrzysztof Halasa 190eb2a2fd9SKrzysztof Halasa spin_lock_irq(&hdlc->state_lock); 191eb2a2fd9SKrzysztof Halasa 192eb2a2fd9SKrzysztof Halasa hdlc->open = 0; 193eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) 194eb2a2fd9SKrzysztof Halasa hdlc_proto_stop(dev); 195eb2a2fd9SKrzysztof Halasa 196eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock); 197eb2a2fd9SKrzysztof Halasa 198eb2a2fd9SKrzysztof Halasa if (hdlc->proto->close) 199eb2a2fd9SKrzysztof Halasa hdlc->proto->close(dev); 200eb2a2fd9SKrzysztof Halasa } 201eb2a2fd9SKrzysztof Halasa 202eb2a2fd9SKrzysztof Halasa 203eb2a2fd9SKrzysztof Halasa 204eb2a2fd9SKrzysztof Halasa int hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 205eb2a2fd9SKrzysztof Halasa { 206eb2a2fd9SKrzysztof Halasa struct hdlc_proto *proto = first_proto; 207eb2a2fd9SKrzysztof Halasa int result; 208eb2a2fd9SKrzysztof Halasa 209eb2a2fd9SKrzysztof Halasa if (cmd != SIOCWANDEV) 210eb2a2fd9SKrzysztof Halasa return -EINVAL; 211eb2a2fd9SKrzysztof Halasa 212eb2a2fd9SKrzysztof Halasa if (dev_to_hdlc(dev)->proto) { 213eb2a2fd9SKrzysztof Halasa result = dev_to_hdlc(dev)->proto->ioctl(dev, ifr); 214eb2a2fd9SKrzysztof Halasa if (result != -EINVAL) 215eb2a2fd9SKrzysztof Halasa return result; 216eb2a2fd9SKrzysztof Halasa } 217eb2a2fd9SKrzysztof Halasa 218eb2a2fd9SKrzysztof Halasa /* Not handled by currently attached protocol (if any) */ 219eb2a2fd9SKrzysztof Halasa 220eb2a2fd9SKrzysztof Halasa while (proto) { 221eb2a2fd9SKrzysztof Halasa if ((result = proto->ioctl(dev, ifr)) != -EINVAL) 222eb2a2fd9SKrzysztof Halasa return result; 223eb2a2fd9SKrzysztof Halasa proto = proto->next; 224eb2a2fd9SKrzysztof Halasa } 225eb2a2fd9SKrzysztof Halasa return -EINVAL; 226eb2a2fd9SKrzysztof Halasa } 227eb2a2fd9SKrzysztof Halasa 2283b04dddeSStephen Hemminger static const struct header_ops hdlc_null_ops; 2293b04dddeSStephen Hemminger 230b5284e5aSKrzysztof Halasa static void hdlc_setup_dev(struct net_device *dev) 231b5284e5aSKrzysztof Halasa { 232b5284e5aSKrzysztof Halasa /* Re-init all variables changed by HDLC protocol drivers, 233b5284e5aSKrzysztof Halasa * including ether_setup() called from hdlc_raw_eth.c. 234b5284e5aSKrzysztof Halasa */ 235b5284e5aSKrzysztof Halasa dev->flags = IFF_POINTOPOINT | IFF_NOARP; 2367cdc15f5SKrzysztof Hałasa dev->priv_flags = IFF_WAN_HDLC; 237b5284e5aSKrzysztof Halasa dev->mtu = HDLC_MAX_MTU; 238b5284e5aSKrzysztof Halasa dev->type = ARPHRD_RAWHDLC; 239b5284e5aSKrzysztof Halasa dev->hard_header_len = 16; 240b5284e5aSKrzysztof Halasa dev->addr_len = 0; 2413b04dddeSStephen Hemminger dev->header_ops = &hdlc_null_ops; 242b5284e5aSKrzysztof Halasa } 243b5284e5aSKrzysztof Halasa 2440bf94fafSAdrian Bunk static void hdlc_setup(struct net_device *dev) 245eb2a2fd9SKrzysztof Halasa { 246eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 247eb2a2fd9SKrzysztof Halasa 248b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev); 249eb2a2fd9SKrzysztof Halasa hdlc->carrier = 1; 250eb2a2fd9SKrzysztof Halasa hdlc->open = 0; 251eb2a2fd9SKrzysztof Halasa spin_lock_init(&hdlc->state_lock); 252eb2a2fd9SKrzysztof Halasa } 253eb2a2fd9SKrzysztof Halasa 254eb2a2fd9SKrzysztof Halasa struct net_device *alloc_hdlcdev(void *priv) 255eb2a2fd9SKrzysztof Halasa { 256eb2a2fd9SKrzysztof Halasa struct net_device *dev; 25740d25142SKrzysztof Halasa dev = alloc_netdev(sizeof(struct hdlc_device), "hdlc%d", hdlc_setup); 258eb2a2fd9SKrzysztof Halasa if (dev) 259eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->priv = priv; 260eb2a2fd9SKrzysztof Halasa return dev; 261eb2a2fd9SKrzysztof Halasa } 262eb2a2fd9SKrzysztof Halasa 263eb2a2fd9SKrzysztof Halasa void unregister_hdlc_device(struct net_device *dev) 264eb2a2fd9SKrzysztof Halasa { 265eb2a2fd9SKrzysztof Halasa rtnl_lock(); 266eb2a2fd9SKrzysztof Halasa unregister_netdevice(dev); 267eb2a2fd9SKrzysztof Halasa detach_hdlc_protocol(dev); 268eb2a2fd9SKrzysztof Halasa rtnl_unlock(); 269eb2a2fd9SKrzysztof Halasa } 270eb2a2fd9SKrzysztof Halasa 271eb2a2fd9SKrzysztof Halasa 272eb2a2fd9SKrzysztof Halasa 273eb2a2fd9SKrzysztof Halasa int attach_hdlc_protocol(struct net_device *dev, struct hdlc_proto *proto, 27440d25142SKrzysztof Halasa size_t size) 275eb2a2fd9SKrzysztof Halasa { 276eb2a2fd9SKrzysztof Halasa detach_hdlc_protocol(dev); 277eb2a2fd9SKrzysztof Halasa 278eb2a2fd9SKrzysztof Halasa if (!try_module_get(proto->module)) 279eb2a2fd9SKrzysztof Halasa return -ENOSYS; 280eb2a2fd9SKrzysztof Halasa 281eb2a2fd9SKrzysztof Halasa if (size) 282eb2a2fd9SKrzysztof Halasa if ((dev_to_hdlc(dev)->state = kmalloc(size, 283eb2a2fd9SKrzysztof Halasa GFP_KERNEL)) == NULL) { 284eb2a2fd9SKrzysztof Halasa printk(KERN_WARNING "Memory squeeze on" 285eb2a2fd9SKrzysztof Halasa " hdlc_proto_attach()\n"); 286eb2a2fd9SKrzysztof Halasa module_put(proto->module); 287eb2a2fd9SKrzysztof Halasa return -ENOBUFS; 288eb2a2fd9SKrzysztof Halasa } 289eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->proto = proto; 290eb2a2fd9SKrzysztof Halasa return 0; 291eb2a2fd9SKrzysztof Halasa } 292eb2a2fd9SKrzysztof Halasa 293eb2a2fd9SKrzysztof Halasa 294eb2a2fd9SKrzysztof Halasa void detach_hdlc_protocol(struct net_device *dev) 295eb2a2fd9SKrzysztof Halasa { 296eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 297eb2a2fd9SKrzysztof Halasa 298eb2a2fd9SKrzysztof Halasa if (hdlc->proto) { 299eb2a2fd9SKrzysztof Halasa if (hdlc->proto->detach) 300eb2a2fd9SKrzysztof Halasa hdlc->proto->detach(dev); 301eb2a2fd9SKrzysztof Halasa module_put(hdlc->proto->module); 302eb2a2fd9SKrzysztof Halasa hdlc->proto = NULL; 303eb2a2fd9SKrzysztof Halasa } 304eb2a2fd9SKrzysztof Halasa kfree(hdlc->state); 305eb2a2fd9SKrzysztof Halasa hdlc->state = NULL; 306b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev); 307eb2a2fd9SKrzysztof Halasa } 308eb2a2fd9SKrzysztof Halasa 309eb2a2fd9SKrzysztof Halasa 310eb2a2fd9SKrzysztof Halasa void register_hdlc_protocol(struct hdlc_proto *proto) 311eb2a2fd9SKrzysztof Halasa { 312fa701bd2SKrzysztof Halasa rtnl_lock(); 313eb2a2fd9SKrzysztof Halasa proto->next = first_proto; 314eb2a2fd9SKrzysztof Halasa first_proto = proto; 315fa701bd2SKrzysztof Halasa rtnl_unlock(); 316eb2a2fd9SKrzysztof Halasa } 317eb2a2fd9SKrzysztof Halasa 318eb2a2fd9SKrzysztof Halasa 319eb2a2fd9SKrzysztof Halasa void unregister_hdlc_protocol(struct hdlc_proto *proto) 320eb2a2fd9SKrzysztof Halasa { 321fa701bd2SKrzysztof Halasa struct hdlc_proto **p; 322fa701bd2SKrzysztof Halasa 323fa701bd2SKrzysztof Halasa rtnl_lock(); 324fa701bd2SKrzysztof Halasa p = &first_proto; 325fa701bd2SKrzysztof Halasa while (*p != proto) { 326fa701bd2SKrzysztof Halasa BUG_ON(!*p); 327eb2a2fd9SKrzysztof Halasa p = &((*p)->next); 328eb2a2fd9SKrzysztof Halasa } 329fa701bd2SKrzysztof Halasa *p = proto->next; 330fa701bd2SKrzysztof Halasa rtnl_unlock(); 331eb2a2fd9SKrzysztof Halasa } 332eb2a2fd9SKrzysztof Halasa 333eb2a2fd9SKrzysztof Halasa 334eb2a2fd9SKrzysztof Halasa 335eb2a2fd9SKrzysztof Halasa MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>"); 336eb2a2fd9SKrzysztof Halasa MODULE_DESCRIPTION("HDLC support module"); 337eb2a2fd9SKrzysztof Halasa MODULE_LICENSE("GPL v2"); 338eb2a2fd9SKrzysztof Halasa 339991990a1SKrzysztof Hałasa EXPORT_SYMBOL(hdlc_change_mtu); 340991990a1SKrzysztof Hałasa EXPORT_SYMBOL(hdlc_start_xmit); 341eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(hdlc_open); 342eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(hdlc_close); 343eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(hdlc_ioctl); 344eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(alloc_hdlcdev); 345eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(unregister_hdlc_device); 346eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(register_hdlc_protocol); 347eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(unregister_hdlc_protocol); 348eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(attach_hdlc_protocol); 349eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(detach_hdlc_protocol); 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 357eb2a2fd9SKrzysztof Halasa static struct notifier_block hdlc_notifier = { 358eb2a2fd9SKrzysztof Halasa .notifier_call = hdlc_device_event, 359eb2a2fd9SKrzysztof Halasa }; 360eb2a2fd9SKrzysztof Halasa 361eb2a2fd9SKrzysztof Halasa 362eb2a2fd9SKrzysztof Halasa static int __init hdlc_module_init(void) 363eb2a2fd9SKrzysztof Halasa { 364eb2a2fd9SKrzysztof Halasa int result; 365eb2a2fd9SKrzysztof Halasa 366eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s\n", version); 367eb2a2fd9SKrzysztof Halasa if ((result = register_netdevice_notifier(&hdlc_notifier)) != 0) 368eb2a2fd9SKrzysztof Halasa return result; 369eb2a2fd9SKrzysztof Halasa dev_add_pack(&hdlc_packet_type); 370eb2a2fd9SKrzysztof Halasa return 0; 371eb2a2fd9SKrzysztof Halasa } 372eb2a2fd9SKrzysztof Halasa 373eb2a2fd9SKrzysztof Halasa 374eb2a2fd9SKrzysztof Halasa 375eb2a2fd9SKrzysztof Halasa static void __exit hdlc_module_exit(void) 376eb2a2fd9SKrzysztof Halasa { 377eb2a2fd9SKrzysztof Halasa dev_remove_pack(&hdlc_packet_type); 378eb2a2fd9SKrzysztof Halasa unregister_netdevice_notifier(&hdlc_notifier); 379eb2a2fd9SKrzysztof Halasa } 380eb2a2fd9SKrzysztof Halasa 381eb2a2fd9SKrzysztof Halasa 382eb2a2fd9SKrzysztof Halasa module_init(hdlc_module_init); 383eb2a2fd9SKrzysztof Halasa module_exit(hdlc_module_exit); 384