1eb2a2fd9SKrzysztof Halasa /* 2eb2a2fd9SKrzysztof Halasa * Generic HDLC support routines for Linux 3eb2a2fd9SKrzysztof Halasa * 4eb2a2fd9SKrzysztof Halasa * Copyright (C) 1999 - 2006 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/module.h> 26eb2a2fd9SKrzysztof Halasa #include <linux/kernel.h> 27eb2a2fd9SKrzysztof Halasa #include <linux/slab.h> 28eb2a2fd9SKrzysztof Halasa #include <linux/poll.h> 29eb2a2fd9SKrzysztof Halasa #include <linux/errno.h> 30eb2a2fd9SKrzysztof Halasa #include <linux/if_arp.h> 31eb2a2fd9SKrzysztof Halasa #include <linux/init.h> 32eb2a2fd9SKrzysztof Halasa #include <linux/skbuff.h> 33eb2a2fd9SKrzysztof Halasa #include <linux/pkt_sched.h> 34eb2a2fd9SKrzysztof Halasa #include <linux/inetdevice.h> 35eb2a2fd9SKrzysztof Halasa #include <linux/lapb.h> 36eb2a2fd9SKrzysztof Halasa #include <linux/rtnetlink.h> 37eb2a2fd9SKrzysztof Halasa #include <linux/notifier.h> 38eb2a2fd9SKrzysztof Halasa #include <linux/hdlc.h> 39eb2a2fd9SKrzysztof Halasa 40eb2a2fd9SKrzysztof Halasa 41b5284e5aSKrzysztof Halasa static const char* version = "HDLC support module revision 1.21"; 42eb2a2fd9SKrzysztof Halasa 43eb2a2fd9SKrzysztof Halasa #undef DEBUG_LINK 44eb2a2fd9SKrzysztof Halasa 45eb2a2fd9SKrzysztof Halasa static struct hdlc_proto *first_proto = NULL; 46eb2a2fd9SKrzysztof Halasa 47eb2a2fd9SKrzysztof Halasa 48eb2a2fd9SKrzysztof Halasa static int hdlc_change_mtu(struct net_device *dev, int new_mtu) 49eb2a2fd9SKrzysztof Halasa { 50eb2a2fd9SKrzysztof Halasa if ((new_mtu < 68) || (new_mtu > HDLC_MAX_MTU)) 51eb2a2fd9SKrzysztof Halasa return -EINVAL; 52eb2a2fd9SKrzysztof Halasa dev->mtu = new_mtu; 53eb2a2fd9SKrzysztof Halasa return 0; 54eb2a2fd9SKrzysztof Halasa } 55eb2a2fd9SKrzysztof Halasa 56eb2a2fd9SKrzysztof Halasa 57eb2a2fd9SKrzysztof Halasa 58eb2a2fd9SKrzysztof Halasa static struct net_device_stats *hdlc_get_stats(struct net_device *dev) 59eb2a2fd9SKrzysztof Halasa { 60eb2a2fd9SKrzysztof Halasa return hdlc_stats(dev); 61eb2a2fd9SKrzysztof Halasa } 62eb2a2fd9SKrzysztof Halasa 63eb2a2fd9SKrzysztof Halasa 64eb2a2fd9SKrzysztof Halasa 65eb2a2fd9SKrzysztof Halasa static int hdlc_rcv(struct sk_buff *skb, struct net_device *dev, 66eb2a2fd9SKrzysztof Halasa struct packet_type *p, struct net_device *orig_dev) 67eb2a2fd9SKrzysztof Halasa { 68eb2a2fd9SKrzysztof Halasa struct hdlc_device_desc *desc = dev_to_desc(dev); 69eb2a2fd9SKrzysztof Halasa if (desc->netif_rx) 70eb2a2fd9SKrzysztof Halasa return desc->netif_rx(skb); 71eb2a2fd9SKrzysztof Halasa 72eb2a2fd9SKrzysztof Halasa desc->stats.rx_dropped++; /* Shouldn't happen */ 73eb2a2fd9SKrzysztof Halasa dev_kfree_skb(skb); 74eb2a2fd9SKrzysztof Halasa return NET_RX_DROP; 75eb2a2fd9SKrzysztof Halasa } 76eb2a2fd9SKrzysztof Halasa 77eb2a2fd9SKrzysztof Halasa 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) 83eb2a2fd9SKrzysztof Halasa return 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) 92eb2a2fd9SKrzysztof Halasa return 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 105eb2a2fd9SKrzysztof Halasa if (dev->get_stats != hdlc_get_stats) 106eb2a2fd9SKrzysztof Halasa return NOTIFY_DONE; /* not an HDLC device */ 107eb2a2fd9SKrzysztof Halasa 108eb2a2fd9SKrzysztof Halasa if (event != NETDEV_CHANGE) 109eb2a2fd9SKrzysztof Halasa return NOTIFY_DONE; /* Only interrested 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) { 130eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s: Carrier detected\n", dev->name); 131eb2a2fd9SKrzysztof Halasa hdlc_proto_start(dev); 132eb2a2fd9SKrzysztof Halasa } else { 133eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s: Carrier lost\n", dev->name); 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 143eb2a2fd9SKrzysztof Halasa 144eb2a2fd9SKrzysztof Halasa /* Must be called by hardware driver when HDLC device is being opened */ 145eb2a2fd9SKrzysztof Halasa int hdlc_open(struct net_device *dev) 146eb2a2fd9SKrzysztof Halasa { 147eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 148eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK 149eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_open() carrier %i open %i\n", dev->name, 150eb2a2fd9SKrzysztof Halasa hdlc->carrier, hdlc->open); 151eb2a2fd9SKrzysztof Halasa #endif 152eb2a2fd9SKrzysztof Halasa 153eb2a2fd9SKrzysztof Halasa if (hdlc->proto == NULL) 154eb2a2fd9SKrzysztof Halasa return -ENOSYS; /* no protocol attached */ 155eb2a2fd9SKrzysztof Halasa 156eb2a2fd9SKrzysztof Halasa if (hdlc->proto->open) { 157eb2a2fd9SKrzysztof Halasa int result = hdlc->proto->open(dev); 158eb2a2fd9SKrzysztof Halasa if (result) 159eb2a2fd9SKrzysztof Halasa return result; 160eb2a2fd9SKrzysztof Halasa } 161eb2a2fd9SKrzysztof Halasa 162eb2a2fd9SKrzysztof Halasa spin_lock_irq(&hdlc->state_lock); 163eb2a2fd9SKrzysztof Halasa 164eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) { 165eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s: Carrier detected\n", dev->name); 166eb2a2fd9SKrzysztof Halasa hdlc_proto_start(dev); 167eb2a2fd9SKrzysztof Halasa } else 168eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s: No carrier\n", dev->name); 169eb2a2fd9SKrzysztof Halasa 170eb2a2fd9SKrzysztof Halasa hdlc->open = 1; 171eb2a2fd9SKrzysztof Halasa 172eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock); 173eb2a2fd9SKrzysztof Halasa return 0; 174eb2a2fd9SKrzysztof Halasa } 175eb2a2fd9SKrzysztof Halasa 176eb2a2fd9SKrzysztof Halasa 177eb2a2fd9SKrzysztof Halasa 178eb2a2fd9SKrzysztof Halasa /* Must be called by hardware driver when HDLC device is being closed */ 179eb2a2fd9SKrzysztof Halasa void hdlc_close(struct net_device *dev) 180eb2a2fd9SKrzysztof Halasa { 181eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 182eb2a2fd9SKrzysztof Halasa #ifdef DEBUG_LINK 183eb2a2fd9SKrzysztof Halasa printk(KERN_DEBUG "%s: hdlc_close() carrier %i open %i\n", dev->name, 184eb2a2fd9SKrzysztof Halasa hdlc->carrier, hdlc->open); 185eb2a2fd9SKrzysztof Halasa #endif 186eb2a2fd9SKrzysztof Halasa 187eb2a2fd9SKrzysztof Halasa spin_lock_irq(&hdlc->state_lock); 188eb2a2fd9SKrzysztof Halasa 189eb2a2fd9SKrzysztof Halasa hdlc->open = 0; 190eb2a2fd9SKrzysztof Halasa if (hdlc->carrier) 191eb2a2fd9SKrzysztof Halasa hdlc_proto_stop(dev); 192eb2a2fd9SKrzysztof Halasa 193eb2a2fd9SKrzysztof Halasa spin_unlock_irq(&hdlc->state_lock); 194eb2a2fd9SKrzysztof Halasa 195eb2a2fd9SKrzysztof Halasa if (hdlc->proto->close) 196eb2a2fd9SKrzysztof Halasa hdlc->proto->close(dev); 197eb2a2fd9SKrzysztof Halasa } 198eb2a2fd9SKrzysztof Halasa 199eb2a2fd9SKrzysztof Halasa 200eb2a2fd9SKrzysztof Halasa 201eb2a2fd9SKrzysztof Halasa int hdlc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 202eb2a2fd9SKrzysztof Halasa { 203eb2a2fd9SKrzysztof Halasa struct hdlc_proto *proto = first_proto; 204eb2a2fd9SKrzysztof Halasa int result; 205eb2a2fd9SKrzysztof Halasa 206eb2a2fd9SKrzysztof Halasa if (cmd != SIOCWANDEV) 207eb2a2fd9SKrzysztof Halasa return -EINVAL; 208eb2a2fd9SKrzysztof Halasa 209eb2a2fd9SKrzysztof Halasa if (dev_to_hdlc(dev)->proto) { 210eb2a2fd9SKrzysztof Halasa result = dev_to_hdlc(dev)->proto->ioctl(dev, ifr); 211eb2a2fd9SKrzysztof Halasa if (result != -EINVAL) 212eb2a2fd9SKrzysztof Halasa return result; 213eb2a2fd9SKrzysztof Halasa } 214eb2a2fd9SKrzysztof Halasa 215eb2a2fd9SKrzysztof Halasa /* Not handled by currently attached protocol (if any) */ 216eb2a2fd9SKrzysztof Halasa 217eb2a2fd9SKrzysztof Halasa while (proto) { 218eb2a2fd9SKrzysztof Halasa if ((result = proto->ioctl(dev, ifr)) != -EINVAL) 219eb2a2fd9SKrzysztof Halasa return result; 220eb2a2fd9SKrzysztof Halasa proto = proto->next; 221eb2a2fd9SKrzysztof Halasa } 222eb2a2fd9SKrzysztof Halasa return -EINVAL; 223eb2a2fd9SKrzysztof Halasa } 224eb2a2fd9SKrzysztof Halasa 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->get_stats = hdlc_get_stats; 231b5284e5aSKrzysztof Halasa dev->flags = IFF_POINTOPOINT | IFF_NOARP; 232b5284e5aSKrzysztof Halasa dev->mtu = HDLC_MAX_MTU; 233b5284e5aSKrzysztof Halasa dev->type = ARPHRD_RAWHDLC; 234b5284e5aSKrzysztof Halasa dev->hard_header_len = 16; 235b5284e5aSKrzysztof Halasa dev->addr_len = 0; 236b5284e5aSKrzysztof Halasa dev->hard_header = NULL; 237b5284e5aSKrzysztof Halasa dev->rebuild_header = NULL; 238b5284e5aSKrzysztof Halasa dev->set_mac_address = NULL; 239b5284e5aSKrzysztof Halasa dev->hard_header_cache = NULL; 240b5284e5aSKrzysztof Halasa dev->header_cache_update = NULL; 241b5284e5aSKrzysztof Halasa dev->change_mtu = hdlc_change_mtu; 242b5284e5aSKrzysztof Halasa dev->hard_header_parse = NULL; 243b5284e5aSKrzysztof Halasa } 244b5284e5aSKrzysztof Halasa 2450bf94fafSAdrian Bunk static void hdlc_setup(struct net_device *dev) 246eb2a2fd9SKrzysztof Halasa { 247eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 248eb2a2fd9SKrzysztof Halasa 249b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev); 250eb2a2fd9SKrzysztof Halasa hdlc->carrier = 1; 251eb2a2fd9SKrzysztof Halasa hdlc->open = 0; 252eb2a2fd9SKrzysztof Halasa spin_lock_init(&hdlc->state_lock); 253eb2a2fd9SKrzysztof Halasa } 254eb2a2fd9SKrzysztof Halasa 255eb2a2fd9SKrzysztof Halasa struct net_device *alloc_hdlcdev(void *priv) 256eb2a2fd9SKrzysztof Halasa { 257eb2a2fd9SKrzysztof Halasa struct net_device *dev; 258eb2a2fd9SKrzysztof Halasa dev = alloc_netdev(sizeof(struct hdlc_device_desc) + 259eb2a2fd9SKrzysztof Halasa sizeof(hdlc_device), "hdlc%d", hdlc_setup); 260eb2a2fd9SKrzysztof Halasa if (dev) 261eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->priv = priv; 262eb2a2fd9SKrzysztof Halasa return dev; 263eb2a2fd9SKrzysztof Halasa } 264eb2a2fd9SKrzysztof Halasa 265eb2a2fd9SKrzysztof Halasa void unregister_hdlc_device(struct net_device *dev) 266eb2a2fd9SKrzysztof Halasa { 267eb2a2fd9SKrzysztof Halasa rtnl_lock(); 268eb2a2fd9SKrzysztof Halasa unregister_netdevice(dev); 269eb2a2fd9SKrzysztof Halasa detach_hdlc_protocol(dev); 270eb2a2fd9SKrzysztof Halasa rtnl_unlock(); 271eb2a2fd9SKrzysztof Halasa } 272eb2a2fd9SKrzysztof Halasa 273eb2a2fd9SKrzysztof Halasa 274eb2a2fd9SKrzysztof Halasa 275eb2a2fd9SKrzysztof Halasa int attach_hdlc_protocol(struct net_device *dev, struct hdlc_proto *proto, 276eb2a2fd9SKrzysztof Halasa int (*rx)(struct sk_buff *skb), size_t size) 277eb2a2fd9SKrzysztof Halasa { 278eb2a2fd9SKrzysztof Halasa detach_hdlc_protocol(dev); 279eb2a2fd9SKrzysztof Halasa 280eb2a2fd9SKrzysztof Halasa if (!try_module_get(proto->module)) 281eb2a2fd9SKrzysztof Halasa return -ENOSYS; 282eb2a2fd9SKrzysztof Halasa 283eb2a2fd9SKrzysztof Halasa if (size) 284eb2a2fd9SKrzysztof Halasa if ((dev_to_hdlc(dev)->state = kmalloc(size, 285eb2a2fd9SKrzysztof Halasa GFP_KERNEL)) == NULL) { 286eb2a2fd9SKrzysztof Halasa printk(KERN_WARNING "Memory squeeze on" 287eb2a2fd9SKrzysztof Halasa " hdlc_proto_attach()\n"); 288eb2a2fd9SKrzysztof Halasa module_put(proto->module); 289eb2a2fd9SKrzysztof Halasa return -ENOBUFS; 290eb2a2fd9SKrzysztof Halasa } 291eb2a2fd9SKrzysztof Halasa dev_to_hdlc(dev)->proto = proto; 292eb2a2fd9SKrzysztof Halasa dev_to_desc(dev)->netif_rx = rx; 293eb2a2fd9SKrzysztof Halasa return 0; 294eb2a2fd9SKrzysztof Halasa } 295eb2a2fd9SKrzysztof Halasa 296eb2a2fd9SKrzysztof Halasa 297eb2a2fd9SKrzysztof Halasa void detach_hdlc_protocol(struct net_device *dev) 298eb2a2fd9SKrzysztof Halasa { 299eb2a2fd9SKrzysztof Halasa hdlc_device *hdlc = dev_to_hdlc(dev); 300eb2a2fd9SKrzysztof Halasa 301eb2a2fd9SKrzysztof Halasa if (hdlc->proto) { 302eb2a2fd9SKrzysztof Halasa if (hdlc->proto->detach) 303eb2a2fd9SKrzysztof Halasa hdlc->proto->detach(dev); 304eb2a2fd9SKrzysztof Halasa module_put(hdlc->proto->module); 305eb2a2fd9SKrzysztof Halasa hdlc->proto = NULL; 306eb2a2fd9SKrzysztof Halasa } 307eb2a2fd9SKrzysztof Halasa kfree(hdlc->state); 308eb2a2fd9SKrzysztof Halasa hdlc->state = NULL; 309b5284e5aSKrzysztof Halasa hdlc_setup_dev(dev); 310eb2a2fd9SKrzysztof Halasa } 311eb2a2fd9SKrzysztof Halasa 312eb2a2fd9SKrzysztof Halasa 313eb2a2fd9SKrzysztof Halasa void register_hdlc_protocol(struct hdlc_proto *proto) 314eb2a2fd9SKrzysztof Halasa { 315eb2a2fd9SKrzysztof Halasa proto->next = first_proto; 316eb2a2fd9SKrzysztof Halasa first_proto = proto; 317eb2a2fd9SKrzysztof Halasa } 318eb2a2fd9SKrzysztof Halasa 319eb2a2fd9SKrzysztof Halasa 320eb2a2fd9SKrzysztof Halasa void unregister_hdlc_protocol(struct hdlc_proto *proto) 321eb2a2fd9SKrzysztof Halasa { 322eb2a2fd9SKrzysztof Halasa struct hdlc_proto **p = &first_proto; 323eb2a2fd9SKrzysztof Halasa while (*p) { 324eb2a2fd9SKrzysztof Halasa if (*p == proto) { 325eb2a2fd9SKrzysztof Halasa *p = proto->next; 326eb2a2fd9SKrzysztof Halasa return; 327eb2a2fd9SKrzysztof Halasa } 328eb2a2fd9SKrzysztof Halasa p = &((*p)->next); 329eb2a2fd9SKrzysztof Halasa } 330eb2a2fd9SKrzysztof Halasa } 331eb2a2fd9SKrzysztof Halasa 332eb2a2fd9SKrzysztof Halasa 333eb2a2fd9SKrzysztof Halasa 334eb2a2fd9SKrzysztof Halasa MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>"); 335eb2a2fd9SKrzysztof Halasa MODULE_DESCRIPTION("HDLC support module"); 336eb2a2fd9SKrzysztof Halasa MODULE_LICENSE("GPL v2"); 337eb2a2fd9SKrzysztof Halasa 338eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(hdlc_open); 339eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(hdlc_close); 340eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(hdlc_ioctl); 341eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(alloc_hdlcdev); 342eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(unregister_hdlc_device); 343eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(register_hdlc_protocol); 344eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(unregister_hdlc_protocol); 345eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(attach_hdlc_protocol); 346eb2a2fd9SKrzysztof Halasa EXPORT_SYMBOL(detach_hdlc_protocol); 347eb2a2fd9SKrzysztof Halasa 348eb2a2fd9SKrzysztof Halasa static struct packet_type hdlc_packet_type = { 349eb2a2fd9SKrzysztof Halasa .type = __constant_htons(ETH_P_HDLC), 350eb2a2fd9SKrzysztof Halasa .func = hdlc_rcv, 351eb2a2fd9SKrzysztof Halasa }; 352eb2a2fd9SKrzysztof Halasa 353eb2a2fd9SKrzysztof Halasa 354eb2a2fd9SKrzysztof Halasa static struct notifier_block hdlc_notifier = { 355eb2a2fd9SKrzysztof Halasa .notifier_call = hdlc_device_event, 356eb2a2fd9SKrzysztof Halasa }; 357eb2a2fd9SKrzysztof Halasa 358eb2a2fd9SKrzysztof Halasa 359eb2a2fd9SKrzysztof Halasa static int __init hdlc_module_init(void) 360eb2a2fd9SKrzysztof Halasa { 361eb2a2fd9SKrzysztof Halasa int result; 362eb2a2fd9SKrzysztof Halasa 363eb2a2fd9SKrzysztof Halasa printk(KERN_INFO "%s\n", version); 364eb2a2fd9SKrzysztof Halasa if ((result = register_netdevice_notifier(&hdlc_notifier)) != 0) 365eb2a2fd9SKrzysztof Halasa return result; 366eb2a2fd9SKrzysztof Halasa dev_add_pack(&hdlc_packet_type); 367eb2a2fd9SKrzysztof Halasa return 0; 368eb2a2fd9SKrzysztof Halasa } 369eb2a2fd9SKrzysztof Halasa 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 379eb2a2fd9SKrzysztof Halasa module_init(hdlc_module_init); 380eb2a2fd9SKrzysztof Halasa module_exit(hdlc_module_exit); 381