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/config.h>
13 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/kernel.h>
17 #include <linux/sched.h>
18 #include <linux/string.h>
20 #include <linux/socket.h>
21 #include <linux/sockios.h>
23 #include <linux/errno.h>
24 #include <linux/interrupt.h>
25 #include <linux/if_ether.h>
26 #include <linux/netdevice.h>
27 #include <linux/inetdevice.h>
28 #include <linux/route.h>
29 #include <linux/inet.h>
30 #include <linux/etherdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/wireless.h>
33 #include <linux/skbuff.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>
45 #include <asm/uaccess.h>
46 #include <asm/system.h>
48 static struct proto_ops econet_ops;
49 static struct hlist_head econet_sklist;
50 static DEFINE_RWLOCK(econet_lock);
52 /* Since there are only 256 possible network numbers (or fewer, depends
53 how you count) it makes sense to use a simple lookup table. */
54 static struct net_device *net2dev_map[256];
56 #define EC_PORT_IP 0xd2
58 #ifdef CONFIG_ECONET_AUNUDP
59 static spinlock_t aun_queue_lock;
60 static struct socket *udpsock;
61 #define AUN_PORT 0x8000
66 unsigned char code; /* AUN magic protocol byte */
73 static unsigned long aun_seq;
75 /* Queue of packets waiting to be transmitted. */
76 static struct sk_buff_head aun_queue;
77 static struct timer_list ab_cleanup_timer;
79 #endif /* CONFIG_ECONET_AUNUDP */
81 /* Per-packet information */
84 struct sockaddr_ec sec;
85 unsigned long cookie; /* Supplied by user. */
86 #ifdef CONFIG_ECONET_AUNUDP
88 unsigned long seq; /* Sequencing */
89 unsigned long timeout; /* Timeout */
90 unsigned long start; /* jiffies */
92 #ifdef CONFIG_ECONET_NATIVE
93 void (*sent)(struct sk_buff *, int result);
97 static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
99 write_lock_bh(&econet_lock);
100 sk_del_node_init(sk);
101 write_unlock_bh(&econet_lock);
104 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
106 write_lock_bh(&econet_lock);
107 sk_add_node(sk, list);
108 write_unlock_bh(&econet_lock);
112 * Pull a packet from our receive queue and hand it to the user.
113 * If necessary we block.
116 static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
117 struct msghdr *msg, size_t len, int flags)
119 struct sock *sk = sock->sk;
124 msg->msg_namelen = sizeof(struct sockaddr_ec);
127 * Call the generic datagram receiver. This handles all sorts
128 * of horrible races and re-entrancy so we can forget about it
129 * in the protocol layers.
131 * Now it will return ENETDOWN, if device have just gone down,
132 * but then it will block.
135 skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
138 * An error occurred so return it. Because skb_recv_datagram()
139 * handles the blocking we don't see and worry about blocking
147 * You lose any data beyond the buffer you gave. If it worries a
148 * user program they can ask the device for its MTU anyway.
155 msg->msg_flags|=MSG_TRUNC;
158 /* We can't use skb_copy_datagram here */
159 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
162 sk->sk_stamp = skb->stamp;
165 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
168 * Free or return the buffer as appropriate. Again this
169 * hides all the races and re-entrancy issues from us.
174 skb_free_datagram(sk, skb);
180 * Bind an Econet socket.
183 static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
185 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
186 struct sock *sk=sock->sk;
187 struct econet_opt *eo = ec_sk(sk);
193 if (addr_len < sizeof(struct sockaddr_ec) ||
194 sec->sec_family != AF_ECONET)
198 eo->port = sec->port;
199 eo->station = sec->addr.station;
200 eo->net = sec->addr.net;
205 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
207 * Queue a transmit result for the user to be told about.
210 static void tx_result(struct sock *sk, unsigned long cookie, int result)
212 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
214 struct sockaddr_ec *sec;
218 printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
222 eb = (struct ec_cb *)&skb->cb;
223 sec = (struct sockaddr_ec *)&eb->sec;
224 memset(sec, 0, sizeof(struct sockaddr_ec));
225 sec->cookie = cookie;
226 sec->type = ECTYPE_TRANSMIT_STATUS | result;
227 sec->sec_family = AF_ECONET;
229 if (sock_queue_rcv_skb(sk, skb) < 0)
234 #ifdef CONFIG_ECONET_NATIVE
236 * Called by the Econet hardware driver when a packet transmit
237 * has completed. Tell the user.
240 static void ec_tx_done(struct sk_buff *skb, int result)
242 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
243 tx_result(skb->sk, eb->cookie, result);
248 * Send a packet. We have to work out which device it's going out on
249 * and hence whether to use real Econet or the UDP emulation.
252 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
253 struct msghdr *msg, size_t len)
255 struct sock *sk = sock->sk;
256 struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
257 struct net_device *dev;
260 unsigned char port, cb;
261 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
265 #ifdef CONFIG_ECONET_AUNUDP
266 struct msghdr udpmsg;
267 struct iovec iov[msg->msg_iovlen+1];
269 struct sockaddr_in udpdest;
270 __kernel_size_t size;
279 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
283 * Get and verify the address.
287 struct econet_opt *eo = ec_sk(sk);
289 addr.station = eo->station;
294 if (msg->msg_namelen < sizeof(struct sockaddr_ec))
296 addr.station = saddr->addr.station;
297 addr.net = saddr->addr.net;
302 /* Look for a device with the right network number. */
303 dev = net2dev_map[addr.net];
305 /* If not directly reachable, use some default */
308 dev = net2dev_map[0];
309 /* No interfaces at all? */
314 if (len + 15 > dev->mtu)
317 if (dev->type == ARPHRD_ECONET)
319 /* Real hardware Econet. We're not worthy etc. */
320 #ifdef CONFIG_ECONET_NATIVE
321 unsigned short proto = 0;
325 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_SPACE(dev),
326 msg->msg_flags & MSG_DONTWAIT, &err);
330 skb_reserve(skb, LL_RESERVED_SPACE(dev));
331 skb->nh.raw = skb->data;
333 eb = (struct ec_cb *)&skb->cb;
335 /* BUG: saddr may be NULL */
336 eb->cookie = saddr->cookie;
338 eb->sent = ec_tx_done;
340 if (dev->hard_header) {
342 struct ec_framehdr *fh;
344 res = dev->hard_header(skb, dev, ntohs(proto),
346 /* Poke in our control byte and
347 port number. Hack, hack. */
348 fh = (struct ec_framehdr *)(skb->data);
351 if (sock->type != SOCK_DGRAM) {
352 skb->tail = skb->data;
358 /* Copy the data. Returns -EFAULT on error */
359 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
360 skb->protocol = proto;
362 skb->priority = sk->sk_priority;
367 if (!(dev->flags & IFF_UP))
389 #ifdef CONFIG_ECONET_AUNUDP
390 /* AUN virtual Econet. */
393 return -ENETDOWN; /* No socket - can't send */
395 /* Make up a UDP datagram and hand it off to some higher intellect. */
397 memset(&udpdest, 0, sizeof(udpdest));
398 udpdest.sin_family = AF_INET;
399 udpdest.sin_port = htons(AUN_PORT);
401 /* At the moment we use the stupid Acorn scheme of Econet address
402 y.x maps to IP a.b.c.x. This should be replaced with something
403 more flexible and more aware of subnet masks. */
405 struct in_device *idev;
406 unsigned long network = 0;
409 idev = __in_dev_get(dev);
412 network = ntohl(idev->ifa_list->ifa_address) &
413 0xffffff00; /* !!! */
416 udpdest.sin_addr.s_addr = htonl(network | addr.station);
421 ah.code = 2; /* magic */
424 /* tack our header on the front of the iovec */
425 size = sizeof(struct aunhdr);
427 * XXX: that is b0rken. We can't mix userland and kernel pointers
428 * in iovec, since on a lot of platforms copy_from_user() will
429 * *not* work with the kernel and userland ones at the same time,
430 * regardless of what we do with set_fs(). And we are talking about
431 * econet-over-ethernet here, so "it's only ARM anyway" doesn't
432 * apply. Any suggestions on fixing that code? -- AV
434 iov[0].iov_base = (void *)&ah;
435 iov[0].iov_len = size;
436 for (i = 0; i < msg->msg_iovlen; i++) {
437 void __user *base = msg->msg_iov[i].iov_base;
438 size_t len = msg->msg_iov[i].iov_len;
439 /* Check it now since we switch to KERNEL_DS later. */
440 if ((err = verify_area(VERIFY_READ, base, len)) < 0)
442 iov[i+1].iov_base = base;
443 iov[i+1].iov_len = len;
447 /* Get a skbuff (no data, just holds our cb information) */
448 if ((skb = sock_alloc_send_skb(sk, 0,
449 msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
452 eb = (struct ec_cb *)&skb->cb;
454 eb->cookie = saddr->cookie;
455 eb->timeout = (5*HZ);
458 eb->seq = (aun_seq++);
461 skb_queue_tail(&aun_queue, skb);
463 udpmsg.msg_name = (void *)&udpdest;
464 udpmsg.msg_namelen = sizeof(udpdest);
465 udpmsg.msg_iov = &iov[0];
466 udpmsg.msg_iovlen = msg->msg_iovlen + 1;
467 udpmsg.msg_control = NULL;
468 udpmsg.msg_controllen = 0;
471 oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
472 err = sock_sendmsg(udpsock, &udpmsg, size);
481 * Look up the address of a socket.
484 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
485 int *uaddr_len, int peer)
487 struct sock *sk = sock->sk;
488 struct econet_opt *eo = ec_sk(sk);
489 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
494 sec->sec_family = AF_ECONET;
495 sec->port = eo->port;
496 sec->addr.station = eo->station;
497 sec->addr.net = eo->net;
499 *uaddr_len = sizeof(*sec);
503 static void econet_destroy_timer(unsigned long data)
505 struct sock *sk=(struct sock *)data;
507 if (!atomic_read(&sk->sk_wmem_alloc) &&
508 !atomic_read(&sk->sk_rmem_alloc)) {
513 sk->sk_timer.expires = jiffies + 10 * HZ;
514 add_timer(&sk->sk_timer);
515 printk(KERN_DEBUG "econet socket destroy delayed\n");
519 * Close an econet socket.
522 static int econet_release(struct socket *sock)
524 struct sock *sk = sock->sk;
529 econet_remove_socket(&econet_sklist, sk);
532 * Now the socket is dead. No more input will appear.
535 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
538 sk->sk_socket = NULL;
539 sock_set_flag(sk, SOCK_DEAD);
543 skb_queue_purge(&sk->sk_receive_queue);
545 if (atomic_read(&sk->sk_rmem_alloc) ||
546 atomic_read(&sk->sk_wmem_alloc)) {
547 sk->sk_timer.data = (unsigned long)sk;
548 sk->sk_timer.expires = jiffies + HZ;
549 sk->sk_timer.function = econet_destroy_timer;
550 add_timer(&sk->sk_timer);
559 * Create an Econet socket
562 static int econet_create(struct socket *sock, int protocol)
565 struct econet_opt *eo;
568 /* Econet only provides datagram services. */
569 if (sock->type != SOCK_DGRAM)
570 return -ESOCKTNOSUPPORT;
572 sock->state = SS_UNCONNECTED;
575 sk = sk_alloc(PF_ECONET, GFP_KERNEL, 1, NULL);
580 sock->ops = &econet_ops;
581 sock_init_data(sock,sk);
582 sk_set_owner(sk, THIS_MODULE);
584 eo = sk->sk_protinfo = kmalloc(sizeof(*eo), GFP_KERNEL);
587 memset(eo, 0, sizeof(*eo));
589 sk->sk_family = PF_ECONET;
592 econet_insert_socket(&econet_sklist, sk);
602 * Handle Econet specific ioctls
605 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
608 struct ec_device *edev;
609 struct net_device *dev;
610 struct sockaddr_ec *sec;
613 * Fetch the caller's info block into kernel space
616 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
619 if ((dev = dev_get_by_name(ifr.ifr_name)) == NULL)
622 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
630 /* Magic up a new one. */
631 edev = kmalloc(sizeof(struct ec_device), GFP_KERNEL);
633 printk("af_ec: memory squeeze.\n");
637 memset(edev, 0, sizeof(struct ec_device));
641 net2dev_map[edev->net] = NULL;
642 edev->station = sec->addr.station;
643 edev->net = sec->addr.net;
644 net2dev_map[sec->addr.net] = dev;
646 net2dev_map[0] = dev;
657 memset(sec, 0, sizeof(struct sockaddr_ec));
658 sec->addr.station = edev->station;
659 sec->addr.net = edev->net;
660 sec->sec_family = AF_ECONET;
662 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
672 * Handle generic ioctls
675 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
677 struct sock *sk = sock->sk;
678 void __user *argp = (void __user *)arg;
682 return sock_get_timestamp(sk, argp);
686 return ec_dev_ioctl(sock, cmd, argp);
690 return dev_ioctl(cmd, argp);
696 static struct net_proto_family econet_family_ops = {
698 .create = econet_create,
699 .owner = THIS_MODULE,
702 static struct proto_ops SOCKOPS_WRAPPED(econet_ops) = {
704 .owner = THIS_MODULE,
705 .release = econet_release,
707 .connect = sock_no_connect,
708 .socketpair = sock_no_socketpair,
709 .accept = sock_no_accept,
710 .getname = econet_getname,
711 .poll = datagram_poll,
712 .ioctl = econet_ioctl,
713 .listen = sock_no_listen,
714 .shutdown = sock_no_shutdown,
715 .setsockopt = sock_no_setsockopt,
716 .getsockopt = sock_no_getsockopt,
717 .sendmsg = econet_sendmsg,
718 .recvmsg = econet_recvmsg,
719 .mmap = sock_no_mmap,
720 .sendpage = sock_no_sendpage,
723 #include <linux/smp_lock.h>
724 SOCKOPS_WRAP(econet, PF_ECONET);
726 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
728 * Find the listening socket, if any, for the given data.
731 static struct sock *ec_listening_socket(unsigned char port, unsigned char
732 station, unsigned char net)
735 struct hlist_node *node;
737 sk_for_each(sk, node, &econet_sklist) {
738 struct econet_opt *opt = ec_sk(sk);
739 if ((opt->port == port || opt->port == 0) &&
740 (opt->station == station || opt->station == 0) &&
741 (opt->net == net || opt->net == 0))
750 * Queue a received packet for a socket.
753 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
754 unsigned char stn, unsigned char net,
755 unsigned char cb, unsigned char port)
757 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
758 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
760 memset(sec, 0, sizeof(struct sockaddr_ec));
761 sec->sec_family = AF_ECONET;
762 sec->type = ECTYPE_PACKET_RECEIVED;
766 sec->addr.station = stn;
768 return sock_queue_rcv_skb(sk, skb);
772 #ifdef CONFIG_ECONET_AUNUDP
774 * Send an AUN protocol response.
777 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
779 struct sockaddr_in sin = {
780 .sin_family = AF_INET,
781 .sin_port = htons(AUN_PORT),
782 .sin_addr = {.s_addr = addr}
784 struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
785 struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
786 struct msghdr udpmsg;
788 udpmsg.msg_name = (void *)&sin;
789 udpmsg.msg_namelen = sizeof(sin);
790 udpmsg.msg_control = NULL;
791 udpmsg.msg_controllen = 0;
794 kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
799 * Handle incoming AUN packets. Work out if anybody wants them,
800 * and send positive or negative acknowledgements as appropriate.
803 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
805 struct iphdr *ip = skb->nh.iph;
806 unsigned char stn = ntohl(ip->saddr) & 0xff;
808 struct sk_buff *newskb;
809 struct ec_device *edev = skb->dev->ec_ptr;
814 if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
815 goto bad; /* Nobody wants it */
817 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
821 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
822 /* Send nack and hope sender tries again */
826 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
827 len - sizeof(struct aunhdr));
829 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
831 /* Socket is bankrupt. */
836 aun_send_response(ip->saddr, ah->handle, 3, 0);
840 aun_send_response(ip->saddr, ah->handle, 4, 0);
844 * Handle incoming AUN transmit acknowledgements. If the sequence
845 * number matches something in our backlog then kill it and tell
846 * the user. If the remote took too long to reply then we may have
847 * dropped the packet already.
850 static void aun_tx_ack(unsigned long seq, int result)
856 spin_lock_irqsave(&aun_queue_lock, flags);
857 skb = skb_peek(&aun_queue);
858 while (skb && skb != (struct sk_buff *)&aun_queue)
860 struct sk_buff *newskb = skb->next;
861 eb = (struct ec_cb *)&skb->cb;
867 spin_unlock_irqrestore(&aun_queue_lock, flags);
868 printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
872 tx_result(skb->sk, eb->cookie, result);
874 spin_unlock_irqrestore(&aun_queue_lock, flags);
879 * Deal with received AUN frames - sort out what type of thing it is
880 * and hand it to the right function.
883 static void aun_data_available(struct sock *sk, int slen)
892 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
893 if (err == -EAGAIN) {
894 printk(KERN_ERR "AUN: no data available?!");
897 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
900 data = skb->h.raw + sizeof(struct udphdr);
901 ah = (struct aunhdr *)data;
902 len = skb->len - sizeof(struct udphdr);
908 aun_incoming(skb, ah, len);
911 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
914 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
917 /* This isn't quite right yet. */
919 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
923 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
926 skb_free_datagram(sk, skb);
930 * Called by the timer to manage the AUN transmit queue. If a packet
931 * was sent to a dead or nonexistent host then we will never get an
932 * acknowledgement back. After a few seconds we need to spot this and
936 static void ab_cleanup(unsigned long h)
941 spin_lock_irqsave(&aun_queue_lock, flags);
942 skb = skb_peek(&aun_queue);
943 while (skb && skb != (struct sk_buff *)&aun_queue)
945 struct sk_buff *newskb = skb->next;
946 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
947 if ((jiffies - eb->start) > eb->timeout)
949 tx_result(skb->sk, eb->cookie,
950 ECTYPE_TRANSMIT_NOT_PRESENT);
956 spin_unlock_irqrestore(&aun_queue_lock, flags);
958 mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
961 static int __init aun_udp_initialise(void)
964 struct sockaddr_in sin;
966 skb_queue_head_init(&aun_queue);
967 spin_lock_init(&aun_queue_lock);
968 init_timer(&ab_cleanup_timer);
969 ab_cleanup_timer.expires = jiffies + (HZ*2);
970 ab_cleanup_timer.function = ab_cleanup;
971 add_timer(&ab_cleanup_timer);
973 memset(&sin, 0, sizeof(sin));
974 sin.sin_port = htons(AUN_PORT);
976 /* We can count ourselves lucky Acorn machines are too dim to
978 if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
980 printk("AUN: socket error %d\n", -error);
984 udpsock->sk->sk_reuse = 1;
985 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
988 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
992 printk("AUN: bind error %d\n", -error);
996 udpsock->sk->sk_data_ready = aun_data_available;
1001 sock_release(udpsock);
1007 #ifdef CONFIG_ECONET_NATIVE
1010 * Receive an Econet frame from a device.
1013 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
1015 struct ec_framehdr *hdr;
1017 struct ec_device *edev = dev->ec_ptr;
1019 if (skb->pkt_type == PACKET_OTHERHOST)
1025 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1028 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1031 hdr = (struct ec_framehdr *) skb->data;
1033 /* First check for encapsulated IP */
1034 if (hdr->port == EC_PORT_IP) {
1035 skb->protocol = htons(ETH_P_IP);
1036 skb_pull(skb, sizeof(struct ec_framehdr));
1041 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1045 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1056 static struct packet_type econet_packet_type = {
1057 .type = __constant_htons(ETH_P_ECONET),
1061 static void econet_hw_initialise(void)
1063 dev_add_pack(&econet_packet_type);
1068 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1070 struct net_device *dev = (struct net_device *)data;
1071 struct ec_device *edev;
1074 case NETDEV_UNREGISTER:
1075 /* A device has gone down - kill any data we hold for it. */
1079 if (net2dev_map[0] == dev)
1080 net2dev_map[0] = NULL;
1081 net2dev_map[edev->net] = NULL;
1091 static struct notifier_block econet_netdev_notifier = {
1092 .notifier_call =econet_notifier,
1095 static void __exit econet_proto_exit(void)
1097 #ifdef CONFIG_ECONET_AUNUDP
1098 del_timer(&ab_cleanup_timer);
1100 sock_release(udpsock);
1102 unregister_netdevice_notifier(&econet_netdev_notifier);
1103 sock_unregister(econet_family_ops.family);
1106 static int __init econet_proto_init(void)
1108 sock_register(&econet_family_ops);
1109 #ifdef CONFIG_ECONET_AUNUDP
1110 spin_lock_init(&aun_queue_lock);
1111 aun_udp_initialise();
1113 #ifdef CONFIG_ECONET_NATIVE
1114 econet_hw_initialise();
1116 register_netdevice_notifier(&econet_netdev_notifier);
1120 module_init(econet_proto_init);
1121 module_exit(econet_proto_exit);
1123 MODULE_LICENSE("GPL");
1124 MODULE_ALIAS_NETPROTO(PF_ECONET);