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