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