2 * An implementation of the Acorn Econet and AUN protocols.
3 * Philip Blundell <philb@gnu.org>
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version
8 * 2 of the License, or (at your option) any later version.
12 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/string.h>
18 #include <linux/socket.h>
19 #include <linux/sockios.h>
21 #include <linux/errno.h>
22 #include <linux/interrupt.h>
23 #include <linux/if_ether.h>
24 #include <linux/netdevice.h>
25 #include <linux/inetdevice.h>
26 #include <linux/route.h>
27 #include <linux/inet.h>
28 #include <linux/etherdevice.h>
29 #include <linux/if_arp.h>
30 #include <linux/wireless.h>
31 #include <linux/skbuff.h>
32 #include <linux/udp.h>
33 #include <linux/slab.h>
35 #include <net/inet_common.h>
36 #include <linux/stat.h>
37 #include <linux/init.h>
38 #include <linux/if_ec.h>
41 #include <linux/spinlock.h>
42 #include <linux/rcupdate.h>
43 #include <linux/bitops.h>
44 #include <linux/mutex.h>
46 #include <asm/uaccess.h>
47 #include <asm/system.h>
49 static const struct proto_ops econet_ops;
50 static struct hlist_head econet_sklist;
51 static DEFINE_SPINLOCK(econet_lock);
52 static DEFINE_MUTEX(econet_mutex);
54 /* Since there are only 256 possible network numbers (or fewer, depends
55 how you count) it makes sense to use a simple lookup table. */
56 static struct net_device *net2dev_map[256];
58 #define EC_PORT_IP 0xd2
60 #ifdef CONFIG_ECONET_AUNUDP
61 static DEFINE_SPINLOCK(aun_queue_lock);
62 static struct socket *udpsock;
63 #define AUN_PORT 0x8000
68 unsigned char code; /* AUN magic protocol byte */
75 static unsigned long aun_seq;
77 /* Queue of packets waiting to be transmitted. */
78 static struct sk_buff_head aun_queue;
79 static struct timer_list ab_cleanup_timer;
81 #endif /* CONFIG_ECONET_AUNUDP */
83 /* Per-packet information */
86 struct sockaddr_ec sec;
87 unsigned long cookie; /* Supplied by user. */
88 #ifdef CONFIG_ECONET_AUNUDP
90 unsigned long seq; /* Sequencing */
91 unsigned long timeout; /* Timeout */
92 unsigned long start; /* jiffies */
94 #ifdef CONFIG_ECONET_NATIVE
95 void (*sent)(struct sk_buff *, int result);
99 static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
101 spin_lock_bh(&econet_lock);
102 sk_del_node_init(sk);
103 spin_unlock_bh(&econet_lock);
106 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
108 spin_lock_bh(&econet_lock);
109 sk_add_node(sk, list);
110 spin_unlock_bh(&econet_lock);
114 * Pull a packet from our receive queue and hand it to the user.
115 * If necessary we block.
118 static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
119 struct msghdr *msg, size_t len, int flags)
121 struct sock *sk = sock->sk;
126 msg->msg_namelen = sizeof(struct sockaddr_ec);
128 mutex_lock(&econet_mutex);
131 * Call the generic datagram receiver. This handles all sorts
132 * of horrible races and re-entrancy so we can forget about it
133 * in the protocol layers.
135 * Now it will return ENETDOWN, if device have just gone down,
136 * but then it will block.
139 skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
142 * An error occurred so return it. Because skb_recv_datagram()
143 * handles the blocking we don't see and worry about blocking
151 * You lose any data beyond the buffer you gave. If it worries a
152 * user program they can ask the device for its MTU anyway.
159 msg->msg_flags|=MSG_TRUNC;
162 /* We can't use skb_copy_datagram here */
163 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
166 sk->sk_stamp = skb->tstamp;
169 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
172 * Free or return the buffer as appropriate. Again this
173 * hides all the races and re-entrancy issues from us.
178 skb_free_datagram(sk, skb);
180 mutex_unlock(&econet_mutex);
185 * Bind an Econet socket.
188 static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
190 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
192 struct econet_sock *eo;
198 if (addr_len < sizeof(struct sockaddr_ec) ||
199 sec->sec_family != AF_ECONET)
202 mutex_lock(&econet_mutex);
208 eo->port = sec->port;
209 eo->station = sec->addr.station;
210 eo->net = sec->addr.net;
212 mutex_unlock(&econet_mutex);
217 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
219 * Queue a transmit result for the user to be told about.
222 static void tx_result(struct sock *sk, unsigned long cookie, int result)
224 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
226 struct sockaddr_ec *sec;
230 printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
234 eb = (struct ec_cb *)&skb->cb;
235 sec = (struct sockaddr_ec *)&eb->sec;
236 memset(sec, 0, sizeof(struct sockaddr_ec));
237 sec->cookie = cookie;
238 sec->type = ECTYPE_TRANSMIT_STATUS | result;
239 sec->sec_family = AF_ECONET;
241 if (sock_queue_rcv_skb(sk, skb) < 0)
246 #ifdef CONFIG_ECONET_NATIVE
248 * Called by the Econet hardware driver when a packet transmit
249 * has completed. Tell the user.
252 static void ec_tx_done(struct sk_buff *skb, int result)
254 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
255 tx_result(skb->sk, eb->cookie, result);
260 * Send a packet. We have to work out which device it's going out on
261 * and hence whether to use real Econet or the UDP emulation.
264 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
265 struct msghdr *msg, size_t len)
267 struct sock *sk = sock->sk;
268 struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
269 struct net_device *dev;
272 unsigned char port, cb;
273 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
277 #ifdef CONFIG_ECONET_AUNUDP
278 struct msghdr udpmsg;
279 struct iovec iov[msg->msg_iovlen+1];
281 struct sockaddr_in udpdest;
282 __kernel_size_t size;
291 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
295 * Get and verify the address.
298 mutex_lock(&econet_mutex);
300 if (saddr == NULL || msg->msg_namelen < sizeof(struct sockaddr_ec)) {
301 mutex_unlock(&econet_mutex);
304 addr.station = saddr->addr.station;
305 addr.net = saddr->addr.net;
309 /* Look for a device with the right network number. */
310 dev = net2dev_map[addr.net];
312 /* If not directly reachable, use some default */
314 dev = net2dev_map[0];
315 /* No interfaces at all? */
317 mutex_unlock(&econet_mutex);
322 if (len + 15 > dev->mtu) {
323 mutex_unlock(&econet_mutex);
327 if (dev->type == ARPHRD_ECONET) {
328 /* Real hardware Econet. We're not worthy etc. */
329 #ifdef CONFIG_ECONET_NATIVE
330 unsigned short proto = 0;
335 skb = sock_alloc_send_skb(sk, len+LL_ALLOCATED_SPACE(dev),
336 msg->msg_flags & MSG_DONTWAIT, &err);
340 skb_reserve(skb, LL_RESERVED_SPACE(dev));
341 skb_reset_network_header(skb);
343 eb = (struct ec_cb *)&skb->cb;
345 eb->cookie = saddr->cookie;
347 eb->sent = ec_tx_done;
350 res = dev_hard_header(skb, dev, ntohs(proto), &addr, NULL, len);
354 struct ec_framehdr *fh;
355 /* Poke in our control byte and
356 port number. Hack, hack. */
357 fh = (struct ec_framehdr *)(skb->data);
360 if (sock->type != SOCK_DGRAM) {
361 skb_reset_tail_pointer(skb);
366 /* Copy the data. Returns -EFAULT on error */
367 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
368 skb->protocol = proto;
370 skb->priority = sk->sk_priority;
375 if (!(dev->flags & IFF_UP))
384 mutex_unlock(&econet_mutex);
395 mutex_unlock(&econet_mutex);
400 #ifdef CONFIG_ECONET_AUNUDP
401 /* AUN virtual Econet. */
403 if (udpsock == NULL) {
404 mutex_unlock(&econet_mutex);
405 return -ENETDOWN; /* No socket - can't send */
408 /* Make up a UDP datagram and hand it off to some higher intellect. */
410 memset(&udpdest, 0, sizeof(udpdest));
411 udpdest.sin_family = AF_INET;
412 udpdest.sin_port = htons(AUN_PORT);
414 /* At the moment we use the stupid Acorn scheme of Econet address
415 y.x maps to IP a.b.c.x. This should be replaced with something
416 more flexible and more aware of subnet masks. */
418 struct in_device *idev;
419 unsigned long network = 0;
422 idev = __in_dev_get_rcu(dev);
425 network = ntohl(idev->ifa_list->ifa_address) &
426 0xffffff00; /* !!! */
429 udpdest.sin_addr.s_addr = htonl(network | addr.station);
434 ah.code = 2; /* magic */
437 /* tack our header on the front of the iovec */
438 size = sizeof(struct aunhdr);
440 * XXX: that is b0rken. We can't mix userland and kernel pointers
441 * in iovec, since on a lot of platforms copy_from_user() will
442 * *not* work with the kernel and userland ones at the same time,
443 * regardless of what we do with set_fs(). And we are talking about
444 * econet-over-ethernet here, so "it's only ARM anyway" doesn't
445 * apply. Any suggestions on fixing that code? -- AV
447 iov[0].iov_base = (void *)&ah;
448 iov[0].iov_len = size;
449 for (i = 0; i < msg->msg_iovlen; i++) {
450 void __user *base = msg->msg_iov[i].iov_base;
451 size_t iov_len = msg->msg_iov[i].iov_len;
452 /* Check it now since we switch to KERNEL_DS later. */
453 if (!access_ok(VERIFY_READ, base, iov_len)) {
454 mutex_unlock(&econet_mutex);
457 iov[i+1].iov_base = base;
458 iov[i+1].iov_len = iov_len;
462 /* Get a skbuff (no data, just holds our cb information) */
463 if ((skb = sock_alloc_send_skb(sk, 0,
464 msg->msg_flags & MSG_DONTWAIT,
466 mutex_unlock(&econet_mutex);
470 eb = (struct ec_cb *)&skb->cb;
472 eb->cookie = saddr->cookie;
473 eb->timeout = (5*HZ);
476 eb->seq = (aun_seq++);
479 skb_queue_tail(&aun_queue, skb);
481 udpmsg.msg_name = (void *)&udpdest;
482 udpmsg.msg_namelen = sizeof(udpdest);
483 udpmsg.msg_iov = &iov[0];
484 udpmsg.msg_iovlen = msg->msg_iovlen + 1;
485 udpmsg.msg_control = NULL;
486 udpmsg.msg_controllen = 0;
489 oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
490 err = sock_sendmsg(udpsock, &udpmsg, size);
495 mutex_unlock(&econet_mutex);
501 * Look up the address of a socket.
504 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
505 int *uaddr_len, int peer)
508 struct econet_sock *eo;
509 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
514 memset(sec, 0, sizeof(*sec));
515 mutex_lock(&econet_mutex);
520 sec->sec_family = AF_ECONET;
521 sec->port = eo->port;
522 sec->addr.station = eo->station;
523 sec->addr.net = eo->net;
525 mutex_unlock(&econet_mutex);
527 *uaddr_len = sizeof(*sec);
531 static void econet_destroy_timer(unsigned long data)
533 struct sock *sk=(struct sock *)data;
535 if (!sk_has_allocations(sk)) {
540 sk->sk_timer.expires = jiffies + 10 * HZ;
541 add_timer(&sk->sk_timer);
542 printk(KERN_DEBUG "econet socket destroy delayed\n");
546 * Close an econet socket.
549 static int econet_release(struct socket *sock)
553 mutex_lock(&econet_mutex);
559 econet_remove_socket(&econet_sklist, sk);
562 * Now the socket is dead. No more input will appear.
565 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
571 skb_queue_purge(&sk->sk_receive_queue);
573 if (sk_has_allocations(sk)) {
574 sk->sk_timer.data = (unsigned long)sk;
575 sk->sk_timer.expires = jiffies + HZ;
576 sk->sk_timer.function = econet_destroy_timer;
577 add_timer(&sk->sk_timer);
585 mutex_unlock(&econet_mutex);
589 static struct proto econet_proto = {
591 .owner = THIS_MODULE,
592 .obj_size = sizeof(struct econet_sock),
596 * Create an Econet socket
599 static int econet_create(struct net *net, struct socket *sock, int protocol,
603 struct econet_sock *eo;
606 if (!net_eq(net, &init_net))
607 return -EAFNOSUPPORT;
609 /* Econet only provides datagram services. */
610 if (sock->type != SOCK_DGRAM)
611 return -ESOCKTNOSUPPORT;
613 sock->state = SS_UNCONNECTED;
616 sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
621 sock->ops = &econet_ops;
622 sock_init_data(sock, sk);
625 sock_reset_flag(sk, SOCK_ZAPPED);
626 sk->sk_family = PF_ECONET;
629 econet_insert_socket(&econet_sklist, sk);
636 * Handle Econet specific ioctls
639 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
642 struct ec_device *edev;
643 struct net_device *dev;
644 struct sockaddr_ec *sec;
648 * Fetch the caller's info block into kernel space
651 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
654 if ((dev = dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
657 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
659 mutex_lock(&econet_mutex);
664 if (!capable(CAP_NET_ADMIN))
669 /* Magic up a new one. */
670 edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
677 net2dev_map[edev->net] = NULL;
678 edev->station = sec->addr.station;
679 edev->net = sec->addr.net;
680 net2dev_map[sec->addr.net] = dev;
682 net2dev_map[0] = dev;
691 memset(sec, 0, sizeof(struct sockaddr_ec));
692 sec->addr.station = edev->station;
693 sec->addr.net = edev->net;
694 sec->sec_family = AF_ECONET;
696 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
705 mutex_unlock(&econet_mutex);
713 * Handle generic ioctls
716 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
718 struct sock *sk = sock->sk;
719 void __user *argp = (void __user *)arg;
723 return sock_get_timestamp(sk, argp);
726 return sock_get_timestampns(sk, argp);
730 return ec_dev_ioctl(sock, cmd, argp);
740 static const struct net_proto_family econet_family_ops = {
742 .create = econet_create,
743 .owner = THIS_MODULE,
746 static const struct proto_ops econet_ops = {
748 .owner = THIS_MODULE,
749 .release = econet_release,
751 .connect = sock_no_connect,
752 .socketpair = sock_no_socketpair,
753 .accept = sock_no_accept,
754 .getname = econet_getname,
755 .poll = datagram_poll,
756 .ioctl = econet_ioctl,
757 .listen = sock_no_listen,
758 .shutdown = sock_no_shutdown,
759 .setsockopt = sock_no_setsockopt,
760 .getsockopt = sock_no_getsockopt,
761 .sendmsg = econet_sendmsg,
762 .recvmsg = econet_recvmsg,
763 .mmap = sock_no_mmap,
764 .sendpage = sock_no_sendpage,
767 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
769 * Find the listening socket, if any, for the given data.
772 static struct sock *ec_listening_socket(unsigned char port, unsigned char
773 station, unsigned char net)
776 struct hlist_node *node;
778 spin_lock(&econet_lock);
779 sk_for_each(sk, node, &econet_sklist) {
780 struct econet_sock *opt = ec_sk(sk);
781 if ((opt->port == port || opt->port == 0) &&
782 (opt->station == station || opt->station == 0) &&
783 (opt->net == net || opt->net == 0)) {
790 spin_unlock(&econet_lock);
795 * Queue a received packet for a socket.
798 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
799 unsigned char stn, unsigned char net,
800 unsigned char cb, unsigned char port)
802 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
803 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
805 memset(sec, 0, sizeof(struct sockaddr_ec));
806 sec->sec_family = AF_ECONET;
807 sec->type = ECTYPE_PACKET_RECEIVED;
811 sec->addr.station = stn;
813 return sock_queue_rcv_skb(sk, skb);
817 #ifdef CONFIG_ECONET_AUNUDP
819 * Send an AUN protocol response.
822 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
824 struct sockaddr_in sin = {
825 .sin_family = AF_INET,
826 .sin_port = htons(AUN_PORT),
827 .sin_addr = {.s_addr = addr}
829 struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
830 struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
831 struct msghdr udpmsg;
833 udpmsg.msg_name = (void *)&sin;
834 udpmsg.msg_namelen = sizeof(sin);
835 udpmsg.msg_control = NULL;
836 udpmsg.msg_controllen = 0;
839 kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
844 * Handle incoming AUN packets. Work out if anybody wants them,
845 * and send positive or negative acknowledgements as appropriate.
848 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
850 struct iphdr *ip = ip_hdr(skb);
851 unsigned char stn = ntohl(ip->saddr) & 0xff;
852 struct sock *sk = NULL;
853 struct sk_buff *newskb;
854 struct ec_device *edev = skb->dev->ec_ptr;
859 if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
860 goto bad; /* Nobody wants it */
862 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
866 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
867 /* Send nack and hope sender tries again */
871 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
872 len - sizeof(struct aunhdr));
874 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
876 /* Socket is bankrupt. */
881 aun_send_response(ip->saddr, ah->handle, 3, 0);
886 aun_send_response(ip->saddr, ah->handle, 4, 0);
892 * Handle incoming AUN transmit acknowledgements. If the sequence
893 * number matches something in our backlog then kill it and tell
894 * the user. If the remote took too long to reply then we may have
895 * dropped the packet already.
898 static void aun_tx_ack(unsigned long seq, int result)
904 spin_lock_irqsave(&aun_queue_lock, flags);
905 skb_queue_walk(&aun_queue, skb) {
906 eb = (struct ec_cb *)&skb->cb;
910 spin_unlock_irqrestore(&aun_queue_lock, flags);
911 printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
915 tx_result(skb->sk, eb->cookie, result);
916 skb_unlink(skb, &aun_queue);
917 spin_unlock_irqrestore(&aun_queue_lock, flags);
922 * Deal with received AUN frames - sort out what type of thing it is
923 * and hand it to the right function.
926 static void aun_data_available(struct sock *sk, int slen)
935 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
936 if (err == -EAGAIN) {
937 printk(KERN_ERR "AUN: no data available?!");
940 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
943 data = skb_transport_header(skb) + sizeof(struct udphdr);
944 ah = (struct aunhdr *)data;
945 len = skb->len - sizeof(struct udphdr);
951 aun_incoming(skb, ah, len);
954 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
957 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
960 /* This isn't quite right yet. */
962 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
966 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
969 skb_free_datagram(sk, skb);
973 * Called by the timer to manage the AUN transmit queue. If a packet
974 * was sent to a dead or nonexistent host then we will never get an
975 * acknowledgement back. After a few seconds we need to spot this and
979 static void ab_cleanup(unsigned long h)
981 struct sk_buff *skb, *n;
984 spin_lock_irqsave(&aun_queue_lock, flags);
985 skb_queue_walk_safe(&aun_queue, skb, n) {
986 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
987 if ((jiffies - eb->start) > eb->timeout) {
988 tx_result(skb->sk, eb->cookie,
989 ECTYPE_TRANSMIT_NOT_PRESENT);
990 skb_unlink(skb, &aun_queue);
994 spin_unlock_irqrestore(&aun_queue_lock, flags);
996 mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
999 static int __init aun_udp_initialise(void)
1002 struct sockaddr_in sin;
1004 skb_queue_head_init(&aun_queue);
1005 setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
1006 ab_cleanup_timer.expires = jiffies + (HZ*2);
1007 add_timer(&ab_cleanup_timer);
1009 memset(&sin, 0, sizeof(sin));
1010 sin.sin_port = htons(AUN_PORT);
1012 /* We can count ourselves lucky Acorn machines are too dim to
1014 if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1016 printk("AUN: socket error %d\n", -error);
1020 udpsock->sk->sk_reuse = 1;
1021 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1024 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1028 printk("AUN: bind error %d\n", -error);
1032 udpsock->sk->sk_data_ready = aun_data_available;
1037 sock_release(udpsock);
1043 #ifdef CONFIG_ECONET_NATIVE
1046 * Receive an Econet frame from a device.
1049 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1051 struct ec_framehdr *hdr;
1052 struct sock *sk = NULL;
1053 struct ec_device *edev = dev->ec_ptr;
1055 if (!net_eq(dev_net(dev), &init_net))
1058 if (skb->pkt_type == PACKET_OTHERHOST)
1064 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1067 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1070 hdr = (struct ec_framehdr *) skb->data;
1072 /* First check for encapsulated IP */
1073 if (hdr->port == EC_PORT_IP) {
1074 skb->protocol = htons(ETH_P_IP);
1075 skb_pull(skb, sizeof(struct ec_framehdr));
1077 return NET_RX_SUCCESS;
1080 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1084 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1088 return NET_RX_SUCCESS;
1097 static struct packet_type econet_packet_type __read_mostly = {
1098 .type = cpu_to_be16(ETH_P_ECONET),
1102 static void econet_hw_initialise(void)
1104 dev_add_pack(&econet_packet_type);
1109 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1111 struct net_device *dev = (struct net_device *)data;
1112 struct ec_device *edev;
1114 if (!net_eq(dev_net(dev), &init_net))
1118 case NETDEV_UNREGISTER:
1119 /* A device has gone down - kill any data we hold for it. */
1123 if (net2dev_map[0] == dev)
1124 net2dev_map[0] = NULL;
1125 net2dev_map[edev->net] = NULL;
1135 static struct notifier_block econet_netdev_notifier = {
1136 .notifier_call =econet_notifier,
1139 static void __exit econet_proto_exit(void)
1141 #ifdef CONFIG_ECONET_AUNUDP
1142 del_timer(&ab_cleanup_timer);
1144 sock_release(udpsock);
1146 unregister_netdevice_notifier(&econet_netdev_notifier);
1147 #ifdef CONFIG_ECONET_NATIVE
1148 dev_remove_pack(&econet_packet_type);
1150 sock_unregister(econet_family_ops.family);
1151 proto_unregister(&econet_proto);
1154 static int __init econet_proto_init(void)
1156 int err = proto_register(&econet_proto, 0);
1160 sock_register(&econet_family_ops);
1161 #ifdef CONFIG_ECONET_AUNUDP
1162 aun_udp_initialise();
1164 #ifdef CONFIG_ECONET_NATIVE
1165 econet_hw_initialise();
1167 register_netdevice_notifier(&econet_netdev_notifier);
1172 module_init(econet_proto_init);
1173 module_exit(econet_proto_exit);
1175 MODULE_LICENSE("GPL");
1176 MODULE_ALIAS_NETPROTO(PF_ECONET);