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, ¶ms, 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, ¶ms); 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 } 752