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