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
);