net/caif/cfcnfg.c

   1 /*
   2  * Copyright (C) ST-Ericsson AB 2010
   3  * Author:      Sjur Brendeland/sjur.brandeland@stericsson.com
   4  * License terms: GNU General Public License (GPL) version 2
   5  */
   6
   7 #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__
   8
   9 #include <linux/kernel.h>
  10 #include <linux/stddef.h>
  11 #include <linux/slab.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/module.h>
  14 #include <net/caif/caif_layer.h>
  15 #include <net/caif/cfpkt.h>
  16 #include <net/caif/cfcnfg.h>
  17 #include <net/caif/cfctrl.h>
  18 #include <net/caif/cfmuxl.h>
  19 #include <net/caif/cffrml.h>
  20 #include <net/caif/cfserl.h>
  21 #include <net/caif/cfsrvl.h>
  22 #include <net/caif/caif_dev.h>
  23
  24 #define container_obj(layr) container_of(layr, struct cfcnfg, layer)
  25
  26 /* Information about CAIF physical interfaces held by Config Module in order
  27  * to manage physical interfaces
  28  */
  29 struct cfcnfg_phyinfo {
  30         struct list_head node;
  31         bool up;
  32
  33         /* Pointer to the layer below the MUX (framing layer) */
  34         struct cflayer *frm_layer;
  35         /* Pointer to the lowest actual physical layer */
  36         struct cflayer *phy_layer;
  37         /* Unique identifier of the physical interface */
  38         unsigned int id;
  39         /* Preference of the physical in interface */
  40         enum cfcnfg_phy_preference pref;
  41
  42         /* Information about the physical device */
  43         struct dev_info dev_info;
  44
  45         /* Interface index */
  46         int ifindex;
  47
  48         /* Protocol head room added for CAIF link layer */
  49         int head_room;
  50
  51         /* Use Start of frame checksum */
  52         bool use_fcs;
  53 };
  54
  55 struct cfcnfg {
  56         struct cflayer layer;
  57         struct cflayer *ctrl;
  58         struct cflayer *mux;
  59         struct list_head phys;
  60         struct mutex lock;
  61 };
  62
  63 static void cfcnfg_linkup_rsp(struct cflayer *layer, u8 channel_id,
  64                              enum cfctrl_srv serv, u8 phyid,
  65                              struct cflayer *adapt_layer);
  66 static void cfcnfg_linkdestroy_rsp(struct cflayer *layer, u8 channel_id);
  67 static void cfcnfg_reject_rsp(struct cflayer *layer, u8 channel_id,
  68                              struct cflayer *adapt_layer);
  69 static void cfctrl_resp_func(void);
  70 static void cfctrl_enum_resp(void);
  71
  72 struct cfcnfg *cfcnfg_create(void)
  73 {
  74         struct cfcnfg *this;
  75         struct cfctrl_rsp *resp;
  76
  77         might_sleep();
  78
  79         /* Initiate this layer */
  80         this = kzalloc(sizeof(struct cfcnfg), GFP_ATOMIC);
  81         if (!this)
  82                 return NULL;
  83         this->mux = cfmuxl_create();
  84         if (!this->mux)
  85                 goto out_of_mem;
  86         this->ctrl = cfctrl_create();
  87         if (!this->ctrl)
  88                 goto out_of_mem;
  89         /* Initiate response functions */
  90         resp = cfctrl_get_respfuncs(this->ctrl);
  91         resp->enum_rsp = cfctrl_enum_resp;
  92         resp->linkerror_ind = cfctrl_resp_func;
  93         resp->linkdestroy_rsp = cfcnfg_linkdestroy_rsp;
  94         resp->sleep_rsp = cfctrl_resp_func;
  95         resp->wake_rsp = cfctrl_resp_func;
  96         resp->restart_rsp = cfctrl_resp_func;
  97         resp->radioset_rsp = cfctrl_resp_func;
  98         resp->linksetup_rsp = cfcnfg_linkup_rsp;
  99         resp->reject_rsp = cfcnfg_reject_rsp;
 100         INIT_LIST_HEAD(&this->phys);
 101
 102         cfmuxl_set_uplayer(this->mux, this->ctrl, 0);
 103         layer_set_dn(this->ctrl, this->mux);
 104         layer_set_up(this->ctrl, this);
 105         mutex_init(&this->lock);
 106
 107         return this;
 108 out_of_mem:
 109         synchronize_rcu();
 110
 111         kfree(this->mux);
 112         kfree(this->ctrl);
 113         kfree(this);
 114         return NULL;
 115 }
 116
 117 void cfcnfg_remove(struct cfcnfg *cfg)
 118 {
 119         might_sleep();
 120         if (cfg) {
 121                 synchronize_rcu();
 122
 123                 kfree(cfg->mux);
 124                 cfctrl_remove(cfg->ctrl);
 125                 kfree(cfg);
 126         }
 127 }
 128
 129 static void cfctrl_resp_func(void)
 130 {
 131 }
 132
 133 static struct cfcnfg_phyinfo *cfcnfg_get_phyinfo_rcu(struct cfcnfg *cnfg,
 134                                                         u8 phyid)
 135 {
 136         struct cfcnfg_phyinfo *phy;
 137
 138         list_for_each_entry_rcu(phy, &cnfg->phys, node)
 139                 if (phy->id == phyid)
 140                         return phy;
 141         return NULL;
 142 }
 143
 144 static void cfctrl_enum_resp(void)
 145 {
 146 }
 147
 148 static struct dev_info *cfcnfg_get_phyid(struct cfcnfg *cnfg,
 149                                   enum cfcnfg_phy_preference phy_pref)
 150 {
 151         /* Try to match with specified preference */
 152         struct cfcnfg_phyinfo *phy;
 153
 154         list_for_each_entry_rcu(phy, &cnfg->phys, node) {
 155                 if (phy->up && phy->pref == phy_pref &&
 156                                 phy->frm_layer != NULL)
 157
 158                         return &phy->dev_info;
 159         }
 160
 161         /* Otherwise just return something */
 162         list_for_each_entry_rcu(phy, &cnfg->phys, node)
 163                 if (phy->up)
 164                         return &phy->dev_info;
 165
 166         return NULL;
 167 }
 168
 169 static int cfcnfg_get_id_from_ifi(struct cfcnfg *cnfg, int ifi)
 170 {
 171         struct cfcnfg_phyinfo *phy;
 172
 173         list_for_each_entry_rcu(phy, &cnfg->phys, node)
 174                 if (phy->ifindex == ifi && phy->up)
 175                         return phy->id;
 176         return -ENODEV;
 177 }
 178
 179 int caif_disconnect_client(struct net *net, struct cflayer *adap_layer)
 180 {
 181         u8 channel_id;
 182         struct cfcnfg *cfg = get_cfcnfg(net);
 183
 184         caif_assert(adap_layer != NULL);
 185         cfctrl_cancel_req(cfg->ctrl, adap_layer);
 186         channel_id = adap_layer->id;
 187         if (channel_id != 0) {
 188                 struct cflayer *servl;
 189                 servl = cfmuxl_remove_uplayer(cfg->mux, channel_id);
 190                 cfctrl_linkdown_req(cfg->ctrl, channel_id, adap_layer);
 191                 if (servl != NULL)
 192                         layer_set_up(servl, NULL);
 193         } else
 194                 pr_debug("nothing to disconnect\n");
 195
 196         /* Do RCU sync before initiating cleanup */
 197         synchronize_rcu();
 198         if (adap_layer->ctrlcmd != NULL)
 199                 adap_layer->ctrlcmd(adap_layer, CAIF_CTRLCMD_DEINIT_RSP, 0);
 200         return 0;
 201
 202 }
 203 EXPORT_SYMBOL(caif_disconnect_client);
 204
 205 static void cfcnfg_linkdestroy_rsp(struct cflayer *layer, u8 channel_id)
 206 {
 207 }
 208
 209 static const int protohead[CFCTRL_SRV_MASK] = {
 210         [CFCTRL_SRV_VEI] = 4,
 211         [CFCTRL_SRV_DATAGRAM] = 7,
 212         [CFCTRL_SRV_UTIL] = 4,
 213         [CFCTRL_SRV_RFM] = 3,
 214         [CFCTRL_SRV_DBG] = 3,
 215 };
 216
 217
 218 static int caif_connect_req_to_link_param(struct cfcnfg *cnfg,
 219                                    struct caif_connect_request *s,
 220                                    struct cfctrl_link_param *l)
 221 {
 222         struct dev_info *dev_info;
 223         enum cfcnfg_phy_preference pref;
 224         int res;
 225
 226         memset(l, 0, sizeof(*l));
 227         /* In caif protocol low value is high priority */
 228         l->priority = CAIF_PRIO_MAX - s->priority + 1;
 229
 230         if (s->ifindex != 0) {
 231                 res = cfcnfg_get_id_from_ifi(cnfg, s->ifindex);
 232                 if (res < 0)
 233                         return res;
 234                 l->phyid = res;
 235         } else {
 236                 switch (s->link_selector) {
 237                 case CAIF_LINK_HIGH_BANDW:
 238                         pref = CFPHYPREF_HIGH_BW;
 239                         break;
 240                 case CAIF_LINK_LOW_LATENCY:
 241                         pref = CFPHYPREF_LOW_LAT;
 242                         break;
 243                 default:
 244                         return -EINVAL;
 245                 }
 246                 dev_info = cfcnfg_get_phyid(cnfg, pref);
 247                 if (dev_info == NULL)
 248                         return -ENODEV;
 249                 l->phyid = dev_info->id;
 250         }
 251         switch (s->protocol) {
 252         case CAIFPROTO_AT:
 253                 l->linktype = CFCTRL_SRV_VEI;
 254                 l->endpoint = (s->sockaddr.u.at.type >> 2) & 0x3;
 255                 l->chtype = s->sockaddr.u.at.type & 0x3;
 256                 break;
 257         case CAIFPROTO_DATAGRAM:
 258                 l->linktype = CFCTRL_SRV_DATAGRAM;
 259                 l->chtype = 0x00;
 260                 l->u.datagram.connid = s->sockaddr.u.dgm.connection_id;
 261                 break;
 262         case CAIFPROTO_DATAGRAM_LOOP:
 263                 l->linktype = CFCTRL_SRV_DATAGRAM;
 264                 l->chtype = 0x03;
 265                 l->endpoint = 0x00;
 266                 l->u.datagram.connid = s->sockaddr.u.dgm.connection_id;
 267                 break;
 268         case CAIFPROTO_RFM:
 269                 l->linktype = CFCTRL_SRV_RFM;
 270                 l->u.datagram.connid = s->sockaddr.u.rfm.connection_id;
 271                 strncpy(l->u.rfm.volume, s->sockaddr.u.rfm.volume,
 272                         sizeof(l->u.rfm.volume)-1);
 273                 l->u.rfm.volume[sizeof(l->u.rfm.volume)-1] = 0;
 274                 break;
 275         case CAIFPROTO_UTIL:
 276                 l->linktype = CFCTRL_SRV_UTIL;
 277                 l->endpoint = 0x00;
 278                 l->chtype = 0x00;
 279                 strncpy(l->u.utility.name, s->sockaddr.u.util.service,
 280                         sizeof(l->u.utility.name)-1);
 281                 l->u.utility.name[sizeof(l->u.utility.name)-1] = 0;
 282                 caif_assert(sizeof(l->u.utility.name) > 10);
 283                 l->u.utility.paramlen = s->param.size;
 284                 if (l->u.utility.paramlen > sizeof(l->u.utility.params))
 285                         l->u.utility.paramlen = sizeof(l->u.utility.params);
 286
 287                 memcpy(l->u.utility.params, s->param.data,
 288                        l->u.utility.paramlen);
 289
 290                 break;
 291         case CAIFPROTO_DEBUG:
 292                 l->linktype = CFCTRL_SRV_DBG;
 293                 l->endpoint = s->sockaddr.u.dbg.service;
 294                 l->chtype = s->sockaddr.u.dbg.type;
 295                 break;
 296         default:
 297                 return -EINVAL;
 298         }
 299         return 0;
 300 }
 301
 302 int caif_connect_client(struct net *net, struct caif_connect_request *conn_req,
 303                         struct cflayer *adap_layer, int *ifindex,
 304                                 int *proto_head,
 305                                 int *proto_tail)
 306 {
 307         struct cflayer *frml;
 308         struct cfcnfg_phyinfo *phy;
 309         int err;
 310         struct cfctrl_link_param param;
 311         struct cfcnfg *cfg = get_cfcnfg(net);
 312         caif_assert(cfg != NULL);
 313
 314         rcu_read_lock();
 315         err = caif_connect_req_to_link_param(cfg, conn_req, &param);
 316         if (err)
 317                 goto unlock;
 318
 319         phy = cfcnfg_get_phyinfo_rcu(cfg, param.phyid);
 320         if (!phy) {
 321                 err = -ENODEV;
 322                 goto unlock;
 323         }
 324         err = -EINVAL;
 325
 326         if (adap_layer == NULL) {
 327                 pr_err("adap_layer is zero\n");
 328                 goto unlock;
 329         }
 330         if (adap_layer->receive == NULL) {
 331                 pr_err("adap_layer->receive is NULL\n");
 332                 goto unlock;
 333         }
 334         if (adap_layer->ctrlcmd == NULL) {
 335                 pr_err("adap_layer->ctrlcmd == NULL\n");
 336                 goto unlock;
 337         }
 338
 339         err = -ENODEV;
 340         frml = phy->frm_layer;
 341         if (frml == NULL) {
 342                 pr_err("Specified PHY type does not exist!\n");
 343                 goto unlock;
 344         }
 345         caif_assert(param.phyid == phy->id);
 346         caif_assert(phy->frm_layer->id ==
 347                      param.phyid);
 348         caif_assert(phy->phy_layer->id ==
 349                      param.phyid);
 350
 351         *ifindex = phy->ifindex;
 352         *proto_tail = 2;
 353         *proto_head = protohead[param.linktype] + phy->head_room;
 354
 355         rcu_read_unlock();
 356
 357         /* FIXME: ENUMERATE INITIALLY WHEN ACTIVATING PHYSICAL INTERFACE */
 358         cfctrl_enum_req(cfg->ctrl, param.phyid);
 359         return cfctrl_linkup_request(cfg->ctrl, &param, adap_layer);
 360
 361 unlock:
 362         rcu_read_unlock();
 363         return err;
 364 }
 365 EXPORT_SYMBOL(caif_connect_client);
 366
 367 static void cfcnfg_reject_rsp(struct cflayer *layer, u8 channel_id,
 368                              struct cflayer *adapt_layer)
 369 {
 370         if (adapt_layer != NULL && adapt_layer->ctrlcmd != NULL)
 371                 adapt_layer->ctrlcmd(adapt_layer,
 372                                      CAIF_CTRLCMD_INIT_FAIL_RSP, 0);
 373 }
 374
 375 static void
 376 cfcnfg_linkup_rsp(struct cflayer *layer, u8 channel_id, enum cfctrl_srv serv,
 377                   u8 phyid, struct cflayer *adapt_layer)
 378 {
 379         struct cfcnfg *cnfg = container_obj(layer);
 380         struct cflayer *servicel = NULL;
 381         struct cfcnfg_phyinfo *phyinfo;
 382         struct net_device *netdev;
 383
 384         if (channel_id == 0) {
 385                 pr_warn("received channel_id zero\n");
 386                 if (adapt_layer != NULL && adapt_layer->ctrlcmd != NULL)
 387                         adapt_layer->ctrlcmd(adapt_layer,
 388                                                 CAIF_CTRLCMD_INIT_FAIL_RSP, 0);
 389                 return;
 390         }
 391
 392         rcu_read_lock();
 393
 394         if (adapt_layer == NULL) {
 395                 pr_debug("link setup response but no client exist,"
 396                                 "send linkdown back\n");
 397                 cfctrl_linkdown_req(cnfg->ctrl, channel_id, NULL);
 398                 goto unlock;
 399         }
 400
 401         caif_assert(cnfg != NULL);
 402         caif_assert(phyid != 0);
 403
 404         phyinfo = cfcnfg_get_phyinfo_rcu(cnfg, phyid);
 405         if (phyinfo == NULL) {
 406                 pr_err("ERROR: Link Layer Device dissapeared"
 407                                 "while connecting\n");
 408                 goto unlock;
 409         }
 410
 411         caif_assert(phyinfo != NULL);
 412         caif_assert(phyinfo->id == phyid);
 413         caif_assert(phyinfo->phy_layer != NULL);
 414         caif_assert(phyinfo->phy_layer->id == phyid);
 415
 416         adapt_layer->id = channel_id;
 417
 418         switch (serv) {
 419         case CFCTRL_SRV_VEI:
 420                 servicel = cfvei_create(channel_id, &phyinfo->dev_info);
 421                 break;
 422         case CFCTRL_SRV_DATAGRAM:
 423                 servicel = cfdgml_create(channel_id,
 424                                         &phyinfo->dev_info);
 425                 break;
 426         case CFCTRL_SRV_RFM:
 427                 netdev = phyinfo->dev_info.dev;
 428                 servicel = cfrfml_create(channel_id, &phyinfo->dev_info,
 429                                                 netdev->mtu);
 430                 break;
 431         case CFCTRL_SRV_UTIL:
 432                 servicel = cfutill_create(channel_id, &phyinfo->dev_info);
 433                 break;
 434         case CFCTRL_SRV_VIDEO:
 435                 servicel = cfvidl_create(channel_id, &phyinfo->dev_info);
 436                 break;
 437         case CFCTRL_SRV_DBG:
 438                 servicel = cfdbgl_create(channel_id, &phyinfo->dev_info);
 439                 break;
 440         default:
 441                 pr_err("Protocol error. Link setup response "
 442                                 "- unknown channel type\n");
 443                 goto unlock;
 444         }
 445         if (!servicel)
 446                 goto unlock;
 447         layer_set_dn(servicel, cnfg->mux);
 448         cfmuxl_set_uplayer(cnfg->mux, servicel, channel_id);
 449         layer_set_up(servicel, adapt_layer);
 450         layer_set_dn(adapt_layer, servicel);
 451
 452         rcu_read_unlock();
 453
 454         servicel->ctrlcmd(servicel, CAIF_CTRLCMD_INIT_RSP, 0);
 455         return;
 456 unlock:
 457         rcu_read_unlock();
 458 }
 459
 460 void
 461 cfcnfg_add_phy_layer(struct cfcnfg *cnfg,
 462                      struct net_device *dev, struct cflayer *phy_layer,
 463                      enum cfcnfg_phy_preference pref,
 464                      struct cflayer *link_support,
 465                      bool fcs, int head_room)
 466 {
 467         struct cflayer *frml;
 468         struct cfcnfg_phyinfo *phyinfo = NULL;
 469         int i;
 470         u8 phyid;
 471
 472         mutex_lock(&cnfg->lock);
 473
 474         /* CAIF protocol allow maximum 6 link-layers */
 475         for (i = 0; i < 7; i++) {
 476                 phyid = (dev->ifindex + i) & 0x7;
 477                 if (phyid == 0)
 478                         continue;
 479                 if (cfcnfg_get_phyinfo_rcu(cnfg, phyid) == NULL)
 480                         goto got_phyid;
 481         }
 482         pr_warn("Too many CAIF Link Layers (max 6)\n");
 483         goto out;
 484
 485 got_phyid:
 486         phyinfo = kzalloc(sizeof(struct cfcnfg_phyinfo), GFP_ATOMIC);
 487         if (!phyinfo)
 488                 goto out_err;
 489
 490         phy_layer->id = phyid;
 491         phyinfo->pref = pref;
 492         phyinfo->id = phyid;
 493         phyinfo->dev_info.id = phyid;
 494         phyinfo->dev_info.dev = dev;
 495         phyinfo->phy_layer = phy_layer;
 496         phyinfo->ifindex = dev->ifindex;
 497         phyinfo->head_room = head_room;
 498         phyinfo->use_fcs = fcs;
 499
 500         frml = cffrml_create(phyid, fcs);
 501
 502         if (!frml)
 503                 goto out_err;
 504         phyinfo->frm_layer = frml;
 505         layer_set_up(frml, cnfg->mux);
 506
 507         if (link_support != NULL) {
 508                 link_support->id = phyid;
 509                 layer_set_dn(frml, link_support);
 510                 layer_set_up(link_support, frml);
 511                 layer_set_dn(link_support, phy_layer);
 512                 layer_set_up(phy_layer, link_support);
 513         } else {
 514                 layer_set_dn(frml, phy_layer);
 515                 layer_set_up(phy_layer, frml);
 516         }
 517
 518         list_add_rcu(&phyinfo->node, &cnfg->phys);
 519 out:
 520         mutex_unlock(&cnfg->lock);
 521         return;
 522
 523 out_err:
 524         kfree(phyinfo);
 525         mutex_unlock(&cnfg->lock);
 526 }
 527 EXPORT_SYMBOL(cfcnfg_add_phy_layer);
 528
 529 int cfcnfg_set_phy_state(struct cfcnfg *cnfg, struct cflayer *phy_layer,
 530                 bool up)
 531 {
 532         struct cfcnfg_phyinfo *phyinfo;
 533
 534         rcu_read_lock();
 535         phyinfo = cfcnfg_get_phyinfo_rcu(cnfg, phy_layer->id);
 536         if (phyinfo == NULL) {
 537                 rcu_read_unlock();
 538                 return -ENODEV;
 539         }
 540
 541         if (phyinfo->up == up) {
 542                 rcu_read_unlock();
 543                 return 0;
 544         }
 545         phyinfo->up = up;
 546
 547         if (up) {
 548                 cffrml_hold(phyinfo->frm_layer);
 549                 cfmuxl_set_dnlayer(cnfg->mux, phyinfo->frm_layer,
 550                                         phy_layer->id);
 551         } else {
 552                 cfmuxl_remove_dnlayer(cnfg->mux, phy_layer->id);
 553                 cffrml_put(phyinfo->frm_layer);
 554         }
 555
 556         rcu_read_unlock();
 557         return 0;
 558 }
 559 EXPORT_SYMBOL(cfcnfg_set_phy_state);
 560
 561 int cfcnfg_del_phy_layer(struct cfcnfg *cnfg, struct cflayer *phy_layer)
 562 {
 563         struct cflayer *frml, *frml_dn;
 564         u16 phyid;
 565         struct cfcnfg_phyinfo *phyinfo;
 566
 567         might_sleep();
 568
 569         mutex_lock(&cnfg->lock);
 570
 571         phyid = phy_layer->id;
 572         phyinfo = cfcnfg_get_phyinfo_rcu(cnfg, phyid);
 573
 574         if (phyinfo == NULL) {
 575                 mutex_unlock(&cnfg->lock);
 576                 return 0;
 577         }
 578         caif_assert(phyid == phyinfo->id);
 579         caif_assert(phy_layer == phyinfo->phy_layer);
 580         caif_assert(phy_layer->id == phyid);
 581         caif_assert(phyinfo->frm_layer->id == phyid);
 582
 583         list_del_rcu(&phyinfo->node);
 584         synchronize_rcu();
 585
 586         /* Fail if reference count is not zero */
 587         if (cffrml_refcnt_read(phyinfo->frm_layer) != 0) {
 588                 pr_info("Wait for device inuse\n");
 589                 list_add_rcu(&phyinfo->node, &cnfg->phys);
 590                 mutex_unlock(&cnfg->lock);
 591                 return -EAGAIN;
 592         }
 593
 594         frml = phyinfo->frm_layer;
 595         frml_dn = frml->dn;
 596         cffrml_set_uplayer(frml, NULL);
 597         cffrml_set_dnlayer(frml, NULL);
 598         if (phy_layer != frml_dn) {
 599                 layer_set_up(frml_dn, NULL);
 600                 layer_set_dn(frml_dn, NULL);
 601         }
 602         layer_set_up(phy_layer, NULL);
 603
 604         if (phyinfo->phy_layer != frml_dn)
 605                 kfree(frml_dn);
 606
 607         cffrml_free(frml);
 608         kfree(phyinfo);
 609         mutex_unlock(&cnfg->lock);
 610
 611         return 0;
 612 }
 613 EXPORT_SYMBOL(cfcnfg_del_phy_layer);