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>
34 #include <net/inet_common.h>
35 #include <linux/stat.h>
36 #include <linux/init.h>
37 #include <linux/if_ec.h>
40 #include <linux/spinlock.h>
41 #include <linux/rcupdate.h>
42 #include <linux/bitops.h>
43 #include <linux/mutex.h>
45 #include <asm/uaccess.h>
46 #include <asm/system.h>
48 static const struct proto_ops econet_ops
;
49 static struct hlist_head econet_sklist
;
50 static DEFINE_RWLOCK(econet_lock
);
51 static DEFINE_MUTEX(econet_mutex
);
53 /* Since there are only 256 possible network numbers (or fewer, depends
54 how you count) it makes sense to use a simple lookup table. */
55 static struct net_device
*net2dev_map
[256];
57 #define EC_PORT_IP 0xd2
59 #ifdef CONFIG_ECONET_AUNUDP
60 static DEFINE_SPINLOCK(aun_queue_lock
);
61 static struct socket
*udpsock
;
62 #define AUN_PORT 0x8000
67 unsigned char code
; /* AUN magic protocol byte */
74 static unsigned long aun_seq
;
76 /* Queue of packets waiting to be transmitted. */
77 static struct sk_buff_head aun_queue
;
78 static struct timer_list ab_cleanup_timer
;
80 #endif /* CONFIG_ECONET_AUNUDP */
82 /* Per-packet information */
85 struct sockaddr_ec sec
;
86 unsigned long cookie
; /* Supplied by user. */
87 #ifdef CONFIG_ECONET_AUNUDP
89 unsigned long seq
; /* Sequencing */
90 unsigned long timeout
; /* Timeout */
91 unsigned long start
; /* jiffies */
93 #ifdef CONFIG_ECONET_NATIVE
94 void (*sent
)(struct sk_buff
*, int result
);
98 static void econet_remove_socket(struct hlist_head
*list
, struct sock
*sk
)
100 write_lock_bh(&econet_lock
);
101 sk_del_node_init(sk
);
102 write_unlock_bh(&econet_lock
);
105 static void econet_insert_socket(struct hlist_head
*list
, struct sock
*sk
)
107 write_lock_bh(&econet_lock
);
108 sk_add_node(sk
, list
);
109 write_unlock_bh(&econet_lock
);
113 * Pull a packet from our receive queue and hand it to the user.
114 * If necessary we block.
117 static int econet_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
118 struct msghdr
*msg
, size_t len
, int flags
)
120 struct sock
*sk
= sock
->sk
;
125 msg
->msg_namelen
= sizeof(struct sockaddr_ec
);
127 mutex_lock(&econet_mutex
);
130 * Call the generic datagram receiver. This handles all sorts
131 * of horrible races and re-entrancy so we can forget about it
132 * in the protocol layers.
134 * Now it will return ENETDOWN, if device have just gone down,
135 * but then it will block.
138 skb
=skb_recv_datagram(sk
,flags
,flags
&MSG_DONTWAIT
,&err
);
141 * An error occurred so return it. Because skb_recv_datagram()
142 * handles the blocking we don't see and worry about blocking
150 * You lose any data beyond the buffer you gave. If it worries a
151 * user program they can ask the device for its MTU anyway.
158 msg
->msg_flags
|=MSG_TRUNC
;
161 /* We can't use skb_copy_datagram here */
162 err
= memcpy_toiovec(msg
->msg_iov
, skb
->data
, copied
);
165 sk
->sk_stamp
= skb
->tstamp
;
168 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
171 * Free or return the buffer as appropriate. Again this
172 * hides all the races and re-entrancy issues from us.
177 skb_free_datagram(sk
, skb
);
179 mutex_unlock(&econet_mutex
);
184 * Bind an Econet socket.
187 static int econet_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
189 struct sockaddr_ec
*sec
= (struct sockaddr_ec
*)uaddr
;
191 struct econet_sock
*eo
;
197 if (addr_len
< sizeof(struct sockaddr_ec
) ||
198 sec
->sec_family
!= AF_ECONET
)
201 mutex_lock(&econet_mutex
);
207 eo
->port
= sec
->port
;
208 eo
->station
= sec
->addr
.station
;
209 eo
->net
= sec
->addr
.net
;
211 mutex_unlock(&econet_mutex
);
216 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
218 * Queue a transmit result for the user to be told about.
221 static void tx_result(struct sock
*sk
, unsigned long cookie
, int result
)
223 struct sk_buff
*skb
= alloc_skb(0, GFP_ATOMIC
);
225 struct sockaddr_ec
*sec
;
229 printk(KERN_DEBUG
"ec: memory squeeze, transmit result dropped.\n");
233 eb
= (struct ec_cb
*)&skb
->cb
;
234 sec
= (struct sockaddr_ec
*)&eb
->sec
;
235 memset(sec
, 0, sizeof(struct sockaddr_ec
));
236 sec
->cookie
= cookie
;
237 sec
->type
= ECTYPE_TRANSMIT_STATUS
| result
;
238 sec
->sec_family
= AF_ECONET
;
240 if (sock_queue_rcv_skb(sk
, skb
) < 0)
245 #ifdef CONFIG_ECONET_NATIVE
247 * Called by the Econet hardware driver when a packet transmit
248 * has completed. Tell the user.
251 static void ec_tx_done(struct sk_buff
*skb
, int result
)
253 struct ec_cb
*eb
= (struct ec_cb
*)&skb
->cb
;
254 tx_result(skb
->sk
, eb
->cookie
, result
);
259 * Send a packet. We have to work out which device it's going out on
260 * and hence whether to use real Econet or the UDP emulation.
263 static int econet_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
264 struct msghdr
*msg
, size_t len
)
266 struct sock
*sk
= sock
->sk
;
267 struct sockaddr_ec
*saddr
=(struct sockaddr_ec
*)msg
->msg_name
;
268 struct net_device
*dev
;
271 unsigned char port
, cb
;
272 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
276 #ifdef CONFIG_ECONET_AUNUDP
277 struct msghdr udpmsg
;
278 struct iovec iov
[msg
->msg_iovlen
+1];
280 struct sockaddr_in udpdest
;
281 __kernel_size_t size
;
290 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_CMSG_COMPAT
))
294 * Get and verify the address.
297 mutex_lock(&econet_mutex
);
300 struct econet_sock
*eo
= ec_sk(sk
);
302 addr
.station
= eo
->station
;
307 if (msg
->msg_namelen
< sizeof(struct sockaddr_ec
)) {
308 mutex_unlock(&econet_mutex
);
311 addr
.station
= saddr
->addr
.station
;
312 addr
.net
= saddr
->addr
.net
;
317 /* Look for a device with the right network number. */
318 dev
= net2dev_map
[addr
.net
];
320 /* If not directly reachable, use some default */
322 dev
= net2dev_map
[0];
323 /* No interfaces at all? */
325 mutex_unlock(&econet_mutex
);
330 if (len
+ 15 > dev
->mtu
) {
331 mutex_unlock(&econet_mutex
);
335 if (dev
->type
== ARPHRD_ECONET
) {
336 /* Real hardware Econet. We're not worthy etc. */
337 #ifdef CONFIG_ECONET_NATIVE
338 unsigned short proto
= 0;
343 skb
= sock_alloc_send_skb(sk
, len
+LL_ALLOCATED_SPACE(dev
),
344 msg
->msg_flags
& MSG_DONTWAIT
, &err
);
348 skb_reserve(skb
, LL_RESERVED_SPACE(dev
));
349 skb_reset_network_header(skb
);
351 eb
= (struct ec_cb
*)&skb
->cb
;
353 /* BUG: saddr may be NULL */
354 eb
->cookie
= saddr
->cookie
;
356 eb
->sent
= ec_tx_done
;
359 res
= dev_hard_header(skb
, dev
, ntohs(proto
), &addr
, NULL
, len
);
363 struct ec_framehdr
*fh
;
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_reset_tail_pointer(skb
);
375 /* Copy the data. Returns -EFAULT on error */
376 err
= memcpy_fromiovec(skb_put(skb
,len
), msg
->msg_iov
, len
);
377 skb
->protocol
= proto
;
379 skb
->priority
= sk
->sk_priority
;
384 if (!(dev
->flags
& IFF_UP
))
393 mutex_unlock(&econet_mutex
);
404 mutex_unlock(&econet_mutex
);
409 #ifdef CONFIG_ECONET_AUNUDP
410 /* AUN virtual Econet. */
412 if (udpsock
== NULL
) {
413 mutex_unlock(&econet_mutex
);
414 return -ENETDOWN
; /* No socket - can't send */
417 /* Make up a UDP datagram and hand it off to some higher intellect. */
419 memset(&udpdest
, 0, sizeof(udpdest
));
420 udpdest
.sin_family
= AF_INET
;
421 udpdest
.sin_port
= htons(AUN_PORT
);
423 /* At the moment we use the stupid Acorn scheme of Econet address
424 y.x maps to IP a.b.c.x. This should be replaced with something
425 more flexible and more aware of subnet masks. */
427 struct in_device
*idev
;
428 unsigned long network
= 0;
431 idev
= __in_dev_get_rcu(dev
);
434 network
= ntohl(idev
->ifa_list
->ifa_address
) &
435 0xffffff00; /* !!! */
438 udpdest
.sin_addr
.s_addr
= htonl(network
| addr
.station
);
443 ah
.code
= 2; /* magic */
446 /* tack our header on the front of the iovec */
447 size
= sizeof(struct aunhdr
);
449 * XXX: that is b0rken. We can't mix userland and kernel pointers
450 * in iovec, since on a lot of platforms copy_from_user() will
451 * *not* work with the kernel and userland ones at the same time,
452 * regardless of what we do with set_fs(). And we are talking about
453 * econet-over-ethernet here, so "it's only ARM anyway" doesn't
454 * apply. Any suggestions on fixing that code? -- AV
456 iov
[0].iov_base
= (void *)&ah
;
457 iov
[0].iov_len
= size
;
458 for (i
= 0; i
< msg
->msg_iovlen
; i
++) {
459 void __user
*base
= msg
->msg_iov
[i
].iov_base
;
460 size_t len
= msg
->msg_iov
[i
].iov_len
;
461 /* Check it now since we switch to KERNEL_DS later. */
462 if (!access_ok(VERIFY_READ
, base
, len
)) {
463 mutex_unlock(&econet_mutex
);
466 iov
[i
+1].iov_base
= base
;
467 iov
[i
+1].iov_len
= len
;
471 /* Get a skbuff (no data, just holds our cb information) */
472 if ((skb
= sock_alloc_send_skb(sk
, 0,
473 msg
->msg_flags
& MSG_DONTWAIT
,
475 mutex_unlock(&econet_mutex
);
479 eb
= (struct ec_cb
*)&skb
->cb
;
481 eb
->cookie
= saddr
->cookie
;
482 eb
->timeout
= (5*HZ
);
485 eb
->seq
= (aun_seq
++);
488 skb_queue_tail(&aun_queue
, skb
);
490 udpmsg
.msg_name
= (void *)&udpdest
;
491 udpmsg
.msg_namelen
= sizeof(udpdest
);
492 udpmsg
.msg_iov
= &iov
[0];
493 udpmsg
.msg_iovlen
= msg
->msg_iovlen
+ 1;
494 udpmsg
.msg_control
= NULL
;
495 udpmsg
.msg_controllen
= 0;
498 oldfs
= get_fs(); set_fs(KERNEL_DS
); /* More privs :-) */
499 err
= sock_sendmsg(udpsock
, &udpmsg
, size
);
504 mutex_unlock(&econet_mutex
);
510 * Look up the address of a socket.
513 static int econet_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
514 int *uaddr_len
, int peer
)
517 struct econet_sock
*eo
;
518 struct sockaddr_ec
*sec
= (struct sockaddr_ec
*)uaddr
;
523 memset(sec
, 0, sizeof(*sec
));
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. */
581 skb_queue_purge(&sk
->sk_receive_queue
);
583 if (atomic_read(&sk
->sk_rmem_alloc
) ||
584 atomic_read(&sk
->sk_wmem_alloc
)) {
585 sk
->sk_timer
.data
= (unsigned long)sk
;
586 sk
->sk_timer
.expires
= jiffies
+ HZ
;
587 sk
->sk_timer
.function
= econet_destroy_timer
;
588 add_timer(&sk
->sk_timer
);
596 mutex_unlock(&econet_mutex
);
600 static struct proto econet_proto
= {
602 .owner
= THIS_MODULE
,
603 .obj_size
= sizeof(struct econet_sock
),
607 * Create an Econet socket
610 static int econet_create(struct net
*net
, struct socket
*sock
, int protocol
)
613 struct econet_sock
*eo
;
616 if (net
!= &init_net
)
617 return -EAFNOSUPPORT
;
619 /* Econet only provides datagram services. */
620 if (sock
->type
!= SOCK_DGRAM
)
621 return -ESOCKTNOSUPPORT
;
623 sock
->state
= SS_UNCONNECTED
;
626 sk
= sk_alloc(net
, PF_ECONET
, GFP_KERNEL
, &econet_proto
);
631 sock
->ops
= &econet_ops
;
632 sock_init_data(sock
, sk
);
635 sock_reset_flag(sk
, SOCK_ZAPPED
);
636 sk
->sk_family
= PF_ECONET
;
639 econet_insert_socket(&econet_sklist
, sk
);
646 * Handle Econet specific ioctls
649 static int ec_dev_ioctl(struct socket
*sock
, unsigned int cmd
, void __user
*arg
)
652 struct ec_device
*edev
;
653 struct net_device
*dev
;
654 struct sockaddr_ec
*sec
;
658 * Fetch the caller's info block into kernel space
661 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
664 if ((dev
= dev_get_by_name(&init_net
, ifr
.ifr_name
)) == NULL
)
667 sec
= (struct sockaddr_ec
*)&ifr
.ifr_addr
;
669 mutex_lock(&econet_mutex
);
676 /* Magic up a new one. */
677 edev
= kzalloc(sizeof(struct ec_device
), GFP_KERNEL
);
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
);
733 return sock_get_timestampns(sk
, argp
);
737 return ec_dev_ioctl(sock
, cmd
, argp
);
747 static struct net_proto_family econet_family_ops
= {
749 .create
= econet_create
,
750 .owner
= THIS_MODULE
,
753 static const struct proto_ops econet_ops
= {
755 .owner
= THIS_MODULE
,
756 .release
= econet_release
,
758 .connect
= sock_no_connect
,
759 .socketpair
= sock_no_socketpair
,
760 .accept
= sock_no_accept
,
761 .getname
= econet_getname
,
762 .poll
= datagram_poll
,
763 .ioctl
= econet_ioctl
,
764 .listen
= sock_no_listen
,
765 .shutdown
= sock_no_shutdown
,
766 .setsockopt
= sock_no_setsockopt
,
767 .getsockopt
= sock_no_getsockopt
,
768 .sendmsg
= econet_sendmsg
,
769 .recvmsg
= econet_recvmsg
,
770 .mmap
= sock_no_mmap
,
771 .sendpage
= sock_no_sendpage
,
774 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
776 * Find the listening socket, if any, for the given data.
779 static struct sock
*ec_listening_socket(unsigned char port
, unsigned char
780 station
, unsigned char net
)
783 struct hlist_node
*node
;
785 sk_for_each(sk
, node
, &econet_sklist
) {
786 struct econet_sock
*opt
= ec_sk(sk
);
787 if ((opt
->port
== port
|| opt
->port
== 0) &&
788 (opt
->station
== station
|| opt
->station
== 0) &&
789 (opt
->net
== net
|| opt
->net
== 0))
798 * Queue a received packet for a socket.
801 static int ec_queue_packet(struct sock
*sk
, struct sk_buff
*skb
,
802 unsigned char stn
, unsigned char net
,
803 unsigned char cb
, unsigned char port
)
805 struct ec_cb
*eb
= (struct ec_cb
*)&skb
->cb
;
806 struct sockaddr_ec
*sec
= (struct sockaddr_ec
*)&eb
->sec
;
808 memset(sec
, 0, sizeof(struct sockaddr_ec
));
809 sec
->sec_family
= AF_ECONET
;
810 sec
->type
= ECTYPE_PACKET_RECEIVED
;
814 sec
->addr
.station
= stn
;
816 return sock_queue_rcv_skb(sk
, skb
);
820 #ifdef CONFIG_ECONET_AUNUDP
822 * Send an AUN protocol response.
825 static void aun_send_response(__u32 addr
, unsigned long seq
, int code
, int cb
)
827 struct sockaddr_in sin
= {
828 .sin_family
= AF_INET
,
829 .sin_port
= htons(AUN_PORT
),
830 .sin_addr
= {.s_addr
= addr
}
832 struct aunhdr ah
= {.code
= code
, .cb
= cb
, .handle
= seq
};
833 struct kvec iov
= {.iov_base
= (void *)&ah
, .iov_len
= sizeof(ah
)};
834 struct msghdr udpmsg
;
836 udpmsg
.msg_name
= (void *)&sin
;
837 udpmsg
.msg_namelen
= sizeof(sin
);
838 udpmsg
.msg_control
= NULL
;
839 udpmsg
.msg_controllen
= 0;
842 kernel_sendmsg(udpsock
, &udpmsg
, &iov
, 1, sizeof(ah
));
847 * Handle incoming AUN packets. Work out if anybody wants them,
848 * and send positive or negative acknowledgements as appropriate.
851 static void aun_incoming(struct sk_buff
*skb
, struct aunhdr
*ah
, size_t len
)
853 struct iphdr
*ip
= ip_hdr(skb
);
854 unsigned char stn
= ntohl(ip
->saddr
) & 0xff;
856 struct sk_buff
*newskb
;
857 struct ec_device
*edev
= skb
->dev
->ec_ptr
;
862 if ((sk
= ec_listening_socket(ah
->port
, stn
, edev
->net
)) == NULL
)
863 goto bad
; /* Nobody wants it */
865 newskb
= alloc_skb((len
- sizeof(struct aunhdr
) + 15) & ~15,
869 printk(KERN_DEBUG
"AUN: memory squeeze, dropping packet.\n");
870 /* Send nack and hope sender tries again */
874 memcpy(skb_put(newskb
, len
- sizeof(struct aunhdr
)), (void *)(ah
+1),
875 len
- sizeof(struct aunhdr
));
877 if (ec_queue_packet(sk
, newskb
, stn
, edev
->net
, ah
->cb
, ah
->port
))
879 /* Socket is bankrupt. */
884 aun_send_response(ip
->saddr
, ah
->handle
, 3, 0);
888 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
= skb_peek(&aun_queue
);
906 while (skb
&& skb
!= (struct sk_buff
*)&aun_queue
)
908 struct sk_buff
*newskb
= skb
->next
;
909 eb
= (struct ec_cb
*)&skb
->cb
;
915 spin_unlock_irqrestore(&aun_queue_lock
, flags
);
916 printk(KERN_DEBUG
"AUN: unknown sequence %ld\n", seq
);
920 tx_result(skb
->sk
, eb
->cookie
, result
);
921 skb_unlink(skb
, &aun_queue
);
922 spin_unlock_irqrestore(&aun_queue_lock
, flags
);
927 * Deal with received AUN frames - sort out what type of thing it is
928 * and hand it to the right function.
931 static void aun_data_available(struct sock
*sk
, int slen
)
940 while ((skb
= skb_recv_datagram(sk
, 0, 1, &err
)) == NULL
) {
941 if (err
== -EAGAIN
) {
942 printk(KERN_ERR
"AUN: no data available?!");
945 printk(KERN_DEBUG
"AUN: recvfrom() error %d\n", -err
);
948 data
= skb_transport_header(skb
) + sizeof(struct udphdr
);
949 ah
= (struct aunhdr
*)data
;
950 len
= skb
->len
- sizeof(struct udphdr
);
956 aun_incoming(skb
, ah
, len
);
959 aun_tx_ack(ah
->handle
, ECTYPE_TRANSMIT_OK
);
962 aun_tx_ack(ah
->handle
, ECTYPE_TRANSMIT_NOT_LISTENING
);
965 /* This isn't quite right yet. */
967 aun_send_response(ip
->saddr
, ah
->handle
, 6, ah
->cb
);
971 printk(KERN_DEBUG
"unknown AUN packet (type %d)\n", data
[0]);
974 skb_free_datagram(sk
, skb
);
978 * Called by the timer to manage the AUN transmit queue. If a packet
979 * was sent to a dead or nonexistent host then we will never get an
980 * acknowledgement back. After a few seconds we need to spot this and
984 static void ab_cleanup(unsigned long h
)
989 spin_lock_irqsave(&aun_queue_lock
, flags
);
990 skb
= skb_peek(&aun_queue
);
991 while (skb
&& skb
!= (struct sk_buff
*)&aun_queue
)
993 struct sk_buff
*newskb
= skb
->next
;
994 struct ec_cb
*eb
= (struct ec_cb
*)&skb
->cb
;
995 if ((jiffies
- eb
->start
) > eb
->timeout
)
997 tx_result(skb
->sk
, eb
->cookie
,
998 ECTYPE_TRANSMIT_NOT_PRESENT
);
999 skb_unlink(skb
, &aun_queue
);
1004 spin_unlock_irqrestore(&aun_queue_lock
, flags
);
1006 mod_timer(&ab_cleanup_timer
, jiffies
+ (HZ
*2));
1009 static int __init
aun_udp_initialise(void)
1012 struct sockaddr_in sin
;
1014 skb_queue_head_init(&aun_queue
);
1015 spin_lock_init(&aun_queue_lock
);
1016 setup_timer(&ab_cleanup_timer
, ab_cleanup
, 0);
1017 ab_cleanup_timer
.expires
= jiffies
+ (HZ
*2);
1018 add_timer(&ab_cleanup_timer
);
1020 memset(&sin
, 0, sizeof(sin
));
1021 sin
.sin_port
= htons(AUN_PORT
);
1023 /* We can count ourselves lucky Acorn machines are too dim to
1025 if ((error
= sock_create_kern(PF_INET
, SOCK_DGRAM
, 0, &udpsock
)) < 0)
1027 printk("AUN: socket error %d\n", -error
);
1031 udpsock
->sk
->sk_reuse
= 1;
1032 udpsock
->sk
->sk_allocation
= GFP_ATOMIC
; /* we're going to call it
1035 error
= udpsock
->ops
->bind(udpsock
, (struct sockaddr
*)&sin
,
1039 printk("AUN: bind error %d\n", -error
);
1043 udpsock
->sk
->sk_data_ready
= aun_data_available
;
1048 sock_release(udpsock
);
1054 #ifdef CONFIG_ECONET_NATIVE
1057 * Receive an Econet frame from a device.
1060 static int econet_rcv(struct sk_buff
*skb
, struct net_device
*dev
, struct packet_type
*pt
, struct net_device
*orig_dev
)
1062 struct ec_framehdr
*hdr
;
1064 struct ec_device
*edev
= dev
->ec_ptr
;
1066 if (!net_eq(dev_net(dev
), &init_net
))
1069 if (skb
->pkt_type
== PACKET_OTHERHOST
)
1075 if ((skb
= skb_share_check(skb
, GFP_ATOMIC
)) == NULL
)
1078 if (!pskb_may_pull(skb
, sizeof(struct ec_framehdr
)))
1081 hdr
= (struct ec_framehdr
*) skb
->data
;
1083 /* First check for encapsulated IP */
1084 if (hdr
->port
== EC_PORT_IP
) {
1085 skb
->protocol
= htons(ETH_P_IP
);
1086 skb_pull(skb
, sizeof(struct ec_framehdr
));
1091 sk
= ec_listening_socket(hdr
->port
, hdr
->src_stn
, hdr
->src_net
);
1095 if (ec_queue_packet(sk
, skb
, edev
->net
, hdr
->src_stn
, hdr
->cb
,
1106 static struct packet_type econet_packet_type __read_mostly
= {
1107 .type
= cpu_to_be16(ETH_P_ECONET
),
1111 static void econet_hw_initialise(void)
1113 dev_add_pack(&econet_packet_type
);
1118 static int econet_notifier(struct notifier_block
*this, unsigned long msg
, void *data
)
1120 struct net_device
*dev
= (struct net_device
*)data
;
1121 struct ec_device
*edev
;
1123 if (!net_eq(dev_net(dev
), &init_net
))
1127 case NETDEV_UNREGISTER
:
1128 /* A device has gone down - kill any data we hold for it. */
1132 if (net2dev_map
[0] == dev
)
1133 net2dev_map
[0] = NULL
;
1134 net2dev_map
[edev
->net
] = NULL
;
1144 static struct notifier_block econet_netdev_notifier
= {
1145 .notifier_call
=econet_notifier
,
1148 static void __exit
econet_proto_exit(void)
1150 #ifdef CONFIG_ECONET_AUNUDP
1151 del_timer(&ab_cleanup_timer
);
1153 sock_release(udpsock
);
1155 unregister_netdevice_notifier(&econet_netdev_notifier
);
1156 #ifdef CONFIG_ECONET_NATIVE
1157 dev_remove_pack(&econet_packet_type
);
1159 sock_unregister(econet_family_ops
.family
);
1160 proto_unregister(&econet_proto
);
1163 static int __init
econet_proto_init(void)
1165 int err
= proto_register(&econet_proto
, 0);
1169 sock_register(&econet_family_ops
);
1170 #ifdef CONFIG_ECONET_AUNUDP
1171 spin_lock_init(&aun_queue_lock
);
1172 aun_udp_initialise();
1174 #ifdef CONFIG_ECONET_NATIVE
1175 econet_hw_initialise();
1177 register_netdevice_notifier(&econet_netdev_notifier
);
1182 module_init(econet_proto_init
);
1183 module_exit(econet_proto_exit
);
1185 MODULE_LICENSE("GPL");
1186 MODULE_ALIAS_NETPROTO(PF_ECONET
);