tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
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
6 */
7
8#define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__
9
10#include <linux/version.h>
11#include <linux/fs.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>
17#include <linux/ip.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/cfcnfg.h>
24#include <net/caif/cfpkt.h>
25#include <net/caif/caif_dev.h>
26
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
32
33/*This list is protected by the rtnl lock. */
34static LIST_HEAD(chnl_net_list);
35
36MODULE_LICENSE("GPL");
37MODULE_ALIAS_RTNL_LINK("caif");
38
39enum caif_states {
40 CAIF_CONNECTED = 1,
41 CAIF_CONNECTING,
42 CAIF_DISCONNECTED,
43 CAIF_SHUTDOWN
44};
45
46struct chnl_net {
47 struct cflayer chnl;
48 struct net_device_stats stats;
49 struct caif_connect_request conn_req;
50 struct list_head list_field;
51 struct net_device *netdev;
52 char name[256];
53 wait_queue_head_t netmgmt_wq;
54 /* Flow status to remember and control the transmission. */
55 bool flowenabled;
56 enum caif_states state;
57};
58
59static void robust_list_del(struct list_head *delete_node)
60{
61 struct list_head *list_node;
62 struct list_head *n;
63 ASSERT_RTNL();
64 list_for_each_safe(list_node, n, &chnl_net_list) {
65 if (list_node == delete_node) {
66 list_del(list_node);
67 return;
68 }
69 }
70 WARN_ON(1);
71}
72
73static int chnl_recv_cb(struct cflayer *layr, struct cfpkt *pkt)
74{
75 struct sk_buff *skb;
76 struct chnl_net *priv = container_of(layr, struct chnl_net, chnl);
77 int pktlen;
78 int err = 0;
79 const u8 *ip_version;
80 u8 buf;
81
82 priv = container_of(layr, struct chnl_net, chnl);
83
84 if (!priv)
85 return -EINVAL;
86
87 /* Get length of CAIF packet. */
88 pktlen = cfpkt_getlen(pkt);
89
90 skb = (struct sk_buff *) cfpkt_tonative(pkt);
91 /* Pass some minimum information and
92 * send the packet to the net stack.
93 */
94 skb->dev = priv->netdev;
95
96 /* check the version of IP */
97 ip_version = skb_header_pointer(skb, 0, 1, &buf);
98 if (!ip_version)
99 return -EINVAL;
100 switch (*ip_version >> 4) {
101 case 4:
102 skb->protocol = htons(ETH_P_IP);
103 break;
104 case 6:
105 skb->protocol = htons(ETH_P_IPV6);
106 break;
107 default:
108 return -EINVAL;
109 }
110
111 /* If we change the header in loop mode, the checksum is corrupted. */
112 if (priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP)
113 skb->ip_summed = CHECKSUM_UNNECESSARY;
114 else
115 skb->ip_summed = CHECKSUM_NONE;
116
117 if (in_interrupt())
118 netif_rx(skb);
119 else
120 netif_rx_ni(skb);
121
122 /* Update statistics. */
123 priv->netdev->stats.rx_packets++;
124 priv->netdev->stats.rx_bytes += pktlen;
125
126 return err;
127}
128
129static int delete_device(struct chnl_net *dev)
130{
131 ASSERT_RTNL();
132 if (dev->netdev)
133 unregister_netdevice(dev->netdev);
134 return 0;
135}
136
137static void close_work(struct work_struct *work)
138{
139 struct chnl_net *dev = NULL;
140 struct list_head *list_node;
141 struct list_head *_tmp;
142 /* May be called with or without RTNL lock held */
143 int islocked = rtnl_is_locked();
144 if (!islocked)
145 rtnl_lock();
146 list_for_each_safe(list_node, _tmp, &chnl_net_list) {
147 dev = list_entry(list_node, struct chnl_net, list_field);
148 if (dev->state == CAIF_SHUTDOWN)
149 dev_close(dev->netdev);
150 }
151 if (!islocked)
152 rtnl_unlock();
153}
154static DECLARE_WORK(close_worker, close_work);
155
156static void chnl_flowctrl_cb(struct cflayer *layr, enum caif_ctrlcmd flow,
157 int phyid)
158{
159 struct chnl_net *priv = container_of(layr, struct chnl_net, chnl);
160 pr_debug("NET flowctrl func called flow: %s\n",
161 flow == CAIF_CTRLCMD_FLOW_ON_IND ? "ON" :
162 flow == CAIF_CTRLCMD_INIT_RSP ? "INIT" :
163 flow == CAIF_CTRLCMD_FLOW_OFF_IND ? "OFF" :
164 flow == CAIF_CTRLCMD_DEINIT_RSP ? "CLOSE/DEINIT" :
165 flow == CAIF_CTRLCMD_INIT_FAIL_RSP ? "OPEN_FAIL" :
166 flow == CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND ?
167 "REMOTE_SHUTDOWN" : "UKNOWN CTRL COMMAND");
168
169
170
171 switch (flow) {
172 case CAIF_CTRLCMD_FLOW_OFF_IND:
173 priv->flowenabled = false;
174 netif_stop_queue(priv->netdev);
175 break;
176 case CAIF_CTRLCMD_DEINIT_RSP:
177 priv->state = CAIF_DISCONNECTED;
178 break;
179 case CAIF_CTRLCMD_INIT_FAIL_RSP:
180 priv->state = CAIF_DISCONNECTED;
181 wake_up_interruptible(&priv->netmgmt_wq);
182 break;
183 case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND:
184 priv->state = CAIF_SHUTDOWN;
185 netif_tx_disable(priv->netdev);
186 schedule_work(&close_worker);
187 break;
188 case CAIF_CTRLCMD_FLOW_ON_IND:
189 priv->flowenabled = true;
190 netif_wake_queue(priv->netdev);
191 break;
192 case CAIF_CTRLCMD_INIT_RSP:
193 priv->state = CAIF_CONNECTED;
194 priv->flowenabled = true;
195 netif_wake_queue(priv->netdev);
196 wake_up_interruptible(&priv->netmgmt_wq);
197 break;
198 default:
199 break;
200 }
201}
202
203static int chnl_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
204{
205 struct chnl_net *priv;
206 struct cfpkt *pkt = NULL;
207 int len;
208 int result = -1;
209 /* Get our private data. */
210 priv = netdev_priv(dev);
211
212 if (skb->len > priv->netdev->mtu) {
213 pr_warn("Size of skb exceeded MTU\n");
214 return -ENOSPC;
215 }
216
217 if (!priv->flowenabled) {
218 pr_debug("dropping packets flow off\n");
219 return NETDEV_TX_BUSY;
220 }
221
222 if (priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP)
223 swap(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
224
225 /* Store original SKB length. */
226 len = skb->len;
227
228 pkt = cfpkt_fromnative(CAIF_DIR_OUT, (void *) skb);
229
230 /* Send the packet down the stack. */
231 result = priv->chnl.dn->transmit(priv->chnl.dn, pkt);
232 if (result) {
233 if (result == -EAGAIN)
234 result = NETDEV_TX_BUSY;
235 return result;
236 }
237
238 /* Update statistics. */
239 dev->stats.tx_packets++;
240 dev->stats.tx_bytes += len;
241
242 return NETDEV_TX_OK;
243}
244
245static int chnl_net_open(struct net_device *dev)
246{
247 struct chnl_net *priv = NULL;
248 int result = -1;
249 int llifindex, headroom, tailroom, mtu;
250 struct net_device *lldev;
251 ASSERT_RTNL();
252 priv = netdev_priv(dev);
253 if (!priv) {
254 pr_debug("chnl_net_open: no priv\n");
255 return -ENODEV;
256 }
257
258 if (priv->state != CAIF_CONNECTING) {
259 priv->state = CAIF_CONNECTING;
260 result = caif_connect_client(&priv->conn_req, &priv->chnl,
261 &llifindex, &headroom, &tailroom);
262 if (result != 0) {
263 pr_debug("err: "
264 "Unable to register and open device,"
265 " Err:%d\n",
266 result);
267 goto error;
268 }
269
270 lldev = dev_get_by_index(dev_net(dev), llifindex);
271
272 if (lldev == NULL) {
273 pr_debug("no interface?\n");
274 result = -ENODEV;
275 goto error;
276 }
277
278 dev->needed_tailroom = tailroom + lldev->needed_tailroom;
279 dev->hard_header_len = headroom + lldev->hard_header_len +
280 lldev->needed_tailroom;
281
282 /*
283 * MTU, head-room etc is not know before we have a
284 * CAIF link layer device available. MTU calculation may
285 * override initial RTNL configuration.
286 * MTU is minimum of current mtu, link layer mtu pluss
287 * CAIF head and tail, and PDP GPRS contexts max MTU.
288 */
289 mtu = min_t(int, dev->mtu, lldev->mtu - (headroom + tailroom));
290 mtu = min_t(int, GPRS_PDP_MTU, mtu);
291 dev_set_mtu(dev, mtu);
292 dev_put(lldev);
293
294 if (mtu < 100) {
295 pr_warn("CAIF Interface MTU too small (%d)\n", mtu);
296 result = -ENODEV;
297 goto error;
298 }
299 }
300
301 rtnl_unlock(); /* Release RTNL lock during connect wait */
302
303 result = wait_event_interruptible_timeout(priv->netmgmt_wq,
304 priv->state != CAIF_CONNECTING,
305 CONNECT_TIMEOUT);
306
307 rtnl_lock();
308
309 if (result == -ERESTARTSYS) {
310 pr_debug("wait_event_interruptible woken by a signal\n");
311 result = -ERESTARTSYS;
312 goto error;
313 }
314
315 if (result == 0) {
316 pr_debug("connect timeout\n");
317 caif_disconnect_client(&priv->chnl);
318 priv->state = CAIF_DISCONNECTED;
319 pr_debug("state disconnected\n");
320 result = -ETIMEDOUT;
321 goto error;
322 }
323
324 if (priv->state != CAIF_CONNECTED) {
325 pr_debug("connect failed\n");
326 result = -ECONNREFUSED;
327 goto error;
328 }
329 pr_debug("CAIF Netdevice connected\n");
330 return 0;
331
332error:
333 caif_disconnect_client(&priv->chnl);
334 priv->state = CAIF_DISCONNECTED;
335 pr_debug("state disconnected\n");
336 return result;
337
338}
339
340static int chnl_net_stop(struct net_device *dev)
341{
342 struct chnl_net *priv;
343
344 ASSERT_RTNL();
345 priv = netdev_priv(dev);
346 priv->state = CAIF_DISCONNECTED;
347 caif_disconnect_client(&priv->chnl);
348 return 0;
349}
350
351static int chnl_net_init(struct net_device *dev)
352{
353 struct chnl_net *priv;
354 ASSERT_RTNL();
355 priv = netdev_priv(dev);
356 strncpy(priv->name, dev->name, sizeof(priv->name));
357 return 0;
358}
359
360static void chnl_net_uninit(struct net_device *dev)
361{
362 struct chnl_net *priv;
363 ASSERT_RTNL();
364 priv = netdev_priv(dev);
365 robust_list_del(&priv->list_field);
366}
367
368static const struct net_device_ops netdev_ops = {
369 .ndo_open = chnl_net_open,
370 .ndo_stop = chnl_net_stop,
371 .ndo_init = chnl_net_init,
372 .ndo_uninit = chnl_net_uninit,
373 .ndo_start_xmit = chnl_net_start_xmit,
374};
375
376static void ipcaif_net_setup(struct net_device *dev)
377{
378 struct chnl_net *priv;
379 dev->netdev_ops = &netdev_ops;
380 dev->destructor = free_netdev;
381 dev->flags |= IFF_NOARP;
382 dev->flags |= IFF_POINTOPOINT;
383 dev->mtu = GPRS_PDP_MTU;
384 dev->tx_queue_len = CAIF_NET_DEFAULT_QUEUE_LEN;
385
386 priv = netdev_priv(dev);
387 priv->chnl.receive = chnl_recv_cb;
388 priv->chnl.ctrlcmd = chnl_flowctrl_cb;
389 priv->netdev = dev;
390 priv->conn_req.protocol = CAIFPROTO_DATAGRAM;
391 priv->conn_req.link_selector = CAIF_LINK_HIGH_BANDW;
392 priv->conn_req.priority = CAIF_PRIO_LOW;
393 /* Insert illegal value */
394 priv->conn_req.sockaddr.u.dgm.connection_id = -1;
395 priv->flowenabled = false;
396
397 init_waitqueue_head(&priv->netmgmt_wq);
398}
399
400
401static int ipcaif_fill_info(struct sk_buff *skb, const struct net_device *dev)
402{
403 struct chnl_net *priv;
404 u8 loop;
405 priv = netdev_priv(dev);
406 NLA_PUT_U32(skb, IFLA_CAIF_IPV4_CONNID,
407 priv->conn_req.sockaddr.u.dgm.connection_id);
408 NLA_PUT_U32(skb, IFLA_CAIF_IPV6_CONNID,
409 priv->conn_req.sockaddr.u.dgm.connection_id);
410 loop = priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP;
411 NLA_PUT_U8(skb, IFLA_CAIF_LOOPBACK, loop);
412
413
414 return 0;
415nla_put_failure:
416 return -EMSGSIZE;
417
418}
419
420static void caif_netlink_parms(struct nlattr *data[],
421 struct caif_connect_request *conn_req)
422{
423 if (!data) {
424 pr_warn("no params data found\n");
425 return;
426 }
427 if (data[IFLA_CAIF_IPV4_CONNID])
428 conn_req->sockaddr.u.dgm.connection_id =
429 nla_get_u32(data[IFLA_CAIF_IPV4_CONNID]);
430 if (data[IFLA_CAIF_IPV6_CONNID])
431 conn_req->sockaddr.u.dgm.connection_id =
432 nla_get_u32(data[IFLA_CAIF_IPV6_CONNID]);
433 if (data[IFLA_CAIF_LOOPBACK]) {
434 if (nla_get_u8(data[IFLA_CAIF_LOOPBACK]))
435 conn_req->protocol = CAIFPROTO_DATAGRAM_LOOP;
436 else
437 conn_req->protocol = CAIFPROTO_DATAGRAM;
438 }
439}
440
441static int ipcaif_newlink(struct net *src_net, struct net_device *dev,
442 struct nlattr *tb[], struct nlattr *data[])
443{
444 int ret;
445 struct chnl_net *caifdev;
446 ASSERT_RTNL();
447 caifdev = netdev_priv(dev);
448 caif_netlink_parms(data, &caifdev->conn_req);
449 dev_net_set(caifdev->netdev, src_net);
450
451 ret = register_netdevice(dev);
452 if (ret)
453 pr_warn("device rtml registration failed\n");
454 else
455 list_add(&caifdev->list_field, &chnl_net_list);
456 return ret;
457}
458
459static int ipcaif_changelink(struct net_device *dev, struct nlattr *tb[],
460 struct nlattr *data[])
461{
462 struct chnl_net *caifdev;
463 ASSERT_RTNL();
464 caifdev = netdev_priv(dev);
465 caif_netlink_parms(data, &caifdev->conn_req);
466 netdev_state_change(dev);
467 return 0;
468}
469
470static size_t ipcaif_get_size(const struct net_device *dev)
471{
472 return
473 /* IFLA_CAIF_IPV4_CONNID */
474 nla_total_size(4) +
475 /* IFLA_CAIF_IPV6_CONNID */
476 nla_total_size(4) +
477 /* IFLA_CAIF_LOOPBACK */
478 nla_total_size(2) +
479 0;
480}
481
482static const struct nla_policy ipcaif_policy[IFLA_CAIF_MAX + 1] = {
483 [IFLA_CAIF_IPV4_CONNID] = { .type = NLA_U32 },
484 [IFLA_CAIF_IPV6_CONNID] = { .type = NLA_U32 },
485 [IFLA_CAIF_LOOPBACK] = { .type = NLA_U8 }
486};
487
488
489static struct rtnl_link_ops ipcaif_link_ops __read_mostly = {
490 .kind = "caif",
491 .priv_size = sizeof(struct chnl_net),
492 .setup = ipcaif_net_setup,
493 .maxtype = IFLA_CAIF_MAX,
494 .policy = ipcaif_policy,
495 .newlink = ipcaif_newlink,
496 .changelink = ipcaif_changelink,
497 .get_size = ipcaif_get_size,
498 .fill_info = ipcaif_fill_info,
499
500};
501
502static int __init chnl_init_module(void)
503{
504 return rtnl_link_register(&ipcaif_link_ops);
505}
506
507static void __exit chnl_exit_module(void)
508{
509 struct chnl_net *dev = NULL;
510 struct list_head *list_node;
511 struct list_head *_tmp;
512 rtnl_link_unregister(&ipcaif_link_ops);
513 rtnl_lock();
514 list_for_each_safe(list_node, _tmp, &chnl_net_list) {
515 dev = list_entry(list_node, struct chnl_net, list_field);
516 list_del(list_node);
517 delete_device(dev);
518 }
519 rtnl_unlock();
520}
521
522module_init(chnl_init_module);
523module_exit(chnl_exit_module);