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