4 * GPRS over Phonet pipe end point socket
6 * Copyright (C) 2008 Nokia Corporation.
8 * Author: RĂ©mi Denis-Courmont <remi.denis-courmont@nokia.com>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * version 2 as published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
25 #include <linux/kernel.h>
26 #include <linux/netdevice.h>
27 #include <linux/if_ether.h>
28 #include <linux/if_arp.h>
31 #include <linux/if_phonet.h>
32 #include <net/tcp_states.h>
33 #include <net/phonet/gprs.h>
35 #define GPRS_DEFAULT_MTU 1400
39 void (*old_state_change)(struct sock *);
40 void (*old_data_ready)(struct sock *, int);
41 void (*old_write_space)(struct sock *);
43 struct net_device *net;
44 struct net_device_stats stats;
46 struct sk_buff_head tx_queue;
47 struct work_struct tx_work;
52 static int gprs_type_trans(struct sk_buff *skb)
57 pvfc = skb_header_pointer(skb, 0, 1, &buf);
60 /* Look at IP version field */
63 return htons(ETH_P_IP);
65 return htons(ETH_P_IPV6);
74 static void gprs_state_change(struct sock *sk)
76 struct gprs_dev *dev = sk->sk_user_data;
78 if (sk->sk_state == TCP_CLOSE_WAIT) {
79 netif_stop_queue(dev->net);
80 netif_carrier_off(dev->net);
84 static int gprs_recv(struct gprs_dev *dev, struct sk_buff *skb)
87 u16 protocol = gprs_type_trans(skb);
94 if (likely(skb_headroom(skb) & 3)) {
95 struct sk_buff *rskb, *fs;
98 /* Phonet Pipe data header is misaligned (3 bytes),
99 * so wrap the IP packet as a single fragment of an head-less
100 * socket buffer. The network stack will pull what it needs,
101 * but at least, the whole IP payload is not memcpy'd. */
102 rskb = netdev_alloc_skb(dev->net, 0);
107 skb_shinfo(rskb)->frag_list = skb;
108 rskb->len += skb->len;
109 rskb->data_len += rskb->len;
110 rskb->truesize += rskb->len;
112 /* Avoid nested fragments */
113 for (fs = skb_shinfo(skb)->frag_list; fs; fs = fs->next)
115 skb->next = skb_shinfo(skb)->frag_list;
116 skb_shinfo(skb)->frag_list = NULL;
118 skb->data_len -= flen;
119 skb->truesize -= flen;
124 skb->protocol = protocol;
125 skb_reset_mac_header(skb);
128 if (likely(dev->net->flags & IFF_UP)) {
129 dev->stats.rx_packets++;
130 dev->stats.rx_bytes += skb->len;
139 dev->stats.rx_dropped++;
144 static void gprs_data_ready(struct sock *sk, int len)
146 struct gprs_dev *dev = sk->sk_user_data;
149 while ((skb = pep_read(sk)) != NULL) {
155 static void gprs_write_space(struct sock *sk)
157 struct gprs_dev *dev = sk->sk_user_data;
158 unsigned credits = pep_writeable(sk);
160 spin_lock_bh(&dev->tx_lock);
161 dev->tx_max = credits;
162 if (credits > skb_queue_len(&dev->tx_queue))
163 netif_wake_queue(dev->net);
164 spin_unlock_bh(&dev->tx_lock);
168 * Network device callbacks
171 static int gprs_xmit(struct sk_buff *skb, struct net_device *net)
173 struct gprs_dev *dev = netdev_priv(net);
175 switch (skb->protocol) {
176 case htons(ETH_P_IP):
177 case htons(ETH_P_IPV6):
184 spin_lock(&dev->tx_lock);
185 if (likely(skb_queue_len(&dev->tx_queue) < dev->tx_max)) {
186 skb_queue_tail(&dev->tx_queue, skb);
189 if (skb_queue_len(&dev->tx_queue) >= dev->tx_max)
190 netif_stop_queue(net);
191 spin_unlock(&dev->tx_lock);
193 schedule_work(&dev->tx_work);
199 static void gprs_tx(struct work_struct *work)
201 struct gprs_dev *dev = container_of(work, struct gprs_dev, tx_work);
202 struct sock *sk = dev->sk;
205 while ((skb = skb_dequeue(&dev->tx_queue)) != NULL) {
208 dev->stats.tx_bytes += skb->len;
209 dev->stats.tx_packets++;
212 skb_set_owner_w(skb, sk);
215 err = pep_write(sk, skb);
217 LIMIT_NETDEBUG(KERN_WARNING"%s: TX error (%d)\n",
218 dev->net->name, err);
219 dev->stats.tx_aborted_errors++;
220 dev->stats.tx_errors++;
226 gprs_write_space(sk);
230 static int gprs_set_mtu(struct net_device *net, int new_mtu)
232 if ((new_mtu < 576) || (new_mtu > (PHONET_MAX_MTU - 11)))
239 static struct net_device_stats *gprs_get_stats(struct net_device *net)
241 struct gprs_dev *dev = netdev_priv(net);
246 static void gprs_setup(struct net_device *net)
248 net->features = NETIF_F_FRAGLIST;
249 net->type = ARPHRD_NONE;
250 net->flags = IFF_POINTOPOINT | IFF_NOARP;
251 net->mtu = GPRS_DEFAULT_MTU;
252 net->hard_header_len = 0;
254 net->tx_queue_len = 10;
256 net->destructor = free_netdev;
257 net->hard_start_xmit = gprs_xmit; /* mandatory */
258 net->change_mtu = gprs_set_mtu;
259 net->get_stats = gprs_get_stats;
267 * Attach a GPRS interface to a datagram socket.
268 * Returns the interface index on success, negative error code on error.
270 int gprs_attach(struct sock *sk)
272 static const char ifname[] = "gprs%d";
273 struct gprs_dev *dev;
274 struct net_device *net;
277 if (unlikely(sk->sk_type == SOCK_STREAM))
278 return -EINVAL; /* need packet boundaries */
280 /* Create net device */
281 net = alloc_netdev(sizeof(*dev), ifname, gprs_setup);
284 dev = netdev_priv(net);
287 spin_lock_init(&dev->tx_lock);
288 skb_queue_head_init(&dev->tx_queue);
289 INIT_WORK(&dev->tx_work, gprs_tx);
291 netif_stop_queue(net);
292 err = register_netdev(net);
299 if (unlikely(sk->sk_user_data)) {
303 if (unlikely((1 << sk->sk_state & (TCPF_CLOSE|TCPF_LISTEN)) ||
304 sock_flag(sk, SOCK_DEAD))) {
308 sk->sk_user_data = dev;
309 dev->old_state_change = sk->sk_state_change;
310 dev->old_data_ready = sk->sk_data_ready;
311 dev->old_write_space = sk->sk_write_space;
312 sk->sk_state_change = gprs_state_change;
313 sk->sk_data_ready = gprs_data_ready;
314 sk->sk_write_space = gprs_write_space;
320 printk(KERN_DEBUG"%s: attached\n", net->name);
321 gprs_write_space(sk); /* kick off TX */
326 unregister_netdev(net);
330 void gprs_detach(struct sock *sk)
332 struct gprs_dev *dev = sk->sk_user_data;
333 struct net_device *net = dev->net;
336 sk->sk_user_data = NULL;
337 sk->sk_state_change = dev->old_state_change;
338 sk->sk_data_ready = dev->old_data_ready;
339 sk->sk_write_space = dev->old_write_space;
342 printk(KERN_DEBUG"%s: detached\n", net->name);
343 unregister_netdev(net);
344 flush_scheduled_work();
346 skb_queue_purge(&dev->tx_queue);