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 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 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 } 76*01506939SPeng Li EXPORT_SYMBOL(hdlc_start_xmit); 77eb2a2fd9SKrzysztof Halasa 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 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 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 */ 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 151eb2a2fd9SKrzysztof Halasa if (hdlc->proto == NULL) 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); 166eb2a2fd9SKrzysztof Halasa } else 16712a3bfefSJoe Perches netdev_info(dev, "No carrier\n"); 168eb2a2fd9SKrzysztof Halasa 169eb2a2fd9SKrzysztof Halasa hdlc->open = 1; 170eb2a2fd9SKrzysztof Halasa 171eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock); 172eb2a2fd9SKrzysztof Halasa return 0; 173eb2a2fd9SKrzysztof Halasa } 174*01506939SPeng Li EXPORT_SYMBOL(hdlc_open); 175eb2a2fd9SKrzysztof Halasa 176eb2a2fd9SKrzysztof Halasa /* Must be called by hardware driver when HDLC device is being closed */ 177eb2a2fd9SKrzysztof Halasa void hdlc_close(struct net_device *dev) 178eb2a2fd9SKrzysztof Halasa { 179eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 180eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK 181eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_close() carrier %i open %i\n", dev->name, 182eb2a2fd9SKrzysztof Halasa hdlc->carrier, hdlc->open); 183eb2a2fd9SKrzysztof Halasa #endif 184eb2a2fd9SKrzysztof Halasa 185eb2a2fd9SKrzysztof Halasa spin_lock_irq(&hdlc->state_lock); 186eb2a2fd9SKrzysztof Halasa 187eb2a2fd9SKrzysztof Halasa hdlc->open = 0; 188eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) 189eb2a2fd9SKrzysztof Halasa hdlc_proto_stop(dev); 190eb2a2fd9SKrzysztof Halasa 191eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock); 192eb2a2fd9SKrzysztof Halasa 193eb2a2fd9SKrzysztof Halasa if (hdlc->proto->close) 194eb2a2fd9SKrzysztof Halasa hdlc->proto->close(dev); 195eb2a2fd9SKrzysztof Halasa } 196*01506939SPeng Li EXPORT_SYMBOL(hdlc_close); 197eb2a2fd9SKrzysztof Halasa 198eb2a2fd9SKrzysztof Halasa int hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 199eb2a2fd9SKrzysztof Halasa { 200eb2a2fd9SKrzysztof Halasa struct hdlc_proto *proto = first_proto; 201eb2a2fd9SKrzysztof Halasa int result; 202eb2a2fd9SKrzysztof Halasa 203eb2a2fd9SKrzysztof Halasa if (cmd != SIOCWANDEV) 204eb2a2fd9SKrzysztof Halasa return -EINVAL; 205eb2a2fd9SKrzysztof Halasa 206eb2a2fd9SKrzysztof Halasa if (dev_to_hdlc(dev)->proto) { 207eb2a2fd9SKrzysztof Halasa result = dev_to_hdlc(dev)->proto->ioctl(dev, ifr); 208eb2a2fd9SKrzysztof Halasa if (result != -EINVAL) 209eb2a2fd9SKrzysztof Halasa return result; 210eb2a2fd9SKrzysztof Halasa } 211eb2a2fd9SKrzysztof Halasa 212eb2a2fd9SKrzysztof Halasa /* Not handled by currently attached protocol (if any) */ 213eb2a2fd9SKrzysztof Halasa 214eb2a2fd9SKrzysztof Halasa while (proto) { 215eb2a2fd9SKrzysztof Halasa if ((result = proto->ioctl(dev, ifr)) != -EINVAL) 216eb2a2fd9SKrzysztof Halasa return result; 217eb2a2fd9SKrzysztof Halasa proto = proto->next; 218eb2a2fd9SKrzysztof Halasa } 219eb2a2fd9SKrzysztof Halasa return -EINVAL; 220eb2a2fd9SKrzysztof Halasa } 221*01506939SPeng Li EXPORT_SYMBOL(hdlc_ioctl); 222eb2a2fd9SKrzysztof Halasa 2233b04dddeSStephen Hemminger static const struct header_ops hdlc_null_ops; 2243b04dddeSStephen Hemminger 225b5284e5aSKrzysztof Halasa static void hdlc_setup_dev(struct net_device *dev) 226b5284e5aSKrzysztof Halasa { 227b5284e5aSKrzysztof Halasa /* Re-init all variables changed by HDLC protocol drivers, 228b5284e5aSKrzysztof Halasa * including ether_setup() called from hdlc_raw_eth.c. 229b5284e5aSKrzysztof Halasa */ 230b5284e5aSKrzysztof Halasa dev->flags = IFF_POINTOPOINT | IFF_NOARP; 2317cdc15f5SKrzysztof Hałasa dev->priv_flags = IFF_WAN_HDLC; 232b5284e5aSKrzysztof Halasa dev->mtu = HDLC_MAX_MTU; 2338b6b4135SJarod Wilson dev->min_mtu = 68; 2348b6b4135SJarod Wilson dev->max_mtu = HDLC_MAX_MTU; 235b5284e5aSKrzysztof Halasa dev->type = ARPHRD_RAWHDLC; 2362b7bcd96SXie He dev->hard_header_len = 0; 23777b981c8SXie He dev->needed_headroom = 0; 238b5284e5aSKrzysztof Halasa dev->addr_len = 0; 2393b04dddeSStephen Hemminger dev->header_ops = &hdlc_null_ops; 240b5284e5aSKrzysztof Halasa } 241b5284e5aSKrzysztof Halasa 2420bf94fafSAdrian Bunk static void hdlc_setup(struct net_device *dev) 243eb2a2fd9SKrzysztof Halasa { 244eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 245eb2a2fd9SKrzysztof Halasa 246b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev); 247eb2a2fd9SKrzysztof Halasa hdlc->carrier = 1; 248eb2a2fd9SKrzysztof Halasa hdlc->open = 0; 249eb2a2fd9SKrzysztof Halasa spin_lock_init(&hdlc->state_lock); 250eb2a2fd9SKrzysztof Halasa } 251eb2a2fd9SKrzysztof Halasa 252eb2a2fd9SKrzysztof Halasa struct net_device *alloc_hdlcdev(void *priv) 253eb2a2fd9SKrzysztof Halasa { 254eb2a2fd9SKrzysztof Halasa struct net_device *dev; 25504cc04f0SPeng Li 256c835a677STom Gundersen dev = alloc_netdev(sizeof(struct hdlc_device), "hdlc%d", 257c835a677STom Gundersen NET_NAME_UNKNOWN, hdlc_setup); 258eb2a2fd9SKrzysztof Halasa if (dev) 259eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->priv = priv; 260eb2a2fd9SKrzysztof Halasa return dev; 261eb2a2fd9SKrzysztof Halasa } 262*01506939SPeng Li EXPORT_SYMBOL(alloc_hdlcdev); 263eb2a2fd9SKrzysztof Halasa 264eb2a2fd9SKrzysztof Halasa void unregister_hdlc_device(struct net_device *dev) 265eb2a2fd9SKrzysztof Halasa { 266eb2a2fd9SKrzysztof Halasa rtnl_lock(); 267eb2a2fd9SKrzysztof Halasa detach_hdlc_protocol(dev); 268ff351644SAndrew Lunn unregister_netdevice(dev); 269eb2a2fd9SKrzysztof Halasa rtnl_unlock(); 270eb2a2fd9SKrzysztof Halasa } 271*01506939SPeng Li EXPORT_SYMBOL(unregister_hdlc_device); 272eb2a2fd9SKrzysztof Halasa 273eb2a2fd9SKrzysztof Halasa int attach_hdlc_protocol(struct net_device *dev, struct hdlc_proto *proto, 27440d25142SKrzysztof Halasa size_t size) 275eb2a2fd9SKrzysztof Halasa { 2762f8364a2SAndrew Lunn int err; 2772f8364a2SAndrew Lunn 2782f8364a2SAndrew Lunn err = detach_hdlc_protocol(dev); 2792f8364a2SAndrew Lunn if (err) 2802f8364a2SAndrew Lunn return err; 281eb2a2fd9SKrzysztof Halasa 282eb2a2fd9SKrzysztof Halasa if (!try_module_get(proto->module)) 283eb2a2fd9SKrzysztof Halasa return -ENOSYS; 284eb2a2fd9SKrzysztof Halasa 2851d5d1fdcSJoe Perches if (size) { 2861d5d1fdcSJoe Perches dev_to_hdlc(dev)->state = kmalloc(size, GFP_KERNEL); 2871d5d1fdcSJoe Perches if (dev_to_hdlc(dev)->state == NULL) { 288eb2a2fd9SKrzysztof Halasa module_put(proto->module); 289eb2a2fd9SKrzysztof Halasa return -ENOBUFS; 290eb2a2fd9SKrzysztof Halasa } 2911d5d1fdcSJoe Perches } 292eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->proto = proto; 2932f8364a2SAndrew Lunn 294eb2a2fd9SKrzysztof Halasa return 0; 295eb2a2fd9SKrzysztof Halasa } 296*01506939SPeng Li EXPORT_SYMBOL(attach_hdlc_protocol); 297eb2a2fd9SKrzysztof Halasa 2982f8364a2SAndrew Lunn int detach_hdlc_protocol(struct net_device *dev) 299eb2a2fd9SKrzysztof Halasa { 300eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 3012f8364a2SAndrew Lunn int err; 302eb2a2fd9SKrzysztof Halasa 303eb2a2fd9SKrzysztof Halasa if (hdlc->proto) { 3042f8364a2SAndrew Lunn err = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE, dev); 3052f8364a2SAndrew Lunn err = notifier_to_errno(err); 3062f8364a2SAndrew Lunn if (err) { 3072f8364a2SAndrew Lunn netdev_err(dev, "Refused to change device type\n"); 3082f8364a2SAndrew Lunn return err; 3092f8364a2SAndrew Lunn } 3102f8364a2SAndrew Lunn 311eb2a2fd9SKrzysztof Halasa if (hdlc->proto->detach) 312eb2a2fd9SKrzysztof Halasa hdlc->proto->detach(dev); 313eb2a2fd9SKrzysztof Halasa module_put(hdlc->proto->module); 314eb2a2fd9SKrzysztof Halasa hdlc->proto = NULL; 315eb2a2fd9SKrzysztof Halasa } 316eb2a2fd9SKrzysztof Halasa kfree(hdlc->state); 317eb2a2fd9SKrzysztof Halasa hdlc->state = NULL; 318b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev); 3192f8364a2SAndrew Lunn 3202f8364a2SAndrew Lunn return 0; 321eb2a2fd9SKrzysztof Halasa } 322*01506939SPeng Li EXPORT_SYMBOL(detach_hdlc_protocol); 323eb2a2fd9SKrzysztof Halasa 324eb2a2fd9SKrzysztof Halasa void register_hdlc_protocol(struct hdlc_proto *proto) 325eb2a2fd9SKrzysztof Halasa { 326fa701bd2SKrzysztof Halasa rtnl_lock(); 327eb2a2fd9SKrzysztof Halasa proto->next = first_proto; 328eb2a2fd9SKrzysztof Halasa first_proto = proto; 329fa701bd2SKrzysztof Halasa rtnl_unlock(); 330eb2a2fd9SKrzysztof Halasa } 331*01506939SPeng Li EXPORT_SYMBOL(register_hdlc_protocol); 332eb2a2fd9SKrzysztof Halasa 333eb2a2fd9SKrzysztof Halasa void unregister_hdlc_protocol(struct hdlc_proto *proto) 334eb2a2fd9SKrzysztof Halasa { 335fa701bd2SKrzysztof Halasa struct hdlc_proto **p; 336fa701bd2SKrzysztof Halasa 337fa701bd2SKrzysztof Halasa rtnl_lock(); 338fa701bd2SKrzysztof Halasa p = &first_proto; 339fa701bd2SKrzysztof Halasa while (*p != proto) { 340fa701bd2SKrzysztof Halasa BUG_ON(!*p); 341eb2a2fd9SKrzysztof Halasa p = &((*p)->next); 342eb2a2fd9SKrzysztof Halasa } 343fa701bd2SKrzysztof Halasa *p = proto->next; 344fa701bd2SKrzysztof Halasa rtnl_unlock(); 345eb2a2fd9SKrzysztof Halasa } 346*01506939SPeng Li EXPORT_SYMBOL(unregister_hdlc_protocol); 347eb2a2fd9SKrzysztof Halasa 348eb2a2fd9SKrzysztof Halasa MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>"); 349eb2a2fd9SKrzysztof Halasa MODULE_DESCRIPTION("HDLC support module"); 350eb2a2fd9SKrzysztof Halasa MODULE_LICENSE("GPL v2"); 351eb2a2fd9SKrzysztof Halasa 3527546dd97SStephen Hemminger static struct packet_type hdlc_packet_type __read_mostly = { 35309640e63SHarvey Harrison .type = cpu_to_be16(ETH_P_HDLC), 354eb2a2fd9SKrzysztof Halasa .func = hdlc_rcv, 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 static int __init hdlc_module_init(void) 362eb2a2fd9SKrzysztof Halasa { 363eb2a2fd9SKrzysztof Halasa int result; 364eb2a2fd9SKrzysztof Halasa 36512a3bfefSJoe Perches pr_info("%s\n", version); 366eb2a2fd9SKrzysztof Halasa if ((result = register_netdevice_notifier(&hdlc_notifier)) != 0) 367eb2a2fd9SKrzysztof Halasa return result; 368eb2a2fd9SKrzysztof Halasa dev_add_pack(&hdlc_packet_type); 369eb2a2fd9SKrzysztof Halasa return 0; 370eb2a2fd9SKrzysztof Halasa } 371eb2a2fd9SKrzysztof Halasa 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