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/cfpkt.h> 24 #include <net/caif/caif_dev.h> 25 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 32 /*This list is protected by the rtnl lock. */ 33 static LIST_HEAD(chnl_net_list); 34 35 MODULE_LICENSE("GPL"); 36 MODULE_ALIAS_RTNL_LINK("caif"); 37 38 enum caif_states { 39 CAIF_CONNECTED = 1, 40 CAIF_CONNECTING, 41 CAIF_DISCONNECTED, 42 CAIF_SHUTDOWN 43 }; 44 45 struct chnl_net { 46 struct cflayer chnl; 47 struct net_device_stats stats; 48 struct caif_connect_request conn_req; 49 struct list_head list_field; 50 struct net_device *netdev; 51 char name[256]; 52 wait_queue_head_t netmgmt_wq; 53 /* Flow status to remember and control the transmission. */ 54 bool flowenabled; 55 enum caif_states state; 56 }; 57 58 static void robust_list_del(struct list_head *delete_node) 59 { 60 struct list_head *list_node; 61 struct list_head *n; 62 ASSERT_RTNL(); 63 list_for_each_safe(list_node, n, &chnl_net_list) { 64 if (list_node == delete_node) { 65 list_del(list_node); 66 return; 67 } 68 } 69 WARN_ON(1); 70 } 71 72 static int chnl_recv_cb(struct cflayer *layr, struct cfpkt *pkt) 73 { 74 struct sk_buff *skb; 75 struct chnl_net *priv = container_of(layr, struct chnl_net, chnl); 76 int pktlen; 77 int err = 0; 78 const u8 *ip_version; 79 u8 buf; 80 81 priv = container_of(layr, struct chnl_net, chnl); 82 83 if (!priv) 84 return -EINVAL; 85 86 skb = (struct sk_buff *) cfpkt_tonative(pkt); 87 88 /* Get length of CAIF packet. */ 89 pktlen = skb->len; 90 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 129 static 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 137 static 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 143 rtnl_lock(); 144 list_for_each_safe(list_node, _tmp, &chnl_net_list) { 145 dev = list_entry(list_node, struct chnl_net, list_field); 146 if (dev->state == CAIF_SHUTDOWN) 147 dev_close(dev->netdev); 148 } 149 rtnl_unlock(); 150 } 151 static DECLARE_WORK(close_worker, close_work); 152 153 static void chnl_hold(struct cflayer *lyr) 154 { 155 struct chnl_net *priv = container_of(lyr, struct chnl_net, chnl); 156 dev_hold(priv->netdev); 157 } 158 159 static void chnl_put(struct cflayer *lyr) 160 { 161 struct chnl_net *priv = container_of(lyr, struct chnl_net, chnl); 162 dev_put(priv->netdev); 163 } 164 165 static void chnl_flowctrl_cb(struct cflayer *layr, enum caif_ctrlcmd flow, 166 int phyid) 167 { 168 struct chnl_net *priv = container_of(layr, struct chnl_net, chnl); 169 pr_debug("NET flowctrl func called flow: %s\n", 170 flow == CAIF_CTRLCMD_FLOW_ON_IND ? "ON" : 171 flow == CAIF_CTRLCMD_INIT_RSP ? "INIT" : 172 flow == CAIF_CTRLCMD_FLOW_OFF_IND ? "OFF" : 173 flow == CAIF_CTRLCMD_DEINIT_RSP ? "CLOSE/DEINIT" : 174 flow == CAIF_CTRLCMD_INIT_FAIL_RSP ? "OPEN_FAIL" : 175 flow == CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND ? 176 "REMOTE_SHUTDOWN" : "UKNOWN CTRL COMMAND"); 177 178 179 180 switch (flow) { 181 case CAIF_CTRLCMD_FLOW_OFF_IND: 182 priv->flowenabled = false; 183 netif_stop_queue(priv->netdev); 184 break; 185 case CAIF_CTRLCMD_DEINIT_RSP: 186 priv->state = CAIF_DISCONNECTED; 187 break; 188 case CAIF_CTRLCMD_INIT_FAIL_RSP: 189 priv->state = CAIF_DISCONNECTED; 190 wake_up_interruptible(&priv->netmgmt_wq); 191 break; 192 case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND: 193 priv->state = CAIF_SHUTDOWN; 194 netif_tx_disable(priv->netdev); 195 schedule_work(&close_worker); 196 break; 197 case CAIF_CTRLCMD_FLOW_ON_IND: 198 priv->flowenabled = true; 199 netif_wake_queue(priv->netdev); 200 break; 201 case CAIF_CTRLCMD_INIT_RSP: 202 caif_client_register_refcnt(&priv->chnl, chnl_hold, chnl_put); 203 priv->state = CAIF_CONNECTED; 204 priv->flowenabled = true; 205 netif_wake_queue(priv->netdev); 206 wake_up_interruptible(&priv->netmgmt_wq); 207 break; 208 default: 209 break; 210 } 211 } 212 213 static int chnl_net_start_xmit(struct sk_buff *skb, struct net_device *dev) 214 { 215 struct chnl_net *priv; 216 struct cfpkt *pkt = NULL; 217 int len; 218 int result = -1; 219 /* Get our private data. */ 220 priv = netdev_priv(dev); 221 222 if (skb->len > priv->netdev->mtu) { 223 pr_warn("Size of skb exceeded MTU\n"); 224 return -ENOSPC; 225 } 226 227 if (!priv->flowenabled) { 228 pr_debug("dropping packets flow off\n"); 229 return NETDEV_TX_BUSY; 230 } 231 232 if (priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP) 233 swap(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr); 234 235 /* Store original SKB length. */ 236 len = skb->len; 237 238 pkt = cfpkt_fromnative(CAIF_DIR_OUT, (void *) skb); 239 240 /* Send the packet down the stack. */ 241 result = priv->chnl.dn->transmit(priv->chnl.dn, pkt); 242 if (result) { 243 if (result == -EAGAIN) 244 result = NETDEV_TX_BUSY; 245 return result; 246 } 247 248 /* Update statistics. */ 249 dev->stats.tx_packets++; 250 dev->stats.tx_bytes += len; 251 252 return NETDEV_TX_OK; 253 } 254 255 static int chnl_net_open(struct net_device *dev) 256 { 257 struct chnl_net *priv = NULL; 258 int result = -1; 259 int llifindex, headroom, tailroom, mtu; 260 struct net_device *lldev; 261 ASSERT_RTNL(); 262 priv = netdev_priv(dev); 263 if (!priv) { 264 pr_debug("chnl_net_open: no priv\n"); 265 return -ENODEV; 266 } 267 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); 273 if (result != 0) { 274 pr_debug("err: " 275 "Unable to register and open device," 276 " Err:%d\n", 277 result); 278 goto error; 279 } 280 281 lldev = dev_get_by_index(dev_net(dev), llifindex); 282 283 if (lldev == NULL) { 284 pr_debug("no interface?\n"); 285 result = -ENODEV; 286 goto error; 287 } 288 289 dev->needed_tailroom = tailroom + lldev->needed_tailroom; 290 dev->hard_header_len = headroom + lldev->hard_header_len + 291 lldev->needed_tailroom; 292 293 /* 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. 299 */ 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); 303 dev_put(lldev); 304 305 if (mtu < 100) { 306 pr_warn("CAIF Interface MTU too small (%d)\n", mtu); 307 result = -ENODEV; 308 goto error; 309 } 310 } 311 312 rtnl_unlock(); /* Release RTNL lock during connect wait */ 313 314 result = wait_event_interruptible_timeout(priv->netmgmt_wq, 315 priv->state != CAIF_CONNECTING, 316 CONNECT_TIMEOUT); 317 318 rtnl_lock(); 319 320 if (result == -ERESTARTSYS) { 321 pr_debug("wait_event_interruptible woken by a signal\n"); 322 result = -ERESTARTSYS; 323 goto error; 324 } 325 326 if (result == 0) { 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"); 331 result = -ETIMEDOUT; 332 goto error; 333 } 334 335 if (priv->state != CAIF_CONNECTED) { 336 pr_debug("connect failed\n"); 337 result = -ECONNREFUSED; 338 goto error; 339 } 340 pr_debug("CAIF Netdevice connected\n"); 341 return 0; 342 343 error: 344 caif_disconnect_client(dev_net(dev), &priv->chnl); 345 priv->state = CAIF_DISCONNECTED; 346 pr_debug("state disconnected\n"); 347 return result; 348 349 } 350 351 static int chnl_net_stop(struct net_device *dev) 352 { 353 struct chnl_net *priv; 354 355 ASSERT_RTNL(); 356 priv = netdev_priv(dev); 357 priv->state = CAIF_DISCONNECTED; 358 caif_disconnect_client(dev_net(dev), &priv->chnl); 359 return 0; 360 } 361 362 static int chnl_net_init(struct net_device *dev) 363 { 364 struct chnl_net *priv; 365 ASSERT_RTNL(); 366 priv = netdev_priv(dev); 367 strncpy(priv->name, dev->name, sizeof(priv->name)); 368 return 0; 369 } 370 371 static void chnl_net_uninit(struct net_device *dev) 372 { 373 struct chnl_net *priv; 374 ASSERT_RTNL(); 375 priv = netdev_priv(dev); 376 robust_list_del(&priv->list_field); 377 } 378 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, 385 }; 386 387 static void chnl_net_destructor(struct net_device *dev) 388 { 389 struct chnl_net *priv = netdev_priv(dev); 390 caif_free_client(&priv->chnl); 391 free_netdev(dev); 392 } 393 394 static void ipcaif_net_setup(struct net_device *dev) 395 { 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; 403 404 priv = netdev_priv(dev); 405 priv->chnl.receive = chnl_recv_cb; 406 priv->chnl.ctrlcmd = chnl_flowctrl_cb; 407 priv->netdev = dev; 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 = 0; 413 priv->flowenabled = false; 414 415 init_waitqueue_head(&priv->netmgmt_wq); 416 } 417 418 419 static int ipcaif_fill_info(struct sk_buff *skb, const struct net_device *dev) 420 { 421 struct chnl_net *priv; 422 u8 loop; 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); 430 431 432 return 0; 433 nla_put_failure: 434 return -EMSGSIZE; 435 436 } 437 438 static void caif_netlink_parms(struct nlattr *data[], 439 struct caif_connect_request *conn_req) 440 { 441 if (!data) { 442 pr_warn("no params data found\n"); 443 return; 444 } 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; 454 else 455 conn_req->protocol = CAIFPROTO_DATAGRAM; 456 } 457 } 458 459 static int ipcaif_newlink(struct net *src_net, struct net_device *dev, 460 struct nlattr *tb[], struct nlattr *data[]) 461 { 462 int ret; 463 struct chnl_net *caifdev; 464 ASSERT_RTNL(); 465 caifdev = netdev_priv(dev); 466 caif_netlink_parms(data, &caifdev->conn_req); 467 dev_net_set(caifdev->netdev, src_net); 468 469 ret = register_netdevice(dev); 470 if (ret) 471 pr_warn("device rtml registration failed\n"); 472 else 473 list_add(&caifdev->list_field, &chnl_net_list); 474 475 /* Take ifindex as connection-id if null */ 476 if (caifdev->conn_req.sockaddr.u.dgm.connection_id == 0) 477 caifdev->conn_req.sockaddr.u.dgm.connection_id = dev->ifindex; 478 return ret; 479 } 480 481 static int ipcaif_changelink(struct net_device *dev, struct nlattr *tb[], 482 struct nlattr *data[]) 483 { 484 struct chnl_net *caifdev; 485 ASSERT_RTNL(); 486 caifdev = netdev_priv(dev); 487 caif_netlink_parms(data, &caifdev->conn_req); 488 netdev_state_change(dev); 489 return 0; 490 } 491 492 static size_t ipcaif_get_size(const struct net_device *dev) 493 { 494 return 495 /* IFLA_CAIF_IPV4_CONNID */ 496 nla_total_size(4) + 497 /* IFLA_CAIF_IPV6_CONNID */ 498 nla_total_size(4) + 499 /* IFLA_CAIF_LOOPBACK */ 500 nla_total_size(2) + 501 0; 502 } 503 504 static const struct nla_policy ipcaif_policy[IFLA_CAIF_MAX + 1] = { 505 [IFLA_CAIF_IPV4_CONNID] = { .type = NLA_U32 }, 506 [IFLA_CAIF_IPV6_CONNID] = { .type = NLA_U32 }, 507 [IFLA_CAIF_LOOPBACK] = { .type = NLA_U8 } 508 }; 509 510 511 static struct rtnl_link_ops ipcaif_link_ops __read_mostly = { 512 .kind = "caif", 513 .priv_size = sizeof(struct chnl_net), 514 .setup = ipcaif_net_setup, 515 .maxtype = IFLA_CAIF_MAX, 516 .policy = ipcaif_policy, 517 .newlink = ipcaif_newlink, 518 .changelink = ipcaif_changelink, 519 .get_size = ipcaif_get_size, 520 .fill_info = ipcaif_fill_info, 521 522 }; 523 524 static int __init chnl_init_module(void) 525 { 526 return rtnl_link_register(&ipcaif_link_ops); 527 } 528 529 static void __exit chnl_exit_module(void) 530 { 531 struct chnl_net *dev = NULL; 532 struct list_head *list_node; 533 struct list_head *_tmp; 534 rtnl_link_unregister(&ipcaif_link_ops); 535 rtnl_lock(); 536 list_for_each_safe(list_node, _tmp, &chnl_net_list) { 537 dev = list_entry(list_node, struct chnl_net, list_field); 538 list_del(list_node); 539 delete_device(dev); 540 } 541 rtnl_unlock(); 542 } 543 544 module_init(chnl_init_module); 545 module_exit(chnl_exit_module); 546