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>
43 #include <asm/uaccess.h>
44 #include <asm/system.h>
45 #include <asm/bitops.h>
47 static struct proto_ops econet_ops;
48 static struct hlist_head econet_sklist;
49 static rwlock_t econet_lock = RW_LOCK_UNLOCKED;
51 /* Since there are only 256 possible network numbers (or fewer, depends
52 how you count) it makes sense to use a simple lookup table. */
53 static struct net_device *net2dev_map[256];
55 #define EC_PORT_IP 0xd2
57 #ifdef CONFIG_ECONET_AUNUDP
58 static spinlock_t aun_queue_lock;
59 static struct socket *udpsock;
60 #define AUN_PORT 0x8000
65 unsigned char code; /* AUN magic protocol byte */
72 static unsigned long aun_seq;
74 /* Queue of packets waiting to be transmitted. */
75 static struct sk_buff_head aun_queue;
76 static struct timer_list ab_cleanup_timer;
78 #endif /* CONFIG_ECONET_AUNUDP */
80 /* Per-packet information */
83 struct sockaddr_ec sec;
84 unsigned long cookie; /* Supplied by user. */
85 #ifdef CONFIG_ECONET_AUNUDP
87 unsigned long seq; /* Sequencing */
88 unsigned long timeout; /* Timeout */
89 unsigned long start; /* jiffies */
91 #ifdef CONFIG_ECONET_NATIVE
92 void (*sent)(struct sk_buff *, int result);
96 static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
98 write_lock_bh(&econet_lock);
100 write_unlock_bh(&econet_lock);
103 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
105 write_lock_bh(&econet_lock);
106 sk_add_node(sk, list);
107 write_unlock_bh(&econet_lock);
111 * Pull a packet from our receive queue and hand it to the user.
112 * If necessary we block.
115 static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
116 struct msghdr *msg, size_t len, int flags)
118 struct sock *sk = sock->sk;
123 msg->msg_namelen = sizeof(struct sockaddr_ec);
126 * Call the generic datagram receiver. This handles all sorts
127 * of horrible races and re-entrancy so we can forget about it
128 * in the protocol layers.
130 * Now it will return ENETDOWN, if device have just gone down,
131 * but then it will block.
134 skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
137 * An error occurred so return it. Because skb_recv_datagram()
138 * handles the blocking we don't see and worry about blocking
146 * You lose any data beyond the buffer you gave. If it worries a
147 * user program they can ask the device for its MTU anyway.
154 msg->msg_flags|=MSG_TRUNC;
157 /* We can't use skb_copy_datagram here */
158 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
161 sk->sk_stamp = skb->stamp;
164 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
167 * Free or return the buffer as appropriate. Again this
168 * hides all the races and re-entrancy issues from us.
173 skb_free_datagram(sk, skb);
179 * Bind an Econet socket.
182 static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
184 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
185 struct sock *sk=sock->sk;
186 struct econet_opt *eo = ec_sk(sk);
192 if (addr_len < sizeof(struct sockaddr_ec) ||
193 sec->sec_family != AF_ECONET)
197 eo->port = sec->port;
198 eo->station = sec->addr.station;
199 eo->net = sec->addr.net;
204 #ifdef CONFIG_ECONET_NATIVE
206 * Queue a transmit result for the user to be told about.
209 static void tx_result(struct sock *sk, unsigned long cookie, int result)
211 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
213 struct sockaddr_ec *sec;
217 printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
221 eb = (struct ec_cb *)&skb->cb;
222 sec = (struct sockaddr_ec *)&eb->sec;
223 memset(sec, 0, sizeof(struct sockaddr_ec));
224 sec->cookie = cookie;
225 sec->type = ECTYPE_TRANSMIT_STATUS | result;
226 sec->sec_family = AF_ECONET;
228 if (sock_queue_rcv_skb(sk, skb) < 0)
233 * Called by the Econet hardware driver when a packet transmit
234 * has completed. Tell the user.
237 static void ec_tx_done(struct sk_buff *skb, int result)
239 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
240 tx_result(skb->sk, eb->cookie, result);
245 * Send a packet. We have to work out which device it's going out on
246 * and hence whether to use real Econet or the UDP emulation.
249 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
250 struct msghdr *msg, size_t len)
252 struct sock *sk = sock->sk;
253 struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
254 struct net_device *dev;
257 unsigned char port, cb;
258 #ifdef CONFIG_ECONET_AUNUDP
259 struct msghdr udpmsg;
260 struct iovec iov[msg->msg_iovlen+1];
262 struct sockaddr_in udpdest;
263 __kernel_size_t size;
272 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
276 * Get and verify the address.
280 struct econet_opt *eo = ec_sk(sk);
282 addr.station = eo->station;
287 if (msg->msg_namelen < sizeof(struct sockaddr_ec))
289 addr.station = saddr->addr.station;
290 addr.net = saddr->addr.net;
295 /* Look for a device with the right network number. */
296 dev = net2dev_map[addr.net];
298 /* If not directly reachable, use some default */
301 dev = net2dev_map[0];
302 /* No interfaces at all? */
307 if (len + 15 > dev->mtu)
310 if (dev->type == ARPHRD_ECONET)
312 /* Real hardware Econet. We're not worthy etc. */
313 #ifdef CONFIG_ECONET_NATIVE
316 unsigned short proto = 0;
320 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_SPACE(dev),
321 msg->msg_flags & MSG_DONTWAIT, &err);
325 skb_reserve(skb, LL_RESERVED_SPACE(dev));
326 skb->nh.raw = skb->data;
328 eb = (struct ec_cb *)&skb->cb;
330 /* BUG: saddr may be NULL */
331 eb->cookie = saddr->cookie;
333 eb->sent = ec_tx_done;
335 if (dev->hard_header) {
337 struct ec_framehdr *fh;
339 res = dev->hard_header(skb, dev, ntohs(proto),
341 /* Poke in our control byte and
342 port number. Hack, hack. */
343 fh = (struct ec_framehdr *)(skb->data);
346 if (sock->type != SOCK_DGRAM) {
347 skb->tail = skb->data;
353 /* Copy the data. Returns -EFAULT on error */
354 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
355 skb->protocol = proto;
357 skb->priority = sk->sk_priority;
362 if (!(dev->flags & IFF_UP))
384 #ifdef CONFIG_ECONET_AUNUDP
385 /* AUN virtual Econet. */
388 return -ENETDOWN; /* No socket - can't send */
390 /* Make up a UDP datagram and hand it off to some higher intellect. */
392 memset(&udpdest, 0, sizeof(udpdest));
393 udpdest.sin_family = AF_INET;
394 udpdest.sin_port = htons(AUN_PORT);
396 /* At the moment we use the stupid Acorn scheme of Econet address
397 y.x maps to IP a.b.c.x. This should be replaced with something
398 more flexible and more aware of subnet masks. */
400 struct in_device *idev = in_dev_get(dev);
401 unsigned long network = 0;
403 read_lock(&idev->lock);
405 network = ntohl(idev->ifa_list->ifa_address) &
406 0xffffff00; /* !!! */
407 read_unlock(&idev->lock);
410 udpdest.sin_addr.s_addr = htonl(network | addr.station);
415 ah.code = 2; /* magic */
418 /* tack our header on the front of the iovec */
419 size = sizeof(struct aunhdr);
421 * XXX: that is b0rken. We can't mix userland and kernel pointers
422 * in iovec, since on a lot of platforms copy_from_user() will
423 * *not* work with the kernel and userland ones at the same time,
424 * regardless of what we do with set_fs(). And we are talking about
425 * econet-over-ethernet here, so "it's only ARM anyway" doesn't
426 * apply. Any suggestions on fixing that code? -- AV
428 iov[0].iov_base = (void *)&ah;
429 iov[0].iov_len = size;
430 for (i = 0; i < msg->msg_iovlen; i++) {
431 void __user *base = msg->msg_iov[i].iov_base;
432 size_t len = msg->msg_iov[i].iov_len;
433 /* Check it now since we switch to KERNEL_DS later. */
434 if ((err = verify_area(VERIFY_READ, base, len)) < 0)
436 iov[i+1].iov_base = base;
437 iov[i+1].iov_len = len;
441 /* Get a skbuff (no data, just holds our cb information) */
442 if ((skb = sock_alloc_send_skb(sk, 0,
443 msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
446 eb = (struct ec_cb *)&skb->cb;
448 eb->cookie = saddr->cookie;
449 eb->timeout = (5*HZ);
452 eb->seq = (aun_seq++);
455 skb_queue_tail(&aun_queue, skb);
457 udpmsg.msg_name = (void *)&udpdest;
458 udpmsg.msg_namelen = sizeof(udpdest);
459 udpmsg.msg_iov = &iov[0];
460 udpmsg.msg_iovlen = msg->msg_iovlen + 1;
461 udpmsg.msg_control = NULL;
462 udpmsg.msg_controllen = 0;
465 oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
466 err = sock_sendmsg(udpsock, &udpmsg, size);
475 * Look up the address of a socket.
478 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
479 int *uaddr_len, int peer)
481 struct sock *sk = sock->sk;
482 struct econet_opt *eo = ec_sk(sk);
483 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
488 sec->sec_family = AF_ECONET;
489 sec->port = eo->port;
490 sec->addr.station = eo->station;
491 sec->addr.net = eo->net;
493 *uaddr_len = sizeof(*sec);
497 static void econet_destroy_timer(unsigned long data)
499 struct sock *sk=(struct sock *)data;
501 if (!atomic_read(&sk->sk_wmem_alloc) &&
502 !atomic_read(&sk->sk_rmem_alloc)) {
507 sk->sk_timer.expires = jiffies + 10 * HZ;
508 add_timer(&sk->sk_timer);
509 printk(KERN_DEBUG "econet socket destroy delayed\n");
513 * Close an econet socket.
516 static int econet_release(struct socket *sock)
518 struct sock *sk = sock->sk;
523 econet_remove_socket(&econet_sklist, sk);
526 * Now the socket is dead. No more input will appear.
529 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
532 sk->sk_socket = NULL;
533 sock_set_flag(sk, SOCK_DEAD);
537 skb_queue_purge(&sk->sk_receive_queue);
539 if (atomic_read(&sk->sk_rmem_alloc) ||
540 atomic_read(&sk->sk_wmem_alloc)) {
541 sk->sk_timer.data = (unsigned long)sk;
542 sk->sk_timer.expires = jiffies + HZ;
543 sk->sk_timer.function = econet_destroy_timer;
544 add_timer(&sk->sk_timer);
553 * Create an Econet socket
556 static int econet_create(struct socket *sock, int protocol)
559 struct econet_opt *eo;
562 /* Econet only provides datagram services. */
563 if (sock->type != SOCK_DGRAM)
564 return -ESOCKTNOSUPPORT;
566 sock->state = SS_UNCONNECTED;
569 sk = sk_alloc(PF_ECONET, GFP_KERNEL, 1, NULL);
574 sock->ops = &econet_ops;
575 sock_init_data(sock,sk);
576 sk_set_owner(sk, THIS_MODULE);
578 eo = sk->sk_protinfo = kmalloc(sizeof(*eo), GFP_KERNEL);
581 memset(eo, 0, sizeof(*eo));
583 sk->sk_family = PF_ECONET;
586 econet_insert_socket(&econet_sklist, sk);
596 * Handle Econet specific ioctls
599 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
602 struct ec_device *edev;
603 struct net_device *dev;
604 struct sockaddr_ec *sec;
607 * Fetch the caller's info block into kernel space
610 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
613 if ((dev = dev_get_by_name(ifr.ifr_name)) == NULL)
616 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
624 /* Magic up a new one. */
625 edev = kmalloc(sizeof(struct ec_device), GFP_KERNEL);
627 printk("af_ec: memory squeeze.\n");
631 memset(edev, 0, sizeof(struct ec_device));
635 net2dev_map[edev->net] = NULL;
636 edev->station = sec->addr.station;
637 edev->net = sec->addr.net;
638 net2dev_map[sec->addr.net] = dev;
640 net2dev_map[0] = dev;
651 memset(sec, 0, sizeof(struct sockaddr_ec));
652 sec->addr.station = edev->station;
653 sec->addr.net = edev->net;
654 sec->sec_family = AF_ECONET;
656 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
666 * Handle generic ioctls
669 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
671 struct sock *sk = sock->sk;
672 void __user *argp = (void __user *)arg;
676 return sock_get_timestamp(sk, argp);
680 return ec_dev_ioctl(sock, cmd, argp);
684 return dev_ioctl(cmd, argp);
690 static struct net_proto_family econet_family_ops = {
692 .create = econet_create,
693 .owner = THIS_MODULE,
696 static struct proto_ops SOCKOPS_WRAPPED(econet_ops) = {
698 .owner = THIS_MODULE,
699 .release = econet_release,
701 .connect = sock_no_connect,
702 .socketpair = sock_no_socketpair,
703 .accept = sock_no_accept,
704 .getname = econet_getname,
705 .poll = datagram_poll,
706 .ioctl = econet_ioctl,
707 .listen = sock_no_listen,
708 .shutdown = sock_no_shutdown,
709 .setsockopt = sock_no_setsockopt,
710 .getsockopt = sock_no_getsockopt,
711 .sendmsg = econet_sendmsg,
712 .recvmsg = econet_recvmsg,
713 .mmap = sock_no_mmap,
714 .sendpage = sock_no_sendpage,
717 #include <linux/smp_lock.h>
718 SOCKOPS_WRAP(econet, PF_ECONET);
720 #ifdef CONFIG_ECONET_AUNUDP
722 * Find the listening socket, if any, for the given data.
725 static struct sock *ec_listening_socket(unsigned char port, unsigned char
726 station, unsigned char net)
729 struct hlist_node *node;
731 sk_for_each(sk, node, &econet_sklist) {
732 struct econet_opt *opt = ec_sk(sk);
733 if ((opt->port == port || opt->port == 0) &&
734 (opt->station == station || opt->station == 0) &&
735 (opt->net == net || opt->net == 0))
744 * Queue a received packet for a socket.
747 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
748 unsigned char stn, unsigned char net,
749 unsigned char cb, unsigned char port)
751 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
752 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
754 memset(sec, 0, sizeof(struct sockaddr_ec));
755 sec->sec_family = AF_ECONET;
756 sec->type = ECTYPE_PACKET_RECEIVED;
760 sec->addr.station = stn;
762 return sock_queue_rcv_skb(sk, skb);
766 * Send an AUN protocol response.
769 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
771 struct sockaddr_in sin;
774 struct msghdr udpmsg;
778 memset(&sin, 0, sizeof(sin));
779 sin.sin_family = AF_INET;
780 sin.sin_port = htons(AUN_PORT);
781 sin.sin_addr.s_addr = addr;
789 iov.iov_base = (void *)&ah;
790 iov.iov_len = sizeof(ah);
792 udpmsg.msg_name = (void *)&sin;
793 udpmsg.msg_namelen = sizeof(sin);
794 udpmsg.msg_iov = &iov;
795 udpmsg.msg_iovlen = 1;
796 udpmsg.msg_control = NULL;
797 udpmsg.msg_controllen = 0;
800 oldfs = get_fs(); set_fs(KERNEL_DS);
801 err = sock_sendmsg(udpsock, &udpmsg, sizeof(ah));
807 * Handle incoming AUN packets. Work out if anybody wants them,
808 * and send positive or negative acknowledgements as appropriate.
811 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
813 struct iphdr *ip = skb->nh.iph;
814 unsigned char stn = ntohl(ip->saddr) & 0xff;
816 struct sk_buff *newskb;
817 struct ec_device *edev = skb->dev->ec_ptr;
822 if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
823 goto bad; /* Nobody wants it */
825 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
829 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
830 /* Send nack and hope sender tries again */
834 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
835 len - sizeof(struct aunhdr));
837 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
839 /* Socket is bankrupt. */
844 aun_send_response(ip->saddr, ah->handle, 3, 0);
848 aun_send_response(ip->saddr, ah->handle, 4, 0);
852 * Handle incoming AUN transmit acknowledgements. If the sequence
853 * number matches something in our backlog then kill it and tell
854 * the user. If the remote took too long to reply then we may have
855 * dropped the packet already.
858 static void aun_tx_ack(unsigned long seq, int result)
864 spin_lock_irqsave(&aun_queue_lock, flags);
865 skb = skb_peek(&aun_queue);
866 while (skb && skb != (struct sk_buff *)&aun_queue)
868 struct sk_buff *newskb = skb->next;
869 eb = (struct ec_cb *)&skb->cb;
875 spin_unlock_irqrestore(&aun_queue_lock, flags);
876 printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
880 tx_result(skb->sk, eb->cookie, result);
882 spin_unlock_irqrestore(&aun_queue_lock, flags);
887 * Deal with received AUN frames - sort out what type of thing it is
888 * and hand it to the right function.
891 static void aun_data_available(struct sock *sk, int slen)
900 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
901 if (err == -EAGAIN) {
902 printk(KERN_ERR "AUN: no data available?!");
905 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
908 data = skb->h.raw + sizeof(struct udphdr);
909 ah = (struct aunhdr *)data;
910 len = skb->len - sizeof(struct udphdr);
916 aun_incoming(skb, ah, len);
919 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
922 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
925 /* This isn't quite right yet. */
927 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
931 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
934 skb_free_datagram(sk, skb);
938 * Called by the timer to manage the AUN transmit queue. If a packet
939 * was sent to a dead or nonexistent host then we will never get an
940 * acknowledgement back. After a few seconds we need to spot this and
944 static void ab_cleanup(unsigned long h)
949 spin_lock_irqsave(&aun_queue_lock, flags);
950 skb = skb_peek(&aun_queue);
951 while (skb && skb != (struct sk_buff *)&aun_queue)
953 struct sk_buff *newskb = skb->next;
954 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
955 if ((jiffies - eb->start) > eb->timeout)
957 tx_result(skb->sk, eb->cookie,
958 ECTYPE_TRANSMIT_NOT_PRESENT);
964 spin_unlock_irqrestore(&aun_queue_lock, flags);
966 mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
969 static int __init aun_udp_initialise(void)
972 struct sockaddr_in sin;
974 skb_queue_head_init(&aun_queue);
975 spin_lock_init(&aun_queue_lock);
976 init_timer(&ab_cleanup_timer);
977 ab_cleanup_timer.expires = jiffies + (HZ*2);
978 ab_cleanup_timer.function = ab_cleanup;
979 add_timer(&ab_cleanup_timer);
981 memset(&sin, 0, sizeof(sin));
982 sin.sin_port = htons(AUN_PORT);
984 /* We can count ourselves lucky Acorn machines are too dim to
986 if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
988 printk("AUN: socket error %d\n", -error);
992 udpsock->sk->sk_reuse = 1;
993 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
996 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1000 printk("AUN: bind error %d\n", -error);
1004 udpsock->sk->sk_data_ready = aun_data_available;
1009 sock_release(udpsock);
1015 #ifdef CONFIG_ECONET_NATIVE
1018 * Receive an Econet frame from a device.
1021 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
1023 struct ec_framehdr *hdr;
1025 struct ec_device *edev = dev->ec_ptr;
1027 if (skb->pkt_type == PACKET_OTHERHOST)
1033 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1036 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1039 hdr = (struct ec_framehdr *) skb->data;
1041 /* First check for encapsulated IP */
1042 if (hdr->port == EC_PORT_IP) {
1043 skb->protocol = htons(ETH_P_IP);
1044 skb_pull(skb, sizeof(struct ec_framehdr));
1049 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1053 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1064 static struct packet_type econet_packet_type = {
1065 .type = __constant_htons(ETH_P_ECONET),
1069 static void econet_hw_initialise(void)
1071 dev_add_pack(&econet_packet_type);
1076 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1078 struct net_device *dev = (struct net_device *)data;
1079 struct ec_device *edev;
1082 case NETDEV_UNREGISTER:
1083 /* A device has gone down - kill any data we hold for it. */
1087 if (net2dev_map[0] == dev)
1089 net2dev_map[edev->net] = NULL;
1099 static struct notifier_block econet_netdev_notifier = {
1100 .notifier_call =econet_notifier,
1103 static void __exit econet_proto_exit(void)
1105 #ifdef CONFIG_ECONET_AUNUDP
1106 del_timer(&ab_cleanup_timer);
1108 sock_release(udpsock);
1110 unregister_netdevice_notifier(&econet_netdev_notifier);
1111 sock_unregister(econet_family_ops.family);
1114 static int __init econet_proto_init(void)
1116 sock_register(&econet_family_ops);
1117 #ifdef CONFIG_ECONET_AUNUDP
1118 spin_lock_init(&aun_queue_lock);
1119 aun_udp_initialise();
1121 #ifdef CONFIG_ECONET_NATIVE
1122 econet_hw_initialise();
1124 register_netdevice_notifier(&econet_netdev_notifier);
1128 module_init(econet_proto_init);
1129 module_exit(econet_proto_exit);
1131 MODULE_LICENSE("GPL");
1132 MODULE_ALIAS_NETPROTO(PF_ECONET);