linux/net/caif/caif_dev.c
<<
>>
Prefs
   1/*
   2 * CAIF Interface registration.
   3 * Copyright (C) ST-Ericsson AB 2010
   4 * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
   5 * License terms: GNU General Public License (GPL) version 2
   6 *
   7 * Borrowed heavily from file: pn_dev.c. Thanks to
   8 *  Remi Denis-Courmont <remi.denis-courmont@nokia.com>
   9 *  and Sakari Ailus <sakari.ailus@nokia.com>
  10 */
  11
  12#define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__
  13
  14#include <linux/version.h>
  15#include <linux/module.h>
  16#include <linux/kernel.h>
  17#include <linux/if_arp.h>
  18#include <linux/net.h>
  19#include <linux/netdevice.h>
  20#include <linux/skbuff.h>
  21#include <linux/sched.h>
  22#include <linux/wait.h>
  23#include <net/netns/generic.h>
  24#include <net/net_namespace.h>
  25#include <net/pkt_sched.h>
  26#include <net/caif/caif_device.h>
  27#include <net/caif/caif_dev.h>
  28#include <net/caif/caif_layer.h>
  29#include <net/caif/cfpkt.h>
  30#include <net/caif/cfcnfg.h>
  31
  32MODULE_LICENSE("GPL");
  33#define TIMEOUT (HZ*5)
  34
  35/* Used for local tracking of the CAIF net devices */
  36struct caif_device_entry {
  37        struct cflayer layer;
  38        struct list_head list;
  39        atomic_t in_use;
  40        atomic_t state;
  41        u16 phyid;
  42        struct net_device *netdev;
  43        wait_queue_head_t event;
  44};
  45
  46struct caif_device_entry_list {
  47        struct list_head list;
  48        /* Protects simulanous deletes in list */
  49        spinlock_t lock;
  50};
  51
  52struct caif_net {
  53        struct caif_device_entry_list caifdevs;
  54};
  55
  56static int caif_net_id;
  57static struct cfcnfg *cfg;
  58
  59static struct caif_device_entry_list *caif_device_list(struct net *net)
  60{
  61        struct caif_net *caifn;
  62        BUG_ON(!net);
  63        caifn = net_generic(net, caif_net_id);
  64        BUG_ON(!caifn);
  65        return &caifn->caifdevs;
  66}
  67
  68/* Allocate new CAIF device. */
  69static struct caif_device_entry *caif_device_alloc(struct net_device *dev)
  70{
  71        struct caif_device_entry_list *caifdevs;
  72        struct caif_device_entry *caifd;
  73        caifdevs = caif_device_list(dev_net(dev));
  74        BUG_ON(!caifdevs);
  75        caifd = kzalloc(sizeof(*caifd), GFP_ATOMIC);
  76        if (!caifd)
  77                return NULL;
  78        caifd->netdev = dev;
  79        list_add(&caifd->list, &caifdevs->list);
  80        init_waitqueue_head(&caifd->event);
  81        return caifd;
  82}
  83
  84static struct caif_device_entry *caif_get(struct net_device *dev)
  85{
  86        struct caif_device_entry_list *caifdevs =
  87            caif_device_list(dev_net(dev));
  88        struct caif_device_entry *caifd;
  89        BUG_ON(!caifdevs);
  90        list_for_each_entry(caifd, &caifdevs->list, list) {
  91                if (caifd->netdev == dev)
  92                        return caifd;
  93        }
  94        return NULL;
  95}
  96
  97static void caif_device_destroy(struct net_device *dev)
  98{
  99        struct caif_device_entry_list *caifdevs =
 100            caif_device_list(dev_net(dev));
 101        struct caif_device_entry *caifd;
 102        ASSERT_RTNL();
 103        if (dev->type != ARPHRD_CAIF)
 104                return;
 105
 106        spin_lock_bh(&caifdevs->lock);
 107        caifd = caif_get(dev);
 108        if (caifd == NULL) {
 109                spin_unlock_bh(&caifdevs->lock);
 110                return;
 111        }
 112
 113        list_del(&caifd->list);
 114        spin_unlock_bh(&caifdevs->lock);
 115
 116        kfree(caifd);
 117}
 118
 119static int transmit(struct cflayer *layer, struct cfpkt *pkt)
 120{
 121        struct caif_device_entry *caifd =
 122            container_of(layer, struct caif_device_entry, layer);
 123        struct sk_buff *skb, *skb2;
 124        int ret = -EINVAL;
 125        skb = cfpkt_tonative(pkt);
 126        skb->dev = caifd->netdev;
 127        /*
 128         * Don't allow SKB to be destroyed upon error, but signal resend
 129         * notification to clients. We can't rely on the return value as
 130         * congestion (NET_XMIT_CN) sometimes drops the packet, sometimes don't.
 131         */
 132        if (netif_queue_stopped(caifd->netdev))
 133                return -EAGAIN;
 134        skb2 = skb_get(skb);
 135
 136        ret = dev_queue_xmit(skb2);
 137
 138        if (!ret)
 139                kfree_skb(skb);
 140        else
 141                return -EAGAIN;
 142
 143        return 0;
 144}
 145
 146static int modemcmd(struct cflayer *layr, enum caif_modemcmd ctrl)
 147{
 148        struct caif_device_entry *caifd;
 149        struct caif_dev_common *caifdev;
 150        caifd = container_of(layr, struct caif_device_entry, layer);
 151        caifdev = netdev_priv(caifd->netdev);
 152        if (ctrl == _CAIF_MODEMCMD_PHYIF_USEFULL) {
 153                atomic_set(&caifd->in_use, 1);
 154                wake_up_interruptible(&caifd->event);
 155
 156        } else if (ctrl == _CAIF_MODEMCMD_PHYIF_USELESS) {
 157                atomic_set(&caifd->in_use, 0);
 158                wake_up_interruptible(&caifd->event);
 159        }
 160        return 0;
 161}
 162
 163/*
 164 * Stuff received packets to associated sockets.
 165 * On error, returns non-zero and releases the skb.
 166 */
 167static int receive(struct sk_buff *skb, struct net_device *dev,
 168                   struct packet_type *pkttype, struct net_device *orig_dev)
 169{
 170        struct net *net;
 171        struct cfpkt *pkt;
 172        struct caif_device_entry *caifd;
 173        net = dev_net(dev);
 174        pkt = cfpkt_fromnative(CAIF_DIR_IN, skb);
 175        caifd = caif_get(dev);
 176        if (!caifd || !caifd->layer.up || !caifd->layer.up->receive)
 177                return NET_RX_DROP;
 178
 179        if (caifd->layer.up->receive(caifd->layer.up, pkt))
 180                return NET_RX_DROP;
 181
 182        return 0;
 183}
 184
 185static struct packet_type caif_packet_type __read_mostly = {
 186        .type = cpu_to_be16(ETH_P_CAIF),
 187        .func = receive,
 188};
 189
 190static void dev_flowctrl(struct net_device *dev, int on)
 191{
 192        struct caif_device_entry *caifd = caif_get(dev);
 193        if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd)
 194                return;
 195
 196        caifd->layer.up->ctrlcmd(caifd->layer.up,
 197                                 on ?
 198                                 _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND :
 199                                 _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND,
 200                                 caifd->layer.id);
 201}
 202
 203/* notify Caif of device events */
 204static int caif_device_notify(struct notifier_block *me, unsigned long what,
 205                              void *arg)
 206{
 207        struct net_device *dev = arg;
 208        struct caif_device_entry *caifd = NULL;
 209        struct caif_dev_common *caifdev;
 210        enum cfcnfg_phy_preference pref;
 211        int res = -EINVAL;
 212        enum cfcnfg_phy_type phy_type;
 213
 214        if (dev->type != ARPHRD_CAIF)
 215                return 0;
 216
 217        switch (what) {
 218        case NETDEV_REGISTER:
 219                netdev_info(dev, "register\n");
 220                caifd = caif_device_alloc(dev);
 221                if (caifd == NULL)
 222                        break;
 223                caifdev = netdev_priv(dev);
 224                caifdev->flowctrl = dev_flowctrl;
 225                atomic_set(&caifd->state, what);
 226                res = 0;
 227                break;
 228
 229        case NETDEV_UP:
 230                netdev_info(dev, "up\n");
 231                caifd = caif_get(dev);
 232                if (caifd == NULL)
 233                        break;
 234                caifdev = netdev_priv(dev);
 235                if (atomic_read(&caifd->state) == NETDEV_UP) {
 236                        netdev_info(dev, "already up\n");
 237                        break;
 238                }
 239                atomic_set(&caifd->state, what);
 240                caifd->layer.transmit = transmit;
 241                caifd->layer.modemcmd = modemcmd;
 242
 243                if (caifdev->use_frag)
 244                        phy_type = CFPHYTYPE_FRAG;
 245                else
 246                        phy_type = CFPHYTYPE_CAIF;
 247
 248                switch (caifdev->link_select) {
 249                case CAIF_LINK_HIGH_BANDW:
 250                        pref = CFPHYPREF_HIGH_BW;
 251                        break;
 252                case CAIF_LINK_LOW_LATENCY:
 253                        pref = CFPHYPREF_LOW_LAT;
 254                        break;
 255                default:
 256                        pref = CFPHYPREF_HIGH_BW;
 257                        break;
 258                }
 259                dev_hold(dev);
 260                cfcnfg_add_phy_layer(get_caif_conf(),
 261                                     phy_type,
 262                                     dev,
 263                                     &caifd->layer,
 264                                     &caifd->phyid,
 265                                     pref,
 266                                     caifdev->use_fcs,
 267                                     caifdev->use_stx);
 268                strncpy(caifd->layer.name, dev->name,
 269                        sizeof(caifd->layer.name) - 1);
 270                caifd->layer.name[sizeof(caifd->layer.name) - 1] = 0;
 271                break;
 272
 273        case NETDEV_GOING_DOWN:
 274                caifd = caif_get(dev);
 275                if (caifd == NULL)
 276                        break;
 277                netdev_info(dev, "going down\n");
 278
 279                if (atomic_read(&caifd->state) == NETDEV_GOING_DOWN ||
 280                        atomic_read(&caifd->state) == NETDEV_DOWN)
 281                        break;
 282
 283                atomic_set(&caifd->state, what);
 284                if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd)
 285                        return -EINVAL;
 286                caifd->layer.up->ctrlcmd(caifd->layer.up,
 287                                         _CAIF_CTRLCMD_PHYIF_DOWN_IND,
 288                                         caifd->layer.id);
 289                might_sleep();
 290                res = wait_event_interruptible_timeout(caifd->event,
 291                                        atomic_read(&caifd->in_use) == 0,
 292                                        TIMEOUT);
 293                break;
 294
 295        case NETDEV_DOWN:
 296                caifd = caif_get(dev);
 297                if (caifd == NULL)
 298                        break;
 299                netdev_info(dev, "down\n");
 300                if (atomic_read(&caifd->in_use))
 301                        netdev_warn(dev,
 302                                    "Unregistering an active CAIF device\n");
 303                cfcnfg_del_phy_layer(get_caif_conf(), &caifd->layer);
 304                dev_put(dev);
 305                atomic_set(&caifd->state, what);
 306                break;
 307
 308        case NETDEV_UNREGISTER:
 309                caifd = caif_get(dev);
 310                if (caifd == NULL)
 311                        break;
 312                netdev_info(dev, "unregister\n");
 313                atomic_set(&caifd->state, what);
 314                caif_device_destroy(dev);
 315                break;
 316        }
 317        return 0;
 318}
 319
 320static struct notifier_block caif_device_notifier = {
 321        .notifier_call = caif_device_notify,
 322        .priority = 0,
 323};
 324
 325
 326struct cfcnfg *get_caif_conf(void)
 327{
 328        return cfg;
 329}
 330EXPORT_SYMBOL(get_caif_conf);
 331
 332int caif_connect_client(struct caif_connect_request *conn_req,
 333                        struct cflayer *client_layer, int *ifindex,
 334                        int *headroom, int *tailroom)
 335{
 336        struct cfctrl_link_param param;
 337        int ret;
 338        ret = connect_req_to_link_param(get_caif_conf(), conn_req, &param);
 339        if (ret)
 340                return ret;
 341        /* Hook up the adaptation layer. */
 342        return cfcnfg_add_adaptation_layer(get_caif_conf(), &param,
 343                                        client_layer, ifindex,
 344                                        headroom, tailroom);
 345}
 346EXPORT_SYMBOL(caif_connect_client);
 347
 348int caif_disconnect_client(struct cflayer *adap_layer)
 349{
 350       return cfcnfg_disconn_adapt_layer(get_caif_conf(), adap_layer);
 351}
 352EXPORT_SYMBOL(caif_disconnect_client);
 353
 354void caif_release_client(struct cflayer *adap_layer)
 355{
 356       cfcnfg_release_adap_layer(adap_layer);
 357}
 358EXPORT_SYMBOL(caif_release_client);
 359
 360/* Per-namespace Caif devices handling */
 361static int caif_init_net(struct net *net)
 362{
 363        struct caif_net *caifn = net_generic(net, caif_net_id);
 364        INIT_LIST_HEAD(&caifn->caifdevs.list);
 365        spin_lock_init(&caifn->caifdevs.lock);
 366        return 0;
 367}
 368
 369static void caif_exit_net(struct net *net)
 370{
 371        struct net_device *dev;
 372        int res;
 373        rtnl_lock();
 374        for_each_netdev(net, dev) {
 375                if (dev->type != ARPHRD_CAIF)
 376                        continue;
 377                res = dev_close(dev);
 378                caif_device_destroy(dev);
 379        }
 380        rtnl_unlock();
 381}
 382
 383static struct pernet_operations caif_net_ops = {
 384        .init = caif_init_net,
 385        .exit = caif_exit_net,
 386        .id   = &caif_net_id,
 387        .size = sizeof(struct caif_net),
 388};
 389
 390/* Initialize Caif devices list */
 391static int __init caif_device_init(void)
 392{
 393        int result;
 394        cfg = cfcnfg_create();
 395        if (!cfg) {
 396                pr_warn("can't create cfcnfg\n");
 397                goto err_cfcnfg_create_failed;
 398        }
 399        result = register_pernet_device(&caif_net_ops);
 400
 401        if (result) {
 402                kfree(cfg);
 403                cfg = NULL;
 404                return result;
 405        }
 406        dev_add_pack(&caif_packet_type);
 407        register_netdevice_notifier(&caif_device_notifier);
 408
 409        return result;
 410err_cfcnfg_create_failed:
 411        return -ENODEV;
 412}
 413
 414static void __exit caif_device_exit(void)
 415{
 416        dev_remove_pack(&caif_packet_type);
 417        unregister_pernet_device(&caif_net_ops);
 418        unregister_netdevice_notifier(&caif_device_notifier);
 419        cfcnfg_remove(cfg);
 420}
 421
 422module_init(caif_device_init);
 423module_exit(caif_device_exit);
 424