net/mac802154/iface.c

   1 /*
   2  * Copyright 2007-2012 Siemens AG
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * Written by:
  14  * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  15  * Sergey Lapin <slapin@ossfans.org>
  16  * Maxim Gorbachyov <maxim.gorbachev@siemens.com>
  17  * Alexander Smirnov <alex.bluesman.smirnov@gmail.com>
  18  */
  19
  20 #include <linux/netdevice.h>
  21 #include <linux/module.h>
  22 #include <linux/if_arp.h>
  23 #include <linux/ieee802154.h>
  24
  25 #include <net/nl802154.h>
  26 #include <net/mac802154.h>
  27 #include <net/ieee802154_netdev.h>
  28 #include <net/cfg802154.h>
  29
  30 #include "ieee802154_i.h"
  31 #include "driver-ops.h"
  32
  33 int mac802154_wpan_update_llsec(struct net_device *dev)
  34 {
  35         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
  36         struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev);
  37         struct wpan_dev *wpan_dev = &sdata->wpan_dev;
  38         int rc = 0;
  39
  40         if (ops->llsec) {
  41                 struct ieee802154_llsec_params params;
  42                 int changed = 0;
  43
  44                 params.pan_id = wpan_dev->pan_id;
  45                 changed |= IEEE802154_LLSEC_PARAM_PAN_ID;
  46
  47                 params.hwaddr = wpan_dev->extended_addr;
  48                 changed |= IEEE802154_LLSEC_PARAM_HWADDR;
  49
  50                 rc = ops->llsec->set_params(dev, &params, changed);
  51         }
  52
  53         return rc;
  54 }
  55
  56 static int
  57 mac802154_wpan_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  58 {
  59         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
  60         struct wpan_dev *wpan_dev = &sdata->wpan_dev;
  61         struct sockaddr_ieee802154 *sa =
  62                 (struct sockaddr_ieee802154 *)&ifr->ifr_addr;
  63         int err = -ENOIOCTLCMD;
  64
  65         if (cmd != SIOCGIFADDR && cmd != SIOCSIFADDR)
  66                 return err;
  67
  68         rtnl_lock();
  69
  70         switch (cmd) {
  71         case SIOCGIFADDR:
  72         {
  73                 u16 pan_id, short_addr;
  74
  75                 pan_id = le16_to_cpu(wpan_dev->pan_id);
  76                 short_addr = le16_to_cpu(wpan_dev->short_addr);
  77                 if (pan_id == IEEE802154_PANID_BROADCAST ||
  78                     short_addr == IEEE802154_ADDR_BROADCAST) {
  79                         err = -EADDRNOTAVAIL;
  80                         break;
  81                 }
  82
  83                 sa->family = AF_IEEE802154;
  84                 sa->addr.addr_type = IEEE802154_ADDR_SHORT;
  85                 sa->addr.pan_id = pan_id;
  86                 sa->addr.short_addr = short_addr;
  87
  88                 err = 0;
  89                 break;
  90         }
  91         case SIOCSIFADDR:
  92                 if (netif_running(dev)) {
  93                         rtnl_unlock();
  94                         return -EBUSY;
  95                 }
  96
  97                 dev_warn(&dev->dev,
  98                          "Using DEBUGing ioctl SIOCSIFADDR isn't recommended!\n");
  99                 if (sa->family != AF_IEEE802154 ||
 100                     sa->addr.addr_type != IEEE802154_ADDR_SHORT ||
 101                     sa->addr.pan_id == IEEE802154_PANID_BROADCAST ||
 102                     sa->addr.short_addr == IEEE802154_ADDR_BROADCAST ||
 103                     sa->addr.short_addr == IEEE802154_ADDR_UNDEF) {
 104                         err = -EINVAL;
 105                         break;
 106                 }
 107
 108                 wpan_dev->pan_id = cpu_to_le16(sa->addr.pan_id);
 109                 wpan_dev->short_addr = cpu_to_le16(sa->addr.short_addr);
 110
 111                 err = mac802154_wpan_update_llsec(dev);
 112                 break;
 113         }
 114
 115         rtnl_unlock();
 116         return err;
 117 }
 118
 119 static int mac802154_wpan_mac_addr(struct net_device *dev, void *p)
 120 {
 121         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 122         struct sockaddr *addr = p;
 123         __le64 extended_addr;
 124
 125         if (netif_running(dev))
 126                 return -EBUSY;
 127
 128         /* lowpan need to be down for update
 129          * SLAAC address after ifup
 130          */
 131         if (sdata->wpan_dev.lowpan_dev) {
 132                 if (netif_running(sdata->wpan_dev.lowpan_dev))
 133                         return -EBUSY;
 134         }
 135
 136         ieee802154_be64_to_le64(&extended_addr, addr->sa_data);
 137         if (!ieee802154_is_valid_extended_unicast_addr(extended_addr))
 138                 return -EINVAL;
 139
 140         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
 141         sdata->wpan_dev.extended_addr = extended_addr;
 142
 143         /* update lowpan interface mac address when
 144          * wpan mac has been changed
 145          */
 146         if (sdata->wpan_dev.lowpan_dev)
 147                 memcpy(sdata->wpan_dev.lowpan_dev->dev_addr, dev->dev_addr,
 148                        dev->addr_len);
 149
 150         return mac802154_wpan_update_llsec(dev);
 151 }
 152
 153 static int ieee802154_setup_hw(struct ieee802154_sub_if_data *sdata)
 154 {
 155         struct ieee802154_local *local = sdata->local;
 156         struct wpan_dev *wpan_dev = &sdata->wpan_dev;
 157         int ret;
 158
 159         if (local->hw.flags & IEEE802154_HW_PROMISCUOUS) {
 160                 ret = drv_set_promiscuous_mode(local,
 161                                                wpan_dev->promiscuous_mode);
 162                 if (ret < 0)
 163                         return ret;
 164         }
 165
 166         if (local->hw.flags & IEEE802154_HW_AFILT) {
 167                 ret = drv_set_pan_id(local, wpan_dev->pan_id);
 168                 if (ret < 0)
 169                         return ret;
 170
 171                 ret = drv_set_extended_addr(local, wpan_dev->extended_addr);
 172                 if (ret < 0)
 173                         return ret;
 174
 175                 ret = drv_set_short_addr(local, wpan_dev->short_addr);
 176                 if (ret < 0)
 177                         return ret;
 178         }
 179
 180         if (local->hw.flags & IEEE802154_HW_LBT) {
 181                 ret = drv_set_lbt_mode(local, wpan_dev->lbt);
 182                 if (ret < 0)
 183                         return ret;
 184         }
 185
 186         if (local->hw.flags & IEEE802154_HW_CSMA_PARAMS) {
 187                 ret = drv_set_csma_params(local, wpan_dev->min_be,
 188                                           wpan_dev->max_be,
 189                                           wpan_dev->csma_retries);
 190                 if (ret < 0)
 191                         return ret;
 192         }
 193
 194         if (local->hw.flags & IEEE802154_HW_FRAME_RETRIES) {
 195                 ret = drv_set_max_frame_retries(local, wpan_dev->frame_retries);
 196                 if (ret < 0)
 197                         return ret;
 198         }
 199
 200         return 0;
 201 }
 202
 203 static int mac802154_slave_open(struct net_device *dev)
 204 {
 205         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 206         struct ieee802154_local *local = sdata->local;
 207         int res;
 208
 209         ASSERT_RTNL();
 210
 211         set_bit(SDATA_STATE_RUNNING, &sdata->state);
 212
 213         if (!local->open_count) {
 214                 res = ieee802154_setup_hw(sdata);
 215                 if (res)
 216                         goto err;
 217
 218                 res = drv_start(local);
 219                 if (res)
 220                         goto err;
 221         }
 222
 223         local->open_count++;
 224         netif_start_queue(dev);
 225         return 0;
 226 err:
 227         /* might already be clear but that doesn't matter */
 228         clear_bit(SDATA_STATE_RUNNING, &sdata->state);
 229
 230         return res;
 231 }
 232
 233 static int
 234 ieee802154_check_mac_settings(struct ieee802154_local *local,
 235                               struct wpan_dev *wpan_dev,
 236                               struct wpan_dev *nwpan_dev)
 237 {
 238         ASSERT_RTNL();
 239
 240         if (local->hw.flags & IEEE802154_HW_PROMISCUOUS) {
 241                 if (wpan_dev->promiscuous_mode != nwpan_dev->promiscuous_mode)
 242                         return -EBUSY;
 243         }
 244
 245         if (local->hw.flags & IEEE802154_HW_AFILT) {
 246                 if (wpan_dev->pan_id != nwpan_dev->pan_id ||
 247                     wpan_dev->short_addr != nwpan_dev->short_addr ||
 248                     wpan_dev->extended_addr != nwpan_dev->extended_addr)
 249                         return -EBUSY;
 250         }
 251
 252         if (local->hw.flags & IEEE802154_HW_CSMA_PARAMS) {
 253                 if (wpan_dev->min_be != nwpan_dev->min_be ||
 254                     wpan_dev->max_be != nwpan_dev->max_be ||
 255                     wpan_dev->csma_retries != nwpan_dev->csma_retries)
 256                         return -EBUSY;
 257         }
 258
 259         if (local->hw.flags & IEEE802154_HW_FRAME_RETRIES) {
 260                 if (wpan_dev->frame_retries != nwpan_dev->frame_retries)
 261                         return -EBUSY;
 262         }
 263
 264         if (local->hw.flags & IEEE802154_HW_LBT) {
 265                 if (wpan_dev->lbt != nwpan_dev->lbt)
 266                         return -EBUSY;
 267         }
 268
 269         return 0;
 270 }
 271
 272 static int
 273 ieee802154_check_concurrent_iface(struct ieee802154_sub_if_data *sdata,
 274                                   enum nl802154_iftype iftype)
 275 {
 276         struct ieee802154_local *local = sdata->local;
 277         struct wpan_dev *wpan_dev = &sdata->wpan_dev;
 278         struct ieee802154_sub_if_data *nsdata;
 279
 280         /* we hold the RTNL here so can safely walk the list */
 281         list_for_each_entry(nsdata, &local->interfaces, list) {
 282                 if (nsdata != sdata && ieee802154_sdata_running(nsdata)) {
 283                         int ret;
 284
 285                         /* TODO currently we don't support multiple node types
 286                          * we need to run skb_clone at rx path. Check if there
 287                          * exist really an use case if we need to support
 288                          * multiple node types at the same time.
 289                          */
 290                         if (wpan_dev->iftype == NL802154_IFTYPE_NODE &&
 291                             nsdata->wpan_dev.iftype == NL802154_IFTYPE_NODE)
 292                                 return -EBUSY;
 293
 294                         /* check all phy mac sublayer settings are the same.
 295                          * We have only one phy, different values makes trouble.
 296                          */
 297                         ret = ieee802154_check_mac_settings(local, wpan_dev,
 298                                                             &nsdata->wpan_dev);
 299                         if (ret < 0)
 300                                 return ret;
 301                 }
 302         }
 303
 304         return 0;
 305 }
 306
 307 static int mac802154_wpan_open(struct net_device *dev)
 308 {
 309         int rc;
 310         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 311         struct wpan_dev *wpan_dev = &sdata->wpan_dev;
 312
 313         rc = ieee802154_check_concurrent_iface(sdata, wpan_dev->iftype);
 314         if (rc < 0)
 315                 return rc;
 316
 317         return mac802154_slave_open(dev);
 318 }
 319
 320 static int mac802154_slave_close(struct net_device *dev)
 321 {
 322         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 323         struct ieee802154_local *local = sdata->local;
 324
 325         ASSERT_RTNL();
 326
 327         netif_stop_queue(dev);
 328         local->open_count--;
 329
 330         clear_bit(SDATA_STATE_RUNNING, &sdata->state);
 331
 332         if (!local->open_count)
 333                 ieee802154_stop_device(local);
 334
 335         return 0;
 336 }
 337
 338 static int mac802154_set_header_security(struct ieee802154_sub_if_data *sdata,
 339                                          struct ieee802154_hdr *hdr,
 340                                          const struct ieee802154_mac_cb *cb)
 341 {
 342         struct ieee802154_llsec_params params;
 343         u8 level;
 344
 345         mac802154_llsec_get_params(&sdata->sec, &params);
 346
 347         if (!params.enabled && cb->secen_override && cb->secen)
 348                 return -EINVAL;
 349         if (!params.enabled ||
 350             (cb->secen_override && !cb->secen) ||
 351             !params.out_level)
 352                 return 0;
 353         if (cb->seclevel_override && !cb->seclevel)
 354                 return -EINVAL;
 355
 356         level = cb->seclevel_override ? cb->seclevel : params.out_level;
 357
 358         hdr->fc.security_enabled = 1;
 359         hdr->sec.level = level;
 360         hdr->sec.key_id_mode = params.out_key.mode;
 361         if (params.out_key.mode == IEEE802154_SCF_KEY_SHORT_INDEX)
 362                 hdr->sec.short_src = params.out_key.short_source;
 363         else if (params.out_key.mode == IEEE802154_SCF_KEY_HW_INDEX)
 364                 hdr->sec.extended_src = params.out_key.extended_source;
 365         hdr->sec.key_id = params.out_key.id;
 366
 367         return 0;
 368 }
 369
 370 static int ieee802154_header_create(struct sk_buff *skb,
 371                                     struct net_device *dev,
 372                                     const struct ieee802154_addr *daddr,
 373                                     const struct ieee802154_addr *saddr,
 374                                     unsigned len)
 375 {
 376         struct ieee802154_hdr hdr;
 377         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 378         struct wpan_dev *wpan_dev = &sdata->wpan_dev;
 379         struct ieee802154_mac_cb *cb = mac_cb(skb);
 380         int hlen;
 381
 382         if (!daddr)
 383                 return -EINVAL;
 384
 385         memset(&hdr.fc, 0, sizeof(hdr.fc));
 386         hdr.fc.type = cb->type;
 387         hdr.fc.security_enabled = cb->secen;
 388         hdr.fc.ack_request = cb->ackreq;
 389         hdr.seq = atomic_inc_return(&dev->ieee802154_ptr->dsn) & 0xFF;
 390
 391         if (mac802154_set_header_security(sdata, &hdr, cb) < 0)
 392                 return -EINVAL;
 393
 394         if (!saddr) {
 395                 if (wpan_dev->short_addr == cpu_to_le16(IEEE802154_ADDR_BROADCAST) ||
 396                     wpan_dev->short_addr == cpu_to_le16(IEEE802154_ADDR_UNDEF) ||
 397                     wpan_dev->pan_id == cpu_to_le16(IEEE802154_PANID_BROADCAST)) {
 398                         hdr.source.mode = IEEE802154_ADDR_LONG;
 399                         hdr.source.extended_addr = wpan_dev->extended_addr;
 400                 } else {
 401                         hdr.source.mode = IEEE802154_ADDR_SHORT;
 402                         hdr.source.short_addr = wpan_dev->short_addr;
 403                 }
 404
 405                 hdr.source.pan_id = wpan_dev->pan_id;
 406         } else {
 407                 hdr.source = *(const struct ieee802154_addr *)saddr;
 408         }
 409
 410         hdr.dest = *(const struct ieee802154_addr *)daddr;
 411
 412         hlen = ieee802154_hdr_push(skb, &hdr);
 413         if (hlen < 0)
 414                 return -EINVAL;
 415
 416         skb_reset_mac_header(skb);
 417         skb->mac_len = hlen;
 418
 419         if (len > ieee802154_max_payload(&hdr))
 420                 return -EMSGSIZE;
 421
 422         return hlen;
 423 }
 424
 425 static const struct wpan_dev_header_ops ieee802154_header_ops = {
 426         .create         = ieee802154_header_create,
 427 };
 428
 429 /* This header create functionality assumes a 8 byte array for
 430  * source and destination pointer at maximum. To adapt this for
 431  * the 802.15.4 dataframe header we use extended address handling
 432  * here only and intra pan connection. fc fields are mostly fallback
 433  * handling. For provide dev_hard_header for dgram sockets.
 434  */
 435 static int mac802154_header_create(struct sk_buff *skb,
 436                                    struct net_device *dev,
 437                                    unsigned short type,
 438                                    const void *daddr,
 439                                    const void *saddr,
 440                                    unsigned len)
 441 {
 442         struct ieee802154_hdr hdr;
 443         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 444         struct wpan_dev *wpan_dev = &sdata->wpan_dev;
 445         struct ieee802154_mac_cb cb = { };
 446         int hlen;
 447
 448         if (!daddr)
 449                 return -EINVAL;
 450
 451         memset(&hdr.fc, 0, sizeof(hdr.fc));
 452         hdr.fc.type = IEEE802154_FC_TYPE_DATA;
 453         hdr.fc.ack_request = wpan_dev->ackreq;
 454         hdr.seq = atomic_inc_return(&dev->ieee802154_ptr->dsn) & 0xFF;
 455
 456         /* TODO currently a workaround to give zero cb block to set
 457          * security parameters defaults according MIB.
 458          */
 459         if (mac802154_set_header_security(sdata, &hdr, &cb) < 0)
 460                 return -EINVAL;
 461
 462         hdr.dest.pan_id = wpan_dev->pan_id;
 463         hdr.dest.mode = IEEE802154_ADDR_LONG;
 464         ieee802154_be64_to_le64(&hdr.dest.extended_addr, daddr);
 465
 466         hdr.source.pan_id = hdr.dest.pan_id;
 467         hdr.source.mode = IEEE802154_ADDR_LONG;
 468
 469         if (!saddr)
 470                 hdr.source.extended_addr = wpan_dev->extended_addr;
 471         else
 472                 ieee802154_be64_to_le64(&hdr.source.extended_addr, saddr);
 473
 474         hlen = ieee802154_hdr_push(skb, &hdr);
 475         if (hlen < 0)
 476                 return -EINVAL;
 477
 478         skb_reset_mac_header(skb);
 479         skb->mac_len = hlen;
 480
 481         if (len > ieee802154_max_payload(&hdr))
 482                 return -EMSGSIZE;
 483
 484         return hlen;
 485 }
 486
 487 static int
 488 mac802154_header_parse(const struct sk_buff *skb, unsigned char *haddr)
 489 {
 490         struct ieee802154_hdr hdr;
 491
 492         if (ieee802154_hdr_peek_addrs(skb, &hdr) < 0) {
 493                 pr_debug("malformed packet\n");
 494                 return 0;
 495         }
 496
 497         if (hdr.source.mode == IEEE802154_ADDR_LONG) {
 498                 ieee802154_le64_to_be64(haddr, &hdr.source.extended_addr);
 499                 return IEEE802154_EXTENDED_ADDR_LEN;
 500         }
 501
 502         return 0;
 503 }
 504
 505 static const struct header_ops mac802154_header_ops = {
 506         .create         = mac802154_header_create,
 507         .parse          = mac802154_header_parse,
 508 };
 509
 510 static const struct net_device_ops mac802154_wpan_ops = {
 511         .ndo_open               = mac802154_wpan_open,
 512         .ndo_stop               = mac802154_slave_close,
 513         .ndo_start_xmit         = ieee802154_subif_start_xmit,
 514         .ndo_do_ioctl           = mac802154_wpan_ioctl,
 515         .ndo_set_mac_address    = mac802154_wpan_mac_addr,
 516 };
 517
 518 static const struct net_device_ops mac802154_monitor_ops = {
 519         .ndo_open               = mac802154_wpan_open,
 520         .ndo_stop               = mac802154_slave_close,
 521         .ndo_start_xmit         = ieee802154_monitor_start_xmit,
 522 };
 523
 524 static void mac802154_wpan_free(struct net_device *dev)
 525 {
 526         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 527
 528         mac802154_llsec_destroy(&sdata->sec);
 529
 530         free_netdev(dev);
 531 }
 532
 533 static void ieee802154_if_setup(struct net_device *dev)
 534 {
 535         dev->addr_len           = IEEE802154_EXTENDED_ADDR_LEN;
 536         memset(dev->broadcast, 0xff, IEEE802154_EXTENDED_ADDR_LEN);
 537
 538         /* Let hard_header_len set to IEEE802154_MIN_HEADER_LEN. AF_PACKET
 539          * will not send frames without any payload, but ack frames
 540          * has no payload, so substract one that we can send a 3 bytes
 541          * frame. The xmit callback assumes at least a hard header where two
 542          * bytes fc and sequence field are set.
 543          */
 544         dev->hard_header_len    = IEEE802154_MIN_HEADER_LEN - 1;
 545         /* The auth_tag header is for security and places in private payload
 546          * room of mac frame which stucks between payload and FCS field.
 547          */
 548         dev->needed_tailroom    = IEEE802154_MAX_AUTH_TAG_LEN +
 549                                   IEEE802154_FCS_LEN;
 550         /* The mtu size is the payload without mac header in this case.
 551          * We have a dynamic length header with a minimum header length
 552          * which is hard_header_len. In this case we let mtu to the size
 553          * of maximum payload which is IEEE802154_MTU - IEEE802154_FCS_LEN -
 554          * hard_header_len. The FCS which is set by hardware or ndo_start_xmit
 555          * and the minimum mac header which can be evaluated inside driver
 556          * layer. The rest of mac header will be part of payload if greater
 557          * than hard_header_len.
 558          */
 559         dev->mtu                = IEEE802154_MTU - IEEE802154_FCS_LEN -
 560                                   dev->hard_header_len;
 561         dev->tx_queue_len       = 300;
 562         dev->flags              = IFF_NOARP | IFF_BROADCAST;
 563 }
 564
 565 static int
 566 ieee802154_setup_sdata(struct ieee802154_sub_if_data *sdata,
 567                        enum nl802154_iftype type)
 568 {
 569         struct wpan_dev *wpan_dev = &sdata->wpan_dev;
 570         int ret;
 571         u8 tmp;
 572
 573         /* set some type-dependent values */
 574         sdata->wpan_dev.iftype = type;
 575
 576         get_random_bytes(&tmp, sizeof(tmp));
 577         atomic_set(&wpan_dev->bsn, tmp);
 578         get_random_bytes(&tmp, sizeof(tmp));
 579         atomic_set(&wpan_dev->dsn, tmp);
 580
 581         /* defaults per 802.15.4-2011 */
 582         wpan_dev->min_be = 3;
 583         wpan_dev->max_be = 5;
 584         wpan_dev->csma_retries = 4;
 585         wpan_dev->frame_retries = 3;
 586
 587         wpan_dev->pan_id = cpu_to_le16(IEEE802154_PANID_BROADCAST);
 588         wpan_dev->short_addr = cpu_to_le16(IEEE802154_ADDR_BROADCAST);
 589
 590         switch (type) {
 591         case NL802154_IFTYPE_NODE:
 592                 ieee802154_be64_to_le64(&wpan_dev->extended_addr,
 593                                         sdata->dev->dev_addr);
 594
 595                 sdata->dev->header_ops = &mac802154_header_ops;
 596                 sdata->dev->destructor = mac802154_wpan_free;
 597                 sdata->dev->netdev_ops = &mac802154_wpan_ops;
 598                 sdata->dev->ml_priv = &mac802154_mlme_wpan;
 599                 wpan_dev->promiscuous_mode = false;
 600                 wpan_dev->header_ops = &ieee802154_header_ops;
 601
 602                 mutex_init(&sdata->sec_mtx);
 603
 604                 mac802154_llsec_init(&sdata->sec);
 605                 ret = mac802154_wpan_update_llsec(sdata->dev);
 606                 if (ret < 0)
 607                         return ret;
 608
 609                 break;
 610         case NL802154_IFTYPE_MONITOR:
 611                 sdata->dev->destructor = free_netdev;
 612                 sdata->dev->netdev_ops = &mac802154_monitor_ops;
 613                 wpan_dev->promiscuous_mode = true;
 614                 break;
 615         default:
 616                 BUG();
 617         }
 618
 619         return 0;
 620 }
 621
 622 struct net_device *
 623 ieee802154_if_add(struct ieee802154_local *local, const char *name,
 624                   unsigned char name_assign_type, enum nl802154_iftype type,
 625                   __le64 extended_addr)
 626 {
 627         struct net_device *ndev = NULL;
 628         struct ieee802154_sub_if_data *sdata = NULL;
 629         int ret = -ENOMEM;
 630
 631         ASSERT_RTNL();
 632
 633         ndev = alloc_netdev(sizeof(*sdata), name,
 634                             name_assign_type, ieee802154_if_setup);
 635         if (!ndev)
 636                 return ERR_PTR(-ENOMEM);
 637
 638         ndev->needed_headroom = local->hw.extra_tx_headroom +
 639                                 IEEE802154_MAX_HEADER_LEN;
 640
 641         ret = dev_alloc_name(ndev, ndev->name);
 642         if (ret < 0)
 643                 goto err;
 644
 645         ieee802154_le64_to_be64(ndev->perm_addr,
 646                                 &local->hw.phy->perm_extended_addr);
 647         switch (type) {
 648         case NL802154_IFTYPE_NODE:
 649                 ndev->type = ARPHRD_IEEE802154;
 650                 if (ieee802154_is_valid_extended_unicast_addr(extended_addr))
 651                         ieee802154_le64_to_be64(ndev->dev_addr, &extended_addr);
 652                 else
 653                         memcpy(ndev->dev_addr, ndev->perm_addr,
 654                                IEEE802154_EXTENDED_ADDR_LEN);
 655                 break;
 656         case NL802154_IFTYPE_MONITOR:
 657                 ndev->type = ARPHRD_IEEE802154_MONITOR;
 658                 break;
 659         default:
 660                 ret = -EINVAL;
 661                 goto err;
 662         }
 663
 664         /* TODO check this */
 665         SET_NETDEV_DEV(ndev, &local->phy->dev);
 666         sdata = netdev_priv(ndev);
 667         ndev->ieee802154_ptr = &sdata->wpan_dev;
 668         memcpy(sdata->name, ndev->name, IFNAMSIZ);
 669         sdata->dev = ndev;
 670         sdata->wpan_dev.wpan_phy = local->hw.phy;
 671         sdata->local = local;
 672
 673         /* setup type-dependent data */
 674         ret = ieee802154_setup_sdata(sdata, type);
 675         if (ret)
 676                 goto err;
 677
 678         ret = register_netdevice(ndev);
 679         if (ret < 0)
 680                 goto err;
 681
 682         mutex_lock(&local->iflist_mtx);
 683         list_add_tail_rcu(&sdata->list, &local->interfaces);
 684         mutex_unlock(&local->iflist_mtx);
 685
 686         return ndev;
 687
 688 err:
 689         free_netdev(ndev);
 690         return ERR_PTR(ret);
 691 }
 692
 693 void ieee802154_if_remove(struct ieee802154_sub_if_data *sdata)
 694 {
 695         ASSERT_RTNL();
 696
 697         mutex_lock(&sdata->local->iflist_mtx);
 698         list_del_rcu(&sdata->list);
 699         mutex_unlock(&sdata->local->iflist_mtx);
 700
 701         synchronize_rcu();
 702         unregister_netdevice(sdata->dev);
 703 }
 704
 705 void ieee802154_remove_interfaces(struct ieee802154_local *local)
 706 {
 707         struct ieee802154_sub_if_data *sdata, *tmp;
 708
 709         mutex_lock(&local->iflist_mtx);
 710         list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
 711                 list_del(&sdata->list);
 712
 713                 unregister_netdevice(sdata->dev);
 714         }
 715         mutex_unlock(&local->iflist_mtx);
 716 }
 717
 718 static int netdev_notify(struct notifier_block *nb,
 719                          unsigned long state, void *ptr)
 720 {
 721         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 722         struct ieee802154_sub_if_data *sdata;
 723
 724         if (state != NETDEV_CHANGENAME)
 725                 return NOTIFY_DONE;
 726
 727         if (!dev->ieee802154_ptr || !dev->ieee802154_ptr->wpan_phy)
 728                 return NOTIFY_DONE;
 729
 730         if (dev->ieee802154_ptr->wpan_phy->privid != mac802154_wpan_phy_privid)
 731                 return NOTIFY_DONE;
 732
 733         sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 734         memcpy(sdata->name, dev->name, IFNAMSIZ);
 735
 736         return NOTIFY_OK;
 737 }
 738
 739 static struct notifier_block mac802154_netdev_notifier = {
 740         .notifier_call = netdev_notify,
 741 };
 742
 743 int ieee802154_iface_init(void)
 744 {
 745         return register_netdevice_notifier(&mac802154_netdev_notifier);
 746 }
 747
 748 void ieee802154_iface_exit(void)
 749 {
 750         unregister_netdevice_notifier(&mac802154_netdev_notifier);
 751 }