2 * Copyright (C) ST-Ericsson AB 2010
3 * Authors: Sjur Brendeland/sjur.brandeland@stericsson.com
4 * Daniel Martensson / Daniel.Martensson@stericsson.com
5 * License terms: GNU General Public License (GPL) version 2
8 #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__
10 #include <linux/version.h>
12 #include <linux/hardirq.h>
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/netdevice.h>
16 #include <linux/if_ether.h>
17 #include <linux/moduleparam.h>
19 #include <linux/sched.h>
20 #include <linux/sockios.h>
21 #include <linux/caif/if_caif.h>
22 #include <net/rtnetlink.h>
23 #include <net/caif/caif_layer.h>
24 #include <net/caif/cfpkt.h>
25 #include <net/caif/caif_dev.h>
27 /* GPRS PDP connection has MTU to 1500 */
28 #define GPRS_PDP_MTU 1500
29 /* 5 sec. connect timeout */
30 #define CONNECT_TIMEOUT (5 * HZ)
31 #define CAIF_NET_DEFAULT_QUEUE_LEN 500
33 /*This list is protected by the rtnl lock. */
34 static LIST_HEAD(chnl_net_list
);
36 MODULE_LICENSE("GPL");
37 MODULE_ALIAS_RTNL_LINK("caif");
48 struct net_device_stats stats
;
49 struct caif_connect_request conn_req
;
50 struct list_head list_field
;
51 struct net_device
*netdev
;
53 wait_queue_head_t netmgmt_wq
;
54 /* Flow status to remember and control the transmission. */
56 enum caif_states state
;
59 static void robust_list_del(struct list_head
*delete_node
)
61 struct list_head
*list_node
;
64 list_for_each_safe(list_node
, n
, &chnl_net_list
) {
65 if (list_node
== delete_node
) {
73 static int chnl_recv_cb(struct cflayer
*layr
, struct cfpkt
*pkt
)
76 struct chnl_net
*priv
= container_of(layr
, struct chnl_net
, chnl
);
82 priv
= container_of(layr
, struct chnl_net
, chnl
);
87 skb
= (struct sk_buff
*) cfpkt_tonative(pkt
);
89 /* Get length of CAIF packet. */
92 /* Pass some minimum information and
93 * send the packet to the net stack.
95 skb
->dev
= priv
->netdev
;
97 /* check the version of IP */
98 ip_version
= skb_header_pointer(skb
, 0, 1, &buf
);
101 switch (*ip_version
>> 4) {
103 skb
->protocol
= htons(ETH_P_IP
);
106 skb
->protocol
= htons(ETH_P_IPV6
);
112 /* If we change the header in loop mode, the checksum is corrupted. */
113 if (priv
->conn_req
.protocol
== CAIFPROTO_DATAGRAM_LOOP
)
114 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
116 skb
->ip_summed
= CHECKSUM_NONE
;
123 /* Update statistics. */
124 priv
->netdev
->stats
.rx_packets
++;
125 priv
->netdev
->stats
.rx_bytes
+= pktlen
;
130 static int delete_device(struct chnl_net
*dev
)
134 unregister_netdevice(dev
->netdev
);
138 static void close_work(struct work_struct
*work
)
140 struct chnl_net
*dev
= NULL
;
141 struct list_head
*list_node
;
142 struct list_head
*_tmp
;
145 list_for_each_safe(list_node
, _tmp
, &chnl_net_list
) {
146 dev
= list_entry(list_node
, struct chnl_net
, list_field
);
147 if (dev
->state
== CAIF_SHUTDOWN
)
148 dev_close(dev
->netdev
);
152 static DECLARE_WORK(close_worker
, close_work
);
154 static void chnl_hold(struct cflayer
*lyr
)
156 struct chnl_net
*priv
= container_of(lyr
, struct chnl_net
, chnl
);
157 dev_hold(priv
->netdev
);
160 static void chnl_put(struct cflayer
*lyr
)
162 struct chnl_net
*priv
= container_of(lyr
, struct chnl_net
, chnl
);
163 dev_put(priv
->netdev
);
166 static void chnl_flowctrl_cb(struct cflayer
*layr
, enum caif_ctrlcmd flow
,
169 struct chnl_net
*priv
= container_of(layr
, struct chnl_net
, chnl
);
170 pr_debug("NET flowctrl func called flow: %s\n",
171 flow
== CAIF_CTRLCMD_FLOW_ON_IND
? "ON" :
172 flow
== CAIF_CTRLCMD_INIT_RSP
? "INIT" :
173 flow
== CAIF_CTRLCMD_FLOW_OFF_IND
? "OFF" :
174 flow
== CAIF_CTRLCMD_DEINIT_RSP
? "CLOSE/DEINIT" :
175 flow
== CAIF_CTRLCMD_INIT_FAIL_RSP
? "OPEN_FAIL" :
176 flow
== CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND
?
177 "REMOTE_SHUTDOWN" : "UKNOWN CTRL COMMAND");
182 case CAIF_CTRLCMD_FLOW_OFF_IND
:
183 priv
->flowenabled
= false;
184 netif_stop_queue(priv
->netdev
);
186 case CAIF_CTRLCMD_DEINIT_RSP
:
187 priv
->state
= CAIF_DISCONNECTED
;
189 case CAIF_CTRLCMD_INIT_FAIL_RSP
:
190 priv
->state
= CAIF_DISCONNECTED
;
191 wake_up_interruptible(&priv
->netmgmt_wq
);
193 case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND
:
194 priv
->state
= CAIF_SHUTDOWN
;
195 netif_tx_disable(priv
->netdev
);
196 schedule_work(&close_worker
);
198 case CAIF_CTRLCMD_FLOW_ON_IND
:
199 priv
->flowenabled
= true;
200 netif_wake_queue(priv
->netdev
);
202 case CAIF_CTRLCMD_INIT_RSP
:
203 caif_client_register_refcnt(&priv
->chnl
, chnl_hold
, chnl_put
);
204 priv
->state
= CAIF_CONNECTED
;
205 priv
->flowenabled
= true;
206 netif_wake_queue(priv
->netdev
);
207 wake_up_interruptible(&priv
->netmgmt_wq
);
214 static int chnl_net_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
216 struct chnl_net
*priv
;
217 struct cfpkt
*pkt
= NULL
;
220 /* Get our private data. */
221 priv
= netdev_priv(dev
);
223 if (skb
->len
> priv
->netdev
->mtu
) {
224 pr_warn("Size of skb exceeded MTU\n");
228 if (!priv
->flowenabled
) {
229 pr_debug("dropping packets flow off\n");
230 return NETDEV_TX_BUSY
;
233 if (priv
->conn_req
.protocol
== CAIFPROTO_DATAGRAM_LOOP
)
234 swap(ip_hdr(skb
)->saddr
, ip_hdr(skb
)->daddr
);
236 /* Store original SKB length. */
239 pkt
= cfpkt_fromnative(CAIF_DIR_OUT
, (void *) skb
);
241 /* Send the packet down the stack. */
242 result
= priv
->chnl
.dn
->transmit(priv
->chnl
.dn
, pkt
);
244 if (result
== -EAGAIN
)
245 result
= NETDEV_TX_BUSY
;
249 /* Update statistics. */
250 dev
->stats
.tx_packets
++;
251 dev
->stats
.tx_bytes
+= len
;
256 static int chnl_net_open(struct net_device
*dev
)
258 struct chnl_net
*priv
= NULL
;
260 int llifindex
, headroom
, tailroom
, mtu
;
261 struct net_device
*lldev
;
263 priv
= netdev_priv(dev
);
265 pr_debug("chnl_net_open: no priv\n");
269 if (priv
->state
!= CAIF_CONNECTING
) {
270 priv
->state
= CAIF_CONNECTING
;
271 result
= caif_connect_client(dev_net(dev
), &priv
->conn_req
,
272 &priv
->chnl
, &llifindex
,
273 &headroom
, &tailroom
);
276 "Unable to register and open device,"
282 lldev
= dev_get_by_index(dev_net(dev
), llifindex
);
285 pr_debug("no interface?\n");
290 dev
->needed_tailroom
= tailroom
+ lldev
->needed_tailroom
;
291 dev
->hard_header_len
= headroom
+ lldev
->hard_header_len
+
292 lldev
->needed_tailroom
;
295 * MTU, head-room etc is not know before we have a
296 * CAIF link layer device available. MTU calculation may
297 * override initial RTNL configuration.
298 * MTU is minimum of current mtu, link layer mtu pluss
299 * CAIF head and tail, and PDP GPRS contexts max MTU.
301 mtu
= min_t(int, dev
->mtu
, lldev
->mtu
- (headroom
+ tailroom
));
302 mtu
= min_t(int, GPRS_PDP_MTU
, mtu
);
303 dev_set_mtu(dev
, mtu
);
307 pr_warn("CAIF Interface MTU too small (%d)\n", mtu
);
313 rtnl_unlock(); /* Release RTNL lock during connect wait */
315 result
= wait_event_interruptible_timeout(priv
->netmgmt_wq
,
316 priv
->state
!= CAIF_CONNECTING
,
321 if (result
== -ERESTARTSYS
) {
322 pr_debug("wait_event_interruptible woken by a signal\n");
323 result
= -ERESTARTSYS
;
328 pr_debug("connect timeout\n");
329 caif_disconnect_client(dev_net(dev
), &priv
->chnl
);
330 priv
->state
= CAIF_DISCONNECTED
;
331 pr_debug("state disconnected\n");
336 if (priv
->state
!= CAIF_CONNECTED
) {
337 pr_debug("connect failed\n");
338 result
= -ECONNREFUSED
;
341 pr_debug("CAIF Netdevice connected\n");
345 caif_disconnect_client(dev_net(dev
), &priv
->chnl
);
346 priv
->state
= CAIF_DISCONNECTED
;
347 pr_debug("state disconnected\n");
352 static int chnl_net_stop(struct net_device
*dev
)
354 struct chnl_net
*priv
;
357 priv
= netdev_priv(dev
);
358 priv
->state
= CAIF_DISCONNECTED
;
359 caif_disconnect_client(dev_net(dev
), &priv
->chnl
);
363 static int chnl_net_init(struct net_device
*dev
)
365 struct chnl_net
*priv
;
367 priv
= netdev_priv(dev
);
368 strncpy(priv
->name
, dev
->name
, sizeof(priv
->name
));
372 static void chnl_net_uninit(struct net_device
*dev
)
374 struct chnl_net
*priv
;
376 priv
= netdev_priv(dev
);
377 robust_list_del(&priv
->list_field
);
380 static const struct net_device_ops netdev_ops
= {
381 .ndo_open
= chnl_net_open
,
382 .ndo_stop
= chnl_net_stop
,
383 .ndo_init
= chnl_net_init
,
384 .ndo_uninit
= chnl_net_uninit
,
385 .ndo_start_xmit
= chnl_net_start_xmit
,
388 static void chnl_net_destructor(struct net_device
*dev
)
390 struct chnl_net
*priv
= netdev_priv(dev
);
391 caif_free_client(&priv
->chnl
);
395 static void ipcaif_net_setup(struct net_device
*dev
)
397 struct chnl_net
*priv
;
398 dev
->netdev_ops
= &netdev_ops
;
399 dev
->destructor
= chnl_net_destructor
;
400 dev
->flags
|= IFF_NOARP
;
401 dev
->flags
|= IFF_POINTOPOINT
;
402 dev
->mtu
= GPRS_PDP_MTU
;
403 dev
->tx_queue_len
= CAIF_NET_DEFAULT_QUEUE_LEN
;
405 priv
= netdev_priv(dev
);
406 priv
->chnl
.receive
= chnl_recv_cb
;
407 priv
->chnl
.ctrlcmd
= chnl_flowctrl_cb
;
409 priv
->conn_req
.protocol
= CAIFPROTO_DATAGRAM
;
410 priv
->conn_req
.link_selector
= CAIF_LINK_HIGH_BANDW
;
411 priv
->conn_req
.priority
= CAIF_PRIO_LOW
;
412 /* Insert illegal value */
413 priv
->conn_req
.sockaddr
.u
.dgm
.connection_id
= 0;
414 priv
->flowenabled
= false;
416 init_waitqueue_head(&priv
->netmgmt_wq
);
420 static int ipcaif_fill_info(struct sk_buff
*skb
, const struct net_device
*dev
)
422 struct chnl_net
*priv
;
424 priv
= netdev_priv(dev
);
425 NLA_PUT_U32(skb
, IFLA_CAIF_IPV4_CONNID
,
426 priv
->conn_req
.sockaddr
.u
.dgm
.connection_id
);
427 NLA_PUT_U32(skb
, IFLA_CAIF_IPV6_CONNID
,
428 priv
->conn_req
.sockaddr
.u
.dgm
.connection_id
);
429 loop
= priv
->conn_req
.protocol
== CAIFPROTO_DATAGRAM_LOOP
;
430 NLA_PUT_U8(skb
, IFLA_CAIF_LOOPBACK
, loop
);
439 static void caif_netlink_parms(struct nlattr
*data
[],
440 struct caif_connect_request
*conn_req
)
443 pr_warn("no params data found\n");
446 if (data
[IFLA_CAIF_IPV4_CONNID
])
447 conn_req
->sockaddr
.u
.dgm
.connection_id
=
448 nla_get_u32(data
[IFLA_CAIF_IPV4_CONNID
]);
449 if (data
[IFLA_CAIF_IPV6_CONNID
])
450 conn_req
->sockaddr
.u
.dgm
.connection_id
=
451 nla_get_u32(data
[IFLA_CAIF_IPV6_CONNID
]);
452 if (data
[IFLA_CAIF_LOOPBACK
]) {
453 if (nla_get_u8(data
[IFLA_CAIF_LOOPBACK
]))
454 conn_req
->protocol
= CAIFPROTO_DATAGRAM_LOOP
;
456 conn_req
->protocol
= CAIFPROTO_DATAGRAM
;
460 static int ipcaif_newlink(struct net
*src_net
, struct net_device
*dev
,
461 struct nlattr
*tb
[], struct nlattr
*data
[])
464 struct chnl_net
*caifdev
;
466 caifdev
= netdev_priv(dev
);
467 caif_netlink_parms(data
, &caifdev
->conn_req
);
468 dev_net_set(caifdev
->netdev
, src_net
);
470 ret
= register_netdevice(dev
);
472 pr_warn("device rtml registration failed\n");
474 list_add(&caifdev
->list_field
, &chnl_net_list
);
476 /* Take ifindex as connection-id if null */
477 if (caifdev
->conn_req
.sockaddr
.u
.dgm
.connection_id
== 0)
478 caifdev
->conn_req
.sockaddr
.u
.dgm
.connection_id
= dev
->ifindex
;
482 static int ipcaif_changelink(struct net_device
*dev
, struct nlattr
*tb
[],
483 struct nlattr
*data
[])
485 struct chnl_net
*caifdev
;
487 caifdev
= netdev_priv(dev
);
488 caif_netlink_parms(data
, &caifdev
->conn_req
);
489 netdev_state_change(dev
);
493 static size_t ipcaif_get_size(const struct net_device
*dev
)
496 /* IFLA_CAIF_IPV4_CONNID */
498 /* IFLA_CAIF_IPV6_CONNID */
500 /* IFLA_CAIF_LOOPBACK */
505 static const struct nla_policy ipcaif_policy
[IFLA_CAIF_MAX
+ 1] = {
506 [IFLA_CAIF_IPV4_CONNID
] = { .type
= NLA_U32
},
507 [IFLA_CAIF_IPV6_CONNID
] = { .type
= NLA_U32
},
508 [IFLA_CAIF_LOOPBACK
] = { .type
= NLA_U8
}
512 static struct rtnl_link_ops ipcaif_link_ops __read_mostly
= {
514 .priv_size
= sizeof(struct chnl_net
),
515 .setup
= ipcaif_net_setup
,
516 .maxtype
= IFLA_CAIF_MAX
,
517 .policy
= ipcaif_policy
,
518 .newlink
= ipcaif_newlink
,
519 .changelink
= ipcaif_changelink
,
520 .get_size
= ipcaif_get_size
,
521 .fill_info
= ipcaif_fill_info
,
525 static int __init
chnl_init_module(void)
527 return rtnl_link_register(&ipcaif_link_ops
);
530 static void __exit
chnl_exit_module(void)
532 struct chnl_net
*dev
= NULL
;
533 struct list_head
*list_node
;
534 struct list_head
*_tmp
;
535 rtnl_link_unregister(&ipcaif_link_ops
);
537 list_for_each_safe(list_node
, _tmp
, &chnl_net_list
) {
538 dev
= list_entry(list_node
, struct chnl_net
, list_field
);
545 module_init(chnl_init_module
);
546 module_exit(chnl_exit_module
);