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/sched.h>
17 #include <linux/string.h>
19 #include <linux/socket.h>
20 #include <linux/sockios.h>
22 #include <linux/errno.h>
23 #include <linux/interrupt.h>
24 #include <linux/if_ether.h>
25 #include <linux/netdevice.h>
26 #include <linux/inetdevice.h>
27 #include <linux/route.h>
28 #include <linux/inet.h>
29 #include <linux/etherdevice.h>
30 #include <linux/if_arp.h>
31 #include <linux/wireless.h>
32 #include <linux/skbuff.h>
33 #include <linux/udp.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_RWLOCK(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 write_lock_bh(&econet_lock);
102 sk_del_node_init(sk);
103 write_unlock_bh(&econet_lock);
106 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
108 write_lock_bh(&econet_lock);
109 sk_add_node(sk, list);
110 write_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 skb_get_timestamp(skb, &sk->sk_stamp);
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);
301 struct econet_sock *eo = ec_sk(sk);
303 addr.station = eo->station;
308 if (msg->msg_namelen < sizeof(struct sockaddr_ec)) {
309 mutex_unlock(&econet_mutex);
312 addr.station = saddr->addr.station;
313 addr.net = saddr->addr.net;
318 /* Look for a device with the right network number. */
319 dev = net2dev_map[addr.net];
321 /* If not directly reachable, use some default */
323 dev = net2dev_map[0];
324 /* No interfaces at all? */
326 mutex_unlock(&econet_mutex);
331 if (len + 15 > dev->mtu) {
332 mutex_unlock(&econet_mutex);
336 if (dev->type == ARPHRD_ECONET) {
337 /* Real hardware Econet. We're not worthy etc. */
338 #ifdef CONFIG_ECONET_NATIVE
339 unsigned short proto = 0;
343 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_SPACE(dev),
344 msg->msg_flags & MSG_DONTWAIT, &err);
348 skb_reserve(skb, LL_RESERVED_SPACE(dev));
349 skb->nh.raw = skb->data;
351 eb = (struct ec_cb *)&skb->cb;
353 /* BUG: saddr may be NULL */
354 eb->cookie = saddr->cookie;
356 eb->sent = ec_tx_done;
358 if (dev->hard_header) {
360 struct ec_framehdr *fh;
362 res = dev->hard_header(skb, dev, ntohs(proto),
364 /* Poke in our control byte and
365 port number. Hack, hack. */
366 fh = (struct ec_framehdr *)(skb->data);
369 if (sock->type != SOCK_DGRAM) {
370 skb->tail = skb->data;
376 /* Copy the data. Returns -EFAULT on error */
377 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
378 skb->protocol = proto;
380 skb->priority = sk->sk_priority;
385 if (!(dev->flags & IFF_UP))
394 mutex_unlock(&econet_mutex);
405 mutex_unlock(&econet_mutex);
410 #ifdef CONFIG_ECONET_AUNUDP
411 /* AUN virtual Econet. */
413 if (udpsock == NULL) {
414 mutex_unlock(&econet_mutex);
415 return -ENETDOWN; /* No socket - can't send */
418 /* Make up a UDP datagram and hand it off to some higher intellect. */
420 memset(&udpdest, 0, sizeof(udpdest));
421 udpdest.sin_family = AF_INET;
422 udpdest.sin_port = htons(AUN_PORT);
424 /* At the moment we use the stupid Acorn scheme of Econet address
425 y.x maps to IP a.b.c.x. This should be replaced with something
426 more flexible and more aware of subnet masks. */
428 struct in_device *idev;
429 unsigned long network = 0;
432 idev = __in_dev_get_rcu(dev);
435 network = ntohl(idev->ifa_list->ifa_address) &
436 0xffffff00; /* !!! */
439 udpdest.sin_addr.s_addr = htonl(network | addr.station);
444 ah.code = 2; /* magic */
447 /* tack our header on the front of the iovec */
448 size = sizeof(struct aunhdr);
450 * XXX: that is b0rken. We can't mix userland and kernel pointers
451 * in iovec, since on a lot of platforms copy_from_user() will
452 * *not* work with the kernel and userland ones at the same time,
453 * regardless of what we do with set_fs(). And we are talking about
454 * econet-over-ethernet here, so "it's only ARM anyway" doesn't
455 * apply. Any suggestions on fixing that code? -- AV
457 iov[0].iov_base = (void *)&ah;
458 iov[0].iov_len = size;
459 for (i = 0; i < msg->msg_iovlen; i++) {
460 void __user *base = msg->msg_iov[i].iov_base;
461 size_t len = msg->msg_iov[i].iov_len;
462 /* Check it now since we switch to KERNEL_DS later. */
463 if (!access_ok(VERIFY_READ, base, len)) {
464 mutex_unlock(&econet_mutex);
467 iov[i+1].iov_base = base;
468 iov[i+1].iov_len = len;
472 /* Get a skbuff (no data, just holds our cb information) */
473 if ((skb = sock_alloc_send_skb(sk, 0,
474 msg->msg_flags & MSG_DONTWAIT,
476 mutex_unlock(&econet_mutex);
480 eb = (struct ec_cb *)&skb->cb;
482 eb->cookie = saddr->cookie;
483 eb->timeout = (5*HZ);
486 eb->seq = (aun_seq++);
489 skb_queue_tail(&aun_queue, skb);
491 udpmsg.msg_name = (void *)&udpdest;
492 udpmsg.msg_namelen = sizeof(udpdest);
493 udpmsg.msg_iov = &iov[0];
494 udpmsg.msg_iovlen = msg->msg_iovlen + 1;
495 udpmsg.msg_control = NULL;
496 udpmsg.msg_controllen = 0;
499 oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
500 err = sock_sendmsg(udpsock, &udpmsg, size);
505 mutex_unlock(&econet_mutex);
511 * Look up the address of a socket.
514 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
515 int *uaddr_len, int peer)
518 struct econet_sock *eo;
519 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
524 mutex_lock(&econet_mutex);
529 sec->sec_family = AF_ECONET;
530 sec->port = eo->port;
531 sec->addr.station = eo->station;
532 sec->addr.net = eo->net;
534 mutex_unlock(&econet_mutex);
536 *uaddr_len = sizeof(*sec);
540 static void econet_destroy_timer(unsigned long data)
542 struct sock *sk=(struct sock *)data;
544 if (!atomic_read(&sk->sk_wmem_alloc) &&
545 !atomic_read(&sk->sk_rmem_alloc)) {
550 sk->sk_timer.expires = jiffies + 10 * HZ;
551 add_timer(&sk->sk_timer);
552 printk(KERN_DEBUG "econet socket destroy delayed\n");
556 * Close an econet socket.
559 static int econet_release(struct socket *sock)
563 mutex_lock(&econet_mutex);
569 econet_remove_socket(&econet_sklist, sk);
572 * Now the socket is dead. No more input will appear.
575 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
578 sk->sk_socket = NULL;
579 sock_set_flag(sk, SOCK_DEAD);
583 skb_queue_purge(&sk->sk_receive_queue);
585 if (atomic_read(&sk->sk_rmem_alloc) ||
586 atomic_read(&sk->sk_wmem_alloc)) {
587 sk->sk_timer.data = (unsigned long)sk;
588 sk->sk_timer.expires = jiffies + HZ;
589 sk->sk_timer.function = econet_destroy_timer;
590 add_timer(&sk->sk_timer);
598 mutex_unlock(&econet_mutex);
602 static struct proto econet_proto = {
604 .owner = THIS_MODULE,
605 .obj_size = sizeof(struct econet_sock),
609 * Create an Econet socket
612 static int econet_create(struct socket *sock, int protocol)
615 struct econet_sock *eo;
618 /* Econet only provides datagram services. */
619 if (sock->type != SOCK_DGRAM)
620 return -ESOCKTNOSUPPORT;
622 sock->state = SS_UNCONNECTED;
625 sk = sk_alloc(PF_ECONET, GFP_KERNEL, &econet_proto, 1);
630 sock->ops = &econet_ops;
631 sock_init_data(sock, sk);
634 sock_reset_flag(sk, SOCK_ZAPPED);
635 sk->sk_family = PF_ECONET;
638 econet_insert_socket(&econet_sklist, sk);
645 * Handle Econet specific ioctls
648 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
651 struct ec_device *edev;
652 struct net_device *dev;
653 struct sockaddr_ec *sec;
657 * Fetch the caller's info block into kernel space
660 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
663 if ((dev = dev_get_by_name(ifr.ifr_name)) == NULL)
666 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
668 mutex_lock(&econet_mutex);
675 /* Magic up a new one. */
676 edev = kmalloc(sizeof(struct ec_device), GFP_KERNEL);
681 memset(edev, 0, sizeof(struct ec_device));
684 net2dev_map[edev->net] = NULL;
685 edev->station = sec->addr.station;
686 edev->net = sec->addr.net;
687 net2dev_map[sec->addr.net] = dev;
689 net2dev_map[0] = dev;
698 memset(sec, 0, sizeof(struct sockaddr_ec));
699 sec->addr.station = edev->station;
700 sec->addr.net = edev->net;
701 sec->sec_family = AF_ECONET;
703 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
712 mutex_unlock(&econet_mutex);
720 * Handle generic ioctls
723 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
725 struct sock *sk = sock->sk;
726 void __user *argp = (void __user *)arg;
730 return sock_get_timestamp(sk, argp);
734 return ec_dev_ioctl(sock, cmd, argp);
744 static struct net_proto_family econet_family_ops = {
746 .create = econet_create,
747 .owner = THIS_MODULE,
750 static const struct proto_ops econet_ops = {
752 .owner = THIS_MODULE,
753 .release = econet_release,
755 .connect = sock_no_connect,
756 .socketpair = sock_no_socketpair,
757 .accept = sock_no_accept,
758 .getname = econet_getname,
759 .poll = datagram_poll,
760 .ioctl = econet_ioctl,
761 .listen = sock_no_listen,
762 .shutdown = sock_no_shutdown,
763 .setsockopt = sock_no_setsockopt,
764 .getsockopt = sock_no_getsockopt,
765 .sendmsg = econet_sendmsg,
766 .recvmsg = econet_recvmsg,
767 .mmap = sock_no_mmap,
768 .sendpage = sock_no_sendpage,
771 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
773 * Find the listening socket, if any, for the given data.
776 static struct sock *ec_listening_socket(unsigned char port, unsigned char
777 station, unsigned char net)
780 struct hlist_node *node;
782 sk_for_each(sk, node, &econet_sklist) {
783 struct econet_sock *opt = ec_sk(sk);
784 if ((opt->port == port || opt->port == 0) &&
785 (opt->station == station || opt->station == 0) &&
786 (opt->net == net || opt->net == 0))
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 = skb->nh.iph;
851 unsigned char stn = ntohl(ip->saddr) & 0xff;
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);
885 aun_send_response(ip->saddr, ah->handle, 4, 0);
889 * Handle incoming AUN transmit acknowledgements. If the sequence
890 * number matches something in our backlog then kill it and tell
891 * the user. If the remote took too long to reply then we may have
892 * dropped the packet already.
895 static void aun_tx_ack(unsigned long seq, int result)
901 spin_lock_irqsave(&aun_queue_lock, flags);
902 skb = skb_peek(&aun_queue);
903 while (skb && skb != (struct sk_buff *)&aun_queue)
905 struct sk_buff *newskb = skb->next;
906 eb = (struct ec_cb *)&skb->cb;
912 spin_unlock_irqrestore(&aun_queue_lock, flags);
913 printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
917 tx_result(skb->sk, eb->cookie, result);
918 skb_unlink(skb, &aun_queue);
919 spin_unlock_irqrestore(&aun_queue_lock, flags);
924 * Deal with received AUN frames - sort out what type of thing it is
925 * and hand it to the right function.
928 static void aun_data_available(struct sock *sk, int slen)
937 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
938 if (err == -EAGAIN) {
939 printk(KERN_ERR "AUN: no data available?!");
942 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
945 data = skb->h.raw + sizeof(struct udphdr);
946 ah = (struct aunhdr *)data;
947 len = skb->len - sizeof(struct udphdr);
953 aun_incoming(skb, ah, len);
956 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
959 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
962 /* This isn't quite right yet. */
964 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
968 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
971 skb_free_datagram(sk, skb);
975 * Called by the timer to manage the AUN transmit queue. If a packet
976 * was sent to a dead or nonexistent host then we will never get an
977 * acknowledgement back. After a few seconds we need to spot this and
981 static void ab_cleanup(unsigned long h)
986 spin_lock_irqsave(&aun_queue_lock, flags);
987 skb = skb_peek(&aun_queue);
988 while (skb && skb != (struct sk_buff *)&aun_queue)
990 struct sk_buff *newskb = skb->next;
991 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
992 if ((jiffies - eb->start) > eb->timeout)
994 tx_result(skb->sk, eb->cookie,
995 ECTYPE_TRANSMIT_NOT_PRESENT);
996 skb_unlink(skb, &aun_queue);
1001 spin_unlock_irqrestore(&aun_queue_lock, flags);
1003 mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
1006 static int __init aun_udp_initialise(void)
1009 struct sockaddr_in sin;
1011 skb_queue_head_init(&aun_queue);
1012 spin_lock_init(&aun_queue_lock);
1013 init_timer(&ab_cleanup_timer);
1014 ab_cleanup_timer.expires = jiffies + (HZ*2);
1015 ab_cleanup_timer.function = ab_cleanup;
1016 add_timer(&ab_cleanup_timer);
1018 memset(&sin, 0, sizeof(sin));
1019 sin.sin_port = htons(AUN_PORT);
1021 /* We can count ourselves lucky Acorn machines are too dim to
1023 if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1025 printk("AUN: socket error %d\n", -error);
1029 udpsock->sk->sk_reuse = 1;
1030 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1033 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1037 printk("AUN: bind error %d\n", -error);
1041 udpsock->sk->sk_data_ready = aun_data_available;
1046 sock_release(udpsock);
1052 #ifdef CONFIG_ECONET_NATIVE
1055 * Receive an Econet frame from a device.
1058 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1060 struct ec_framehdr *hdr;
1062 struct ec_device *edev = dev->ec_ptr;
1064 if (skb->pkt_type == PACKET_OTHERHOST)
1070 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1073 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1076 hdr = (struct ec_framehdr *) skb->data;
1078 /* First check for encapsulated IP */
1079 if (hdr->port == EC_PORT_IP) {
1080 skb->protocol = htons(ETH_P_IP);
1081 skb_pull(skb, sizeof(struct ec_framehdr));
1086 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1090 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1101 static struct packet_type econet_packet_type = {
1102 .type = __constant_htons(ETH_P_ECONET),
1106 static void econet_hw_initialise(void)
1108 dev_add_pack(&econet_packet_type);
1113 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1115 struct net_device *dev = (struct net_device *)data;
1116 struct ec_device *edev;
1119 case NETDEV_UNREGISTER:
1120 /* A device has gone down - kill any data we hold for it. */
1124 if (net2dev_map[0] == dev)
1125 net2dev_map[0] = NULL;
1126 net2dev_map[edev->net] = NULL;
1136 static struct notifier_block econet_netdev_notifier = {
1137 .notifier_call =econet_notifier,
1140 static void __exit econet_proto_exit(void)
1142 #ifdef CONFIG_ECONET_AUNUDP
1143 del_timer(&ab_cleanup_timer);
1145 sock_release(udpsock);
1147 unregister_netdevice_notifier(&econet_netdev_notifier);
1148 sock_unregister(econet_family_ops.family);
1149 proto_unregister(&econet_proto);
1152 static int __init econet_proto_init(void)
1154 int err = proto_register(&econet_proto, 0);
1158 sock_register(&econet_family_ops);
1159 #ifdef CONFIG_ECONET_AUNUDP
1160 spin_lock_init(&aun_queue_lock);
1161 aun_udp_initialise();
1163 #ifdef CONFIG_ECONET_NATIVE
1164 econet_hw_initialise();
1166 register_netdevice_notifier(&econet_netdev_notifier);
1171 module_init(econet_proto_init);
1172 module_exit(econet_proto_exit);
1174 MODULE_LICENSE("GPL");
1175 MODULE_ALIAS_NETPROTO(PF_ECONET);