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__
11 #include <linux/hardirq.h>
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/netdevice.h>
15 #include <linux/if_ether.h>
16 #include <linux/moduleparam.h>
18 #include <linux/sched.h>
19 #include <linux/sockios.h>
20 #include <linux/caif/if_caif.h>
21 #include <net/rtnetlink.h>
22 #include <net/caif/caif_layer.h>
23 #include <net/caif/cfpkt.h>
24 #include <net/caif/caif_dev.h>
26 /* GPRS PDP connection has MTU to 1500 */
27 #define GPRS_PDP_MTU 1500
28 /* 5 sec. connect timeout */
29 #define CONNECT_TIMEOUT (5 * HZ)
30 #define CAIF_NET_DEFAULT_QUEUE_LEN 500
31 #define UNDEF_CONNID 0xffffffff
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
;
81 priv
= container_of(layr
, struct chnl_net
, chnl
);
85 skb
= (struct sk_buff
*) cfpkt_tonative(pkt
);
87 /* Get length of CAIF packet. */
90 /* Pass some minimum information and
91 * send the packet to the net stack.
93 skb
->dev
= priv
->netdev
;
95 /* check the version of IP */
96 ip_version
= skb_header_pointer(skb
, 0, 1, &buf
);
98 switch (*ip_version
>> 4) {
100 skb
->protocol
= htons(ETH_P_IP
);
103 skb
->protocol
= htons(ETH_P_IPV6
);
106 priv
->netdev
->stats
.rx_errors
++;
110 /* If we change the header in loop mode, the checksum is corrupted. */
111 if (priv
->conn_req
.protocol
== CAIFPROTO_DATAGRAM_LOOP
)
112 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
114 skb
->ip_summed
= CHECKSUM_NONE
;
121 /* Update statistics. */
122 priv
->netdev
->stats
.rx_packets
++;
123 priv
->netdev
->stats
.rx_bytes
+= pktlen
;
128 static int delete_device(struct chnl_net
*dev
)
132 unregister_netdevice(dev
->netdev
);
136 static void close_work(struct work_struct
*work
)
138 struct chnl_net
*dev
= NULL
;
139 struct list_head
*list_node
;
140 struct list_head
*_tmp
;
143 list_for_each_safe(list_node
, _tmp
, &chnl_net_list
) {
144 dev
= list_entry(list_node
, struct chnl_net
, list_field
);
145 if (dev
->state
== CAIF_SHUTDOWN
)
146 dev_close(dev
->netdev
);
150 static DECLARE_WORK(close_worker
, close_work
);
152 static void chnl_hold(struct cflayer
*lyr
)
154 struct chnl_net
*priv
= container_of(lyr
, struct chnl_net
, chnl
);
155 dev_hold(priv
->netdev
);
158 static void chnl_put(struct cflayer
*lyr
)
160 struct chnl_net
*priv
= container_of(lyr
, struct chnl_net
, chnl
);
161 dev_put(priv
->netdev
);
164 static void chnl_flowctrl_cb(struct cflayer
*layr
, enum caif_ctrlcmd flow
,
167 struct chnl_net
*priv
= container_of(layr
, struct chnl_net
, chnl
);
168 pr_debug("NET flowctrl func called flow: %s\n",
169 flow
== CAIF_CTRLCMD_FLOW_ON_IND
? "ON" :
170 flow
== CAIF_CTRLCMD_INIT_RSP
? "INIT" :
171 flow
== CAIF_CTRLCMD_FLOW_OFF_IND
? "OFF" :
172 flow
== CAIF_CTRLCMD_DEINIT_RSP
? "CLOSE/DEINIT" :
173 flow
== CAIF_CTRLCMD_INIT_FAIL_RSP
? "OPEN_FAIL" :
174 flow
== CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND
?
175 "REMOTE_SHUTDOWN" : "UKNOWN CTRL COMMAND");
180 case CAIF_CTRLCMD_FLOW_OFF_IND
:
181 priv
->flowenabled
= false;
182 netif_stop_queue(priv
->netdev
);
184 case CAIF_CTRLCMD_DEINIT_RSP
:
185 priv
->state
= CAIF_DISCONNECTED
;
187 case CAIF_CTRLCMD_INIT_FAIL_RSP
:
188 priv
->state
= CAIF_DISCONNECTED
;
189 wake_up_interruptible(&priv
->netmgmt_wq
);
191 case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND
:
192 priv
->state
= CAIF_SHUTDOWN
;
193 netif_tx_disable(priv
->netdev
);
194 schedule_work(&close_worker
);
196 case CAIF_CTRLCMD_FLOW_ON_IND
:
197 priv
->flowenabled
= true;
198 netif_wake_queue(priv
->netdev
);
200 case CAIF_CTRLCMD_INIT_RSP
:
201 caif_client_register_refcnt(&priv
->chnl
, chnl_hold
, chnl_put
);
202 priv
->state
= CAIF_CONNECTED
;
203 priv
->flowenabled
= true;
204 netif_wake_queue(priv
->netdev
);
205 wake_up_interruptible(&priv
->netmgmt_wq
);
212 static int chnl_net_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
214 struct chnl_net
*priv
;
215 struct cfpkt
*pkt
= NULL
;
218 /* Get our private data. */
219 priv
= netdev_priv(dev
);
221 if (skb
->len
> priv
->netdev
->mtu
) {
222 pr_warn("Size of skb exceeded MTU\n");
223 dev
->stats
.tx_errors
++;
227 if (!priv
->flowenabled
) {
228 pr_debug("dropping packets flow off\n");
229 dev
->stats
.tx_dropped
++;
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 dev
->stats
.tx_dropped
++;
248 /* Update statistics. */
249 dev
->stats
.tx_packets
++;
250 dev
->stats
.tx_bytes
+= len
;
255 static int chnl_net_open(struct net_device
*dev
)
257 struct chnl_net
*priv
= NULL
;
259 int llifindex
, headroom
, tailroom
, mtu
;
260 struct net_device
*lldev
;
262 priv
= netdev_priv(dev
);
264 pr_debug("chnl_net_open: no priv\n");
268 if (priv
->state
!= CAIF_CONNECTING
) {
269 priv
->state
= CAIF_CONNECTING
;
270 result
= caif_connect_client(dev_net(dev
), &priv
->conn_req
,
271 &priv
->chnl
, &llifindex
,
272 &headroom
, &tailroom
);
275 "Unable to register and open device,"
281 lldev
= dev_get_by_index(dev_net(dev
), llifindex
);
284 pr_debug("no interface?\n");
289 dev
->needed_tailroom
= tailroom
+ lldev
->needed_tailroom
;
290 dev
->hard_header_len
= headroom
+ lldev
->hard_header_len
+
291 lldev
->needed_tailroom
;
294 * MTU, head-room etc is not know before we have a
295 * CAIF link layer device available. MTU calculation may
296 * override initial RTNL configuration.
297 * MTU is minimum of current mtu, link layer mtu pluss
298 * CAIF head and tail, and PDP GPRS contexts max MTU.
300 mtu
= min_t(int, dev
->mtu
, lldev
->mtu
- (headroom
+ tailroom
));
301 mtu
= min_t(int, GPRS_PDP_MTU
, mtu
);
302 dev_set_mtu(dev
, mtu
);
306 pr_warn("CAIF Interface MTU too small (%d)\n", mtu
);
312 rtnl_unlock(); /* Release RTNL lock during connect wait */
314 result
= wait_event_interruptible_timeout(priv
->netmgmt_wq
,
315 priv
->state
!= CAIF_CONNECTING
,
320 if (result
== -ERESTARTSYS
) {
321 pr_debug("wait_event_interruptible woken by a signal\n");
322 result
= -ERESTARTSYS
;
327 pr_debug("connect timeout\n");
328 caif_disconnect_client(dev_net(dev
), &priv
->chnl
);
329 priv
->state
= CAIF_DISCONNECTED
;
330 pr_debug("state disconnected\n");
335 if (priv
->state
!= CAIF_CONNECTED
) {
336 pr_debug("connect failed\n");
337 result
= -ECONNREFUSED
;
340 pr_debug("CAIF Netdevice connected\n");
344 caif_disconnect_client(dev_net(dev
), &priv
->chnl
);
345 priv
->state
= CAIF_DISCONNECTED
;
346 pr_debug("state disconnected\n");
351 static int chnl_net_stop(struct net_device
*dev
)
353 struct chnl_net
*priv
;
356 priv
= netdev_priv(dev
);
357 priv
->state
= CAIF_DISCONNECTED
;
358 caif_disconnect_client(dev_net(dev
), &priv
->chnl
);
362 static int chnl_net_init(struct net_device
*dev
)
364 struct chnl_net
*priv
;
366 priv
= netdev_priv(dev
);
367 strncpy(priv
->name
, dev
->name
, sizeof(priv
->name
));
371 static void chnl_net_uninit(struct net_device
*dev
)
373 struct chnl_net
*priv
;
375 priv
= netdev_priv(dev
);
376 robust_list_del(&priv
->list_field
);
379 static const struct net_device_ops netdev_ops
= {
380 .ndo_open
= chnl_net_open
,
381 .ndo_stop
= chnl_net_stop
,
382 .ndo_init
= chnl_net_init
,
383 .ndo_uninit
= chnl_net_uninit
,
384 .ndo_start_xmit
= chnl_net_start_xmit
,
387 static void chnl_net_destructor(struct net_device
*dev
)
389 struct chnl_net
*priv
= netdev_priv(dev
);
390 caif_free_client(&priv
->chnl
);
394 static void ipcaif_net_setup(struct net_device
*dev
)
396 struct chnl_net
*priv
;
397 dev
->netdev_ops
= &netdev_ops
;
398 dev
->destructor
= chnl_net_destructor
;
399 dev
->flags
|= IFF_NOARP
;
400 dev
->flags
|= IFF_POINTOPOINT
;
401 dev
->mtu
= GPRS_PDP_MTU
;
402 dev
->tx_queue_len
= CAIF_NET_DEFAULT_QUEUE_LEN
;
404 priv
= netdev_priv(dev
);
405 priv
->chnl
.receive
= chnl_recv_cb
;
406 priv
->chnl
.ctrlcmd
= chnl_flowctrl_cb
;
408 priv
->conn_req
.protocol
= CAIFPROTO_DATAGRAM
;
409 priv
->conn_req
.link_selector
= CAIF_LINK_HIGH_BANDW
;
410 priv
->conn_req
.priority
= CAIF_PRIO_LOW
;
411 /* Insert illegal value */
412 priv
->conn_req
.sockaddr
.u
.dgm
.connection_id
= UNDEF_CONNID
;
413 priv
->flowenabled
= false;
415 init_waitqueue_head(&priv
->netmgmt_wq
);
419 static int ipcaif_fill_info(struct sk_buff
*skb
, const struct net_device
*dev
)
421 struct chnl_net
*priv
;
423 priv
= netdev_priv(dev
);
424 NLA_PUT_U32(skb
, IFLA_CAIF_IPV4_CONNID
,
425 priv
->conn_req
.sockaddr
.u
.dgm
.connection_id
);
426 NLA_PUT_U32(skb
, IFLA_CAIF_IPV6_CONNID
,
427 priv
->conn_req
.sockaddr
.u
.dgm
.connection_id
);
428 loop
= priv
->conn_req
.protocol
== CAIFPROTO_DATAGRAM_LOOP
;
429 NLA_PUT_U8(skb
, IFLA_CAIF_LOOPBACK
, loop
);
438 static void caif_netlink_parms(struct nlattr
*data
[],
439 struct caif_connect_request
*conn_req
)
442 pr_warn("no params data found\n");
445 if (data
[IFLA_CAIF_IPV4_CONNID
])
446 conn_req
->sockaddr
.u
.dgm
.connection_id
=
447 nla_get_u32(data
[IFLA_CAIF_IPV4_CONNID
]);
448 if (data
[IFLA_CAIF_IPV6_CONNID
])
449 conn_req
->sockaddr
.u
.dgm
.connection_id
=
450 nla_get_u32(data
[IFLA_CAIF_IPV6_CONNID
]);
451 if (data
[IFLA_CAIF_LOOPBACK
]) {
452 if (nla_get_u8(data
[IFLA_CAIF_LOOPBACK
]))
453 conn_req
->protocol
= CAIFPROTO_DATAGRAM_LOOP
;
455 conn_req
->protocol
= CAIFPROTO_DATAGRAM
;
459 static int ipcaif_newlink(struct net
*src_net
, struct net_device
*dev
,
460 struct nlattr
*tb
[], struct nlattr
*data
[])
463 struct chnl_net
*caifdev
;
465 caifdev
= netdev_priv(dev
);
466 caif_netlink_parms(data
, &caifdev
->conn_req
);
467 dev_net_set(caifdev
->netdev
, src_net
);
469 ret
= register_netdevice(dev
);
471 pr_warn("device rtml registration failed\n");
473 list_add(&caifdev
->list_field
, &chnl_net_list
);
475 /* Use ifindex as connection id, and use loopback channel default. */
476 if (caifdev
->conn_req
.sockaddr
.u
.dgm
.connection_id
== UNDEF_CONNID
) {
477 caifdev
->conn_req
.sockaddr
.u
.dgm
.connection_id
= dev
->ifindex
;
478 caifdev
->conn_req
.protocol
= CAIFPROTO_DATAGRAM_LOOP
;
483 static int ipcaif_changelink(struct net_device
*dev
, struct nlattr
*tb
[],
484 struct nlattr
*data
[])
486 struct chnl_net
*caifdev
;
488 caifdev
= netdev_priv(dev
);
489 caif_netlink_parms(data
, &caifdev
->conn_req
);
490 netdev_state_change(dev
);
494 static size_t ipcaif_get_size(const struct net_device
*dev
)
497 /* IFLA_CAIF_IPV4_CONNID */
499 /* IFLA_CAIF_IPV6_CONNID */
501 /* IFLA_CAIF_LOOPBACK */
506 static const struct nla_policy ipcaif_policy
[IFLA_CAIF_MAX
+ 1] = {
507 [IFLA_CAIF_IPV4_CONNID
] = { .type
= NLA_U32
},
508 [IFLA_CAIF_IPV6_CONNID
] = { .type
= NLA_U32
},
509 [IFLA_CAIF_LOOPBACK
] = { .type
= NLA_U8
}
513 static struct rtnl_link_ops ipcaif_link_ops __read_mostly
= {
515 .priv_size
= sizeof(struct chnl_net
),
516 .setup
= ipcaif_net_setup
,
517 .maxtype
= IFLA_CAIF_MAX
,
518 .policy
= ipcaif_policy
,
519 .newlink
= ipcaif_newlink
,
520 .changelink
= ipcaif_changelink
,
521 .get_size
= ipcaif_get_size
,
522 .fill_info
= ipcaif_fill_info
,
526 static int __init
chnl_init_module(void)
528 return rtnl_link_register(&ipcaif_link_ops
);
531 static void __exit
chnl_exit_module(void)
533 struct chnl_net
*dev
= NULL
;
534 struct list_head
*list_node
;
535 struct list_head
*_tmp
;
536 rtnl_link_unregister(&ipcaif_link_ops
);
538 list_for_each_safe(list_node
, _tmp
, &chnl_net_list
) {
539 dev
= list_entry(list_node
, struct chnl_net
, list_field
);
546 module_init(chnl_init_module
);
547 module_exit(chnl_exit_module
);