net/wireless/core.c

   1 /*
   2  * This is the linux wireless configuration interface.
   3  *
   4  * Copyright 2006-2010          Johannes Berg <johannes@sipsolutions.net>
   5  * Copyright 2013-2014  Intel Mobile Communications GmbH
   6  * Copyright 2015       Intel Deutschland GmbH
   7  */
   8
   9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11 #include <linux/if.h>
  12 #include <linux/module.h>
  13 #include <linux/err.h>
  14 #include <linux/list.h>
  15 #include <linux/slab.h>
  16 #include <linux/nl80211.h>
  17 #include <linux/debugfs.h>
  18 #include <linux/notifier.h>
  19 #include <linux/device.h>
  20 #include <linux/etherdevice.h>
  21 #include <linux/rtnetlink.h>
  22 #include <linux/sched.h>
  23 #include <net/genetlink.h>
  24 #include <net/cfg80211.h>
  25 #include "nl80211.h"
  26 #include "core.h"
  27 #include "sysfs.h"
  28 #include "debugfs.h"
  29 #include "wext-compat.h"
  30 #include "rdev-ops.h"
  31
  32 /* name for sysfs, %d is appended */
  33 #define PHY_NAME "phy"
  34
  35 MODULE_AUTHOR("Johannes Berg");
  36 MODULE_LICENSE("GPL");
  37 MODULE_DESCRIPTION("wireless configuration support");
  38 MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME);
  39
  40 /* RCU-protected (and RTNL for writers) */
  41 LIST_HEAD(cfg80211_rdev_list);
  42 int cfg80211_rdev_list_generation;
  43
  44 /* for debugfs */
  45 static struct dentry *ieee80211_debugfs_dir;
  46
  47 /* for the cleanup, scan and event works */
  48 struct workqueue_struct *cfg80211_wq;
  49
  50 static bool cfg80211_disable_40mhz_24ghz;
  51 module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
  52 MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
  53                  "Disable 40MHz support in the 2.4GHz band");
  54
  55 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
  56 {
  57         struct cfg80211_registered_device *result = NULL, *rdev;
  58
  59         ASSERT_RTNL();
  60
  61         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
  62                 if (rdev->wiphy_idx == wiphy_idx) {
  63                         result = rdev;
  64                         break;
  65                 }
  66         }
  67
  68         return result;
  69 }
  70
  71 int get_wiphy_idx(struct wiphy *wiphy)
  72 {
  73         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  74
  75         return rdev->wiphy_idx;
  76 }
  77
  78 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
  79 {
  80         struct cfg80211_registered_device *rdev;
  81
  82         ASSERT_RTNL();
  83
  84         rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
  85         if (!rdev)
  86                 return NULL;
  87         return &rdev->wiphy;
  88 }
  89
  90 static int cfg80211_dev_check_name(struct cfg80211_registered_device *rdev,
  91                                    const char *newname)
  92 {
  93         struct cfg80211_registered_device *rdev2;
  94         int wiphy_idx, taken = -1, digits;
  95
  96         ASSERT_RTNL();
  97
  98         /* prohibit calling the thing phy%d when %d is not its number */
  99         sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
 100         if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
 101                 /* count number of places needed to print wiphy_idx */
 102                 digits = 1;
 103                 while (wiphy_idx /= 10)
 104                         digits++;
 105                 /*
 106                  * deny the name if it is phy<idx> where <idx> is printed
 107                  * without leading zeroes. taken == strlen(newname) here
 108                  */
 109                 if (taken == strlen(PHY_NAME) + digits)
 110                         return -EINVAL;
 111         }
 112
 113         /* Ensure another device does not already have this name. */
 114         list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
 115                 if (strcmp(newname, wiphy_name(&rdev2->wiphy)) == 0)
 116                         return -EINVAL;
 117
 118         return 0;
 119 }
 120
 121 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
 122                         char *newname)
 123 {
 124         int result;
 125
 126         ASSERT_RTNL();
 127
 128         /* Ignore nop renames */
 129         if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
 130                 return 0;
 131
 132         result = cfg80211_dev_check_name(rdev, newname);
 133         if (result < 0)
 134                 return result;
 135
 136         result = device_rename(&rdev->wiphy.dev, newname);
 137         if (result)
 138                 return result;
 139
 140         if (rdev->wiphy.debugfsdir &&
 141             !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
 142                             rdev->wiphy.debugfsdir,
 143                             rdev->wiphy.debugfsdir->d_parent,
 144                             newname))
 145                 pr_err("failed to rename debugfs dir to %s!\n", newname);
 146
 147         nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
 148
 149         return 0;
 150 }
 151
 152 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
 153                           struct net *net)
 154 {
 155         struct wireless_dev *wdev;
 156         int err = 0;
 157
 158         if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
 159                 return -EOPNOTSUPP;
 160
 161         list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
 162                 if (!wdev->netdev)
 163                         continue;
 164                 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
 165                 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
 166                 if (err)
 167                         break;
 168                 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
 169         }
 170
 171         if (err) {
 172                 /* failed -- clean up to old netns */
 173                 net = wiphy_net(&rdev->wiphy);
 174
 175                 list_for_each_entry_continue_reverse(wdev,
 176                                                      &rdev->wiphy.wdev_list,
 177                                                      list) {
 178                         if (!wdev->netdev)
 179                                 continue;
 180                         wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
 181                         err = dev_change_net_namespace(wdev->netdev, net,
 182                                                         "wlan%d");
 183                         WARN_ON(err);
 184                         wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
 185                 }
 186
 187                 return err;
 188         }
 189
 190         wiphy_net_set(&rdev->wiphy, net);
 191
 192         err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
 193         WARN_ON(err);
 194
 195         return 0;
 196 }
 197
 198 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
 199 {
 200         struct cfg80211_registered_device *rdev = data;
 201
 202         rdev_rfkill_poll(rdev);
 203 }
 204
 205 void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
 206                               struct wireless_dev *wdev)
 207 {
 208         ASSERT_RTNL();
 209
 210         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
 211                 return;
 212
 213         if (!wdev_running(wdev))
 214                 return;
 215
 216         rdev_stop_p2p_device(rdev, wdev);
 217         wdev->is_running = false;
 218
 219         rdev->opencount--;
 220
 221         if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
 222                 if (WARN_ON(!rdev->scan_req->notified))
 223                         rdev->scan_req->info.aborted = true;
 224                 ___cfg80211_scan_done(rdev, false);
 225         }
 226 }
 227
 228 void cfg80211_stop_nan(struct cfg80211_registered_device *rdev,
 229                        struct wireless_dev *wdev)
 230 {
 231         ASSERT_RTNL();
 232
 233         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_NAN))
 234                 return;
 235
 236         if (!wdev_running(wdev))
 237                 return;
 238
 239         rdev_stop_nan(rdev, wdev);
 240         wdev->is_running = false;
 241
 242         rdev->opencount--;
 243 }
 244
 245 void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy)
 246 {
 247         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 248         struct wireless_dev *wdev;
 249
 250         ASSERT_RTNL();
 251
 252         list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
 253                 if (wdev->netdev) {
 254                         dev_close(wdev->netdev);
 255                         continue;
 256                 }
 257                 /* otherwise, check iftype */
 258                 switch (wdev->iftype) {
 259                 case NL80211_IFTYPE_P2P_DEVICE:
 260                         cfg80211_stop_p2p_device(rdev, wdev);
 261                         break;
 262                 case NL80211_IFTYPE_NAN:
 263                         cfg80211_stop_nan(rdev, wdev);
 264                         break;
 265                 default:
 266                         break;
 267                 }
 268         }
 269 }
 270 EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces);
 271
 272 static int cfg80211_rfkill_set_block(void *data, bool blocked)
 273 {
 274         struct cfg80211_registered_device *rdev = data;
 275
 276         if (!blocked)
 277                 return 0;
 278
 279         rtnl_lock();
 280         cfg80211_shutdown_all_interfaces(&rdev->wiphy);
 281         rtnl_unlock();
 282
 283         return 0;
 284 }
 285
 286 static void cfg80211_rfkill_sync_work(struct work_struct *work)
 287 {
 288         struct cfg80211_registered_device *rdev;
 289
 290         rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
 291         cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
 292 }
 293
 294 static void cfg80211_event_work(struct work_struct *work)
 295 {
 296         struct cfg80211_registered_device *rdev;
 297
 298         rdev = container_of(work, struct cfg80211_registered_device,
 299                             event_work);
 300
 301         rtnl_lock();
 302         cfg80211_process_rdev_events(rdev);
 303         rtnl_unlock();
 304 }
 305
 306 void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev)
 307 {
 308         struct wireless_dev *wdev, *tmp;
 309
 310         ASSERT_RTNL();
 311
 312         list_for_each_entry_safe(wdev, tmp, &rdev->wiphy.wdev_list, list) {
 313                 if (wdev->nl_owner_dead)
 314                         rdev_del_virtual_intf(rdev, wdev);
 315         }
 316 }
 317
 318 static void cfg80211_destroy_iface_wk(struct work_struct *work)
 319 {
 320         struct cfg80211_registered_device *rdev;
 321
 322         rdev = container_of(work, struct cfg80211_registered_device,
 323                             destroy_work);
 324
 325         rtnl_lock();
 326         cfg80211_destroy_ifaces(rdev);
 327         rtnl_unlock();
 328 }
 329
 330 static void cfg80211_sched_scan_stop_wk(struct work_struct *work)
 331 {
 332         struct cfg80211_registered_device *rdev;
 333
 334         rdev = container_of(work, struct cfg80211_registered_device,
 335                            sched_scan_stop_wk);
 336
 337         rtnl_lock();
 338
 339         __cfg80211_stop_sched_scan(rdev, false);
 340
 341         rtnl_unlock();
 342 }
 343
 344 static void cfg80211_propagate_radar_detect_wk(struct work_struct *work)
 345 {
 346         struct cfg80211_registered_device *rdev;
 347
 348         rdev = container_of(work, struct cfg80211_registered_device,
 349                             propagate_radar_detect_wk);
 350
 351         rtnl_lock();
 352
 353         regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->radar_chandef,
 354                                        NL80211_DFS_UNAVAILABLE,
 355                                        NL80211_RADAR_DETECTED);
 356
 357         rtnl_unlock();
 358 }
 359
 360 static void cfg80211_propagate_cac_done_wk(struct work_struct *work)
 361 {
 362         struct cfg80211_registered_device *rdev;
 363
 364         rdev = container_of(work, struct cfg80211_registered_device,
 365                             propagate_cac_done_wk);
 366
 367         rtnl_lock();
 368
 369         regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->cac_done_chandef,
 370                                        NL80211_DFS_AVAILABLE,
 371                                        NL80211_RADAR_CAC_FINISHED);
 372
 373         rtnl_unlock();
 374 }
 375
 376 /* exported functions */
 377
 378 struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
 379                            const char *requested_name)
 380 {
 381         static atomic_t wiphy_counter = ATOMIC_INIT(0);
 382
 383         struct cfg80211_registered_device *rdev;
 384         int alloc_size;
 385
 386         WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
 387         WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
 388         WARN_ON(ops->connect && !ops->disconnect);
 389         WARN_ON(ops->join_ibss && !ops->leave_ibss);
 390         WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
 391         WARN_ON(ops->add_station && !ops->del_station);
 392         WARN_ON(ops->add_mpath && !ops->del_mpath);
 393         WARN_ON(ops->join_mesh && !ops->leave_mesh);
 394         WARN_ON(ops->start_p2p_device && !ops->stop_p2p_device);
 395         WARN_ON(ops->start_ap && !ops->stop_ap);
 396         WARN_ON(ops->join_ocb && !ops->leave_ocb);
 397         WARN_ON(ops->suspend && !ops->resume);
 398         WARN_ON(ops->sched_scan_start && !ops->sched_scan_stop);
 399         WARN_ON(ops->remain_on_channel && !ops->cancel_remain_on_channel);
 400         WARN_ON(ops->tdls_channel_switch && !ops->tdls_cancel_channel_switch);
 401         WARN_ON(ops->add_tx_ts && !ops->del_tx_ts);
 402
 403         alloc_size = sizeof(*rdev) + sizeof_priv;
 404
 405         rdev = kzalloc(alloc_size, GFP_KERNEL);
 406         if (!rdev)
 407                 return NULL;
 408
 409         rdev->ops = ops;
 410
 411         rdev->wiphy_idx = atomic_inc_return(&wiphy_counter);
 412
 413         if (unlikely(rdev->wiphy_idx < 0)) {
 414                 /* ugh, wrapped! */
 415                 atomic_dec(&wiphy_counter);
 416                 kfree(rdev);
 417                 return NULL;
 418         }
 419
 420         /* atomic_inc_return makes it start at 1, make it start at 0 */
 421         rdev->wiphy_idx--;
 422
 423         /* give it a proper name */
 424         if (requested_name && requested_name[0]) {
 425                 int rv;
 426
 427                 rtnl_lock();
 428                 rv = cfg80211_dev_check_name(rdev, requested_name);
 429
 430                 if (rv < 0) {
 431                         rtnl_unlock();
 432                         goto use_default_name;
 433                 }
 434
 435                 rv = dev_set_name(&rdev->wiphy.dev, "%s", requested_name);
 436                 rtnl_unlock();
 437                 if (rv)
 438                         goto use_default_name;
 439         } else {
 440 use_default_name:
 441                 /* NOTE:  This is *probably* safe w/out holding rtnl because of
 442                  * the restrictions on phy names.  Probably this call could
 443                  * fail if some other part of the kernel (re)named a device
 444                  * phyX.  But, might should add some locking and check return
 445                  * value, and use a different name if this one exists?
 446                  */
 447                 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
 448         }
 449
 450         INIT_LIST_HEAD(&rdev->wiphy.wdev_list);
 451         INIT_LIST_HEAD(&rdev->beacon_registrations);
 452         spin_lock_init(&rdev->beacon_registrations_lock);
 453         spin_lock_init(&rdev->bss_lock);
 454         INIT_LIST_HEAD(&rdev->bss_list);
 455         INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
 456         INIT_WORK(&rdev->sched_scan_results_wk, __cfg80211_sched_scan_results);
 457         INIT_LIST_HEAD(&rdev->mlme_unreg);
 458         spin_lock_init(&rdev->mlme_unreg_lock);
 459         INIT_WORK(&rdev->mlme_unreg_wk, cfg80211_mlme_unreg_wk);
 460         INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
 461                           cfg80211_dfs_channels_update_work);
 462 #ifdef CONFIG_CFG80211_WEXT
 463         rdev->wiphy.wext = &cfg80211_wext_handler;
 464 #endif
 465
 466         device_initialize(&rdev->wiphy.dev);
 467         rdev->wiphy.dev.class = &ieee80211_class;
 468         rdev->wiphy.dev.platform_data = rdev;
 469         device_enable_async_suspend(&rdev->wiphy.dev);
 470
 471         INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);
 472         INIT_WORK(&rdev->sched_scan_stop_wk, cfg80211_sched_scan_stop_wk);
 473         INIT_WORK(&rdev->propagate_radar_detect_wk,
 474                   cfg80211_propagate_radar_detect_wk);
 475         INIT_WORK(&rdev->propagate_cac_done_wk, cfg80211_propagate_cac_done_wk);
 476
 477 #ifdef CONFIG_CFG80211_DEFAULT_PS
 478         rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
 479 #endif
 480
 481         wiphy_net_set(&rdev->wiphy, &init_net);
 482
 483         rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
 484         rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
 485                                    &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
 486                                    &rdev->rfkill_ops, rdev);
 487
 488         if (!rdev->rfkill) {
 489                 kfree(rdev);
 490                 return NULL;
 491         }
 492
 493         INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
 494         INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
 495         INIT_WORK(&rdev->event_work, cfg80211_event_work);
 496
 497         init_waitqueue_head(&rdev->dev_wait);
 498
 499         /*
 500          * Initialize wiphy parameters to IEEE 802.11 MIB default values.
 501          * Fragmentation and RTS threshold are disabled by default with the
 502          * special -1 value.
 503          */
 504         rdev->wiphy.retry_short = 7;
 505         rdev->wiphy.retry_long = 4;
 506         rdev->wiphy.frag_threshold = (u32) -1;
 507         rdev->wiphy.rts_threshold = (u32) -1;
 508         rdev->wiphy.coverage_class = 0;
 509
 510         rdev->wiphy.max_num_csa_counters = 1;
 511
 512         rdev->wiphy.max_sched_scan_plans = 1;
 513         rdev->wiphy.max_sched_scan_plan_interval = U32_MAX;
 514
 515         return &rdev->wiphy;
 516 }
 517 EXPORT_SYMBOL(wiphy_new_nm);
 518
 519 static int wiphy_verify_combinations(struct wiphy *wiphy)
 520 {
 521         const struct ieee80211_iface_combination *c;
 522         int i, j;
 523
 524         for (i = 0; i < wiphy->n_iface_combinations; i++) {
 525                 u32 cnt = 0;
 526                 u16 all_iftypes = 0;
 527
 528                 c = &wiphy->iface_combinations[i];
 529
 530                 /*
 531                  * Combinations with just one interface aren't real,
 532                  * however we make an exception for DFS.
 533                  */
 534                 if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
 535                         return -EINVAL;
 536
 537                 /* Need at least one channel */
 538                 if (WARN_ON(!c->num_different_channels))
 539                         return -EINVAL;
 540
 541                 /*
 542                  * Put a sane limit on maximum number of different
 543                  * channels to simplify channel accounting code.
 544                  */
 545                 if (WARN_ON(c->num_different_channels >
 546                                 CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
 547                         return -EINVAL;
 548
 549                 /* DFS only works on one channel. */
 550                 if (WARN_ON(c->radar_detect_widths &&
 551                             (c->num_different_channels > 1)))
 552                         return -EINVAL;
 553
 554                 if (WARN_ON(!c->n_limits))
 555                         return -EINVAL;
 556
 557                 for (j = 0; j < c->n_limits; j++) {
 558                         u16 types = c->limits[j].types;
 559
 560                         /* interface types shouldn't overlap */
 561                         if (WARN_ON(types & all_iftypes))
 562                                 return -EINVAL;
 563                         all_iftypes |= types;
 564
 565                         if (WARN_ON(!c->limits[j].max))
 566                                 return -EINVAL;
 567
 568                         /* Shouldn't list software iftypes in combinations! */
 569                         if (WARN_ON(wiphy->software_iftypes & types))
 570                                 return -EINVAL;
 571
 572                         /* Only a single P2P_DEVICE can be allowed */
 573                         if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
 574                                     c->limits[j].max > 1))
 575                                 return -EINVAL;
 576
 577                         /* Only a single NAN can be allowed */
 578                         if (WARN_ON(types & BIT(NL80211_IFTYPE_NAN) &&
 579                                     c->limits[j].max > 1))
 580                                 return -EINVAL;
 581
 582                         /*
 583                          * This isn't well-defined right now. If you have an
 584                          * IBSS interface, then its beacon interval may change
 585                          * by joining other networks, and nothing prevents it
 586                          * from doing that.
 587                          * So technically we probably shouldn't even allow AP
 588                          * and IBSS in the same interface, but it seems that
 589                          * some drivers support that, possibly only with fixed
 590                          * beacon intervals for IBSS.
 591                          */
 592                         if (WARN_ON(types & BIT(NL80211_IFTYPE_ADHOC) &&
 593                                     c->beacon_int_min_gcd)) {
 594                                 return -EINVAL;
 595                         }
 596
 597                         cnt += c->limits[j].max;
 598                         /*
 599                          * Don't advertise an unsupported type
 600                          * in a combination.
 601                          */
 602                         if (WARN_ON((wiphy->interface_modes & types) != types))
 603                                 return -EINVAL;
 604                 }
 605
 606 #ifndef CONFIG_WIRELESS_WDS
 607                 if (WARN_ON(all_iftypes & BIT(NL80211_IFTYPE_WDS)))
 608                         return -EINVAL;
 609 #endif
 610
 611                 /* You can't even choose that many! */
 612                 if (WARN_ON(cnt < c->max_interfaces))
 613                         return -EINVAL;
 614         }
 615
 616         return 0;
 617 }
 618
 619 int wiphy_register(struct wiphy *wiphy)
 620 {
 621         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 622         int res;
 623         enum nl80211_band band;
 624         struct ieee80211_supported_band *sband;
 625         bool have_band = false;
 626         int i;
 627         u16 ifmodes = wiphy->interface_modes;
 628
 629 #ifdef CONFIG_PM
 630         if (WARN_ON(wiphy->wowlan &&
 631                     (wiphy->wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
 632                     !(wiphy->wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
 633                 return -EINVAL;
 634         if (WARN_ON(wiphy->wowlan &&
 635                     !wiphy->wowlan->flags && !wiphy->wowlan->n_patterns &&
 636                     !wiphy->wowlan->tcp))
 637                 return -EINVAL;
 638 #endif
 639         if (WARN_ON((wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
 640                     (!rdev->ops->tdls_channel_switch ||
 641                      !rdev->ops->tdls_cancel_channel_switch)))
 642                 return -EINVAL;
 643
 644         if (WARN_ON((wiphy->interface_modes & BIT(NL80211_IFTYPE_NAN)) &&
 645                     (!rdev->ops->start_nan || !rdev->ops->stop_nan ||
 646                      !rdev->ops->add_nan_func || !rdev->ops->del_nan_func ||
 647                      !(wiphy->nan_supported_bands & BIT(NL80211_BAND_2GHZ)))))
 648                 return -EINVAL;
 649
 650 #ifndef CONFIG_WIRELESS_WDS
 651         if (WARN_ON(wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS)))
 652                 return -EINVAL;
 653 #endif
 654
 655         /*
 656          * if a wiphy has unsupported modes for regulatory channel enforcement,
 657          * opt-out of enforcement checking
 658          */
 659         if (wiphy->interface_modes & ~(BIT(NL80211_IFTYPE_STATION) |
 660                                        BIT(NL80211_IFTYPE_P2P_CLIENT) |
 661                                        BIT(NL80211_IFTYPE_AP) |
 662                                        BIT(NL80211_IFTYPE_P2P_GO) |
 663                                        BIT(NL80211_IFTYPE_ADHOC) |
 664                                        BIT(NL80211_IFTYPE_P2P_DEVICE) |
 665                                        BIT(NL80211_IFTYPE_NAN) |
 666                                        BIT(NL80211_IFTYPE_AP_VLAN) |
 667                                        BIT(NL80211_IFTYPE_MONITOR)))
 668                 wiphy->regulatory_flags |= REGULATORY_IGNORE_STALE_KICKOFF;
 669
 670         if (WARN_ON((wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) &&
 671                     (wiphy->regulatory_flags &
 672                                         (REGULATORY_CUSTOM_REG |
 673                                          REGULATORY_STRICT_REG |
 674                                          REGULATORY_COUNTRY_IE_FOLLOW_POWER |
 675                                          REGULATORY_COUNTRY_IE_IGNORE))))
 676                 return -EINVAL;
 677
 678         if (WARN_ON(wiphy->coalesce &&
 679                     (!wiphy->coalesce->n_rules ||
 680                      !wiphy->coalesce->n_patterns) &&
 681                     (!wiphy->coalesce->pattern_min_len ||
 682                      wiphy->coalesce->pattern_min_len >
 683                         wiphy->coalesce->pattern_max_len)))
 684                 return -EINVAL;
 685
 686         if (WARN_ON(wiphy->ap_sme_capa &&
 687                     !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
 688                 return -EINVAL;
 689
 690         if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
 691                 return -EINVAL;
 692
 693         if (WARN_ON(wiphy->addresses &&
 694                     !is_zero_ether_addr(wiphy->perm_addr) &&
 695                     memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
 696                            ETH_ALEN)))
 697                 return -EINVAL;
 698
 699         if (WARN_ON(wiphy->max_acl_mac_addrs &&
 700                     (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
 701                      !rdev->ops->set_mac_acl)))
 702                 return -EINVAL;
 703
 704         /* assure only valid behaviours are flagged by driver
 705          * hence subtract 2 as bit 0 is invalid.
 706          */
 707         if (WARN_ON(wiphy->bss_select_support &&
 708                     (wiphy->bss_select_support & ~(BIT(__NL80211_BSS_SELECT_ATTR_AFTER_LAST) - 2))))
 709                 return -EINVAL;
 710
 711         if (wiphy->addresses)
 712                 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
 713
 714         /* sanity check ifmodes */
 715         WARN_ON(!ifmodes);
 716         ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
 717         if (WARN_ON(ifmodes != wiphy->interface_modes))
 718                 wiphy->interface_modes = ifmodes;
 719
 720         res = wiphy_verify_combinations(wiphy);
 721         if (res)
 722                 return res;
 723
 724         /* sanity check supported bands/channels */
 725         for (band = 0; band < NUM_NL80211_BANDS; band++) {
 726                 sband = wiphy->bands[band];
 727                 if (!sband)
 728                         continue;
 729
 730                 sband->band = band;
 731                 if (WARN_ON(!sband->n_channels))
 732                         return -EINVAL;
 733                 /*
 734                  * on 60GHz band, there are no legacy rates, so
 735                  * n_bitrates is 0
 736                  */
 737                 if (WARN_ON(band != NL80211_BAND_60GHZ &&
 738                             !sband->n_bitrates))
 739                         return -EINVAL;
 740
 741                 /*
 742                  * Since cfg80211_disable_40mhz_24ghz is global, we can
 743                  * modify the sband's ht data even if the driver uses a
 744                  * global structure for that.
 745                  */
 746                 if (cfg80211_disable_40mhz_24ghz &&
 747                     band == NL80211_BAND_2GHZ &&
 748                     sband->ht_cap.ht_supported) {
 749                         sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
 750                         sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
 751                 }
 752
 753                 /*
 754                  * Since we use a u32 for rate bitmaps in
 755                  * ieee80211_get_response_rate, we cannot
 756                  * have more than 32 legacy rates.
 757                  */
 758                 if (WARN_ON(sband->n_bitrates > 32))
 759                         return -EINVAL;
 760
 761                 for (i = 0; i < sband->n_channels; i++) {
 762                         sband->channels[i].orig_flags =
 763                                 sband->channels[i].flags;
 764                         sband->channels[i].orig_mag = INT_MAX;
 765                         sband->channels[i].orig_mpwr =
 766                                 sband->channels[i].max_power;
 767                         sband->channels[i].band = band;
 768                 }
 769
 770                 have_band = true;
 771         }
 772
 773         if (!have_band) {
 774                 WARN_ON(1);
 775                 return -EINVAL;
 776         }
 777
 778 #ifdef CONFIG_PM
 779         if (WARN_ON(rdev->wiphy.wowlan && rdev->wiphy.wowlan->n_patterns &&
 780                     (!rdev->wiphy.wowlan->pattern_min_len ||
 781                      rdev->wiphy.wowlan->pattern_min_len >
 782                                 rdev->wiphy.wowlan->pattern_max_len)))
 783                 return -EINVAL;
 784 #endif
 785
 786         /* check and set up bitrates */
 787         ieee80211_set_bitrate_flags(wiphy);
 788
 789         rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
 790
 791         rtnl_lock();
 792         res = device_add(&rdev->wiphy.dev);
 793         if (res) {
 794                 rtnl_unlock();
 795                 return res;
 796         }
 797
 798         /* set up regulatory info */
 799         wiphy_regulatory_register(wiphy);
 800
 801         list_add_rcu(&rdev->list, &cfg80211_rdev_list);
 802         cfg80211_rdev_list_generation++;
 803
 804         /* add to debugfs */
 805         rdev->wiphy.debugfsdir =
 806                 debugfs_create_dir(wiphy_name(&rdev->wiphy),
 807                                    ieee80211_debugfs_dir);
 808         if (IS_ERR(rdev->wiphy.debugfsdir))
 809                 rdev->wiphy.debugfsdir = NULL;
 810
 811         cfg80211_debugfs_rdev_add(rdev);
 812         nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
 813
 814         if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
 815                 struct regulatory_request request;
 816
 817                 request.wiphy_idx = get_wiphy_idx(wiphy);
 818                 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
 819                 request.alpha2[0] = '9';
 820                 request.alpha2[1] = '9';
 821
 822                 nl80211_send_reg_change_event(&request);
 823         }
 824
 825         /* Check that nobody globally advertises any capabilities they do not
 826          * advertise on all possible interface types.
 827          */
 828         if (wiphy->extended_capabilities_len &&
 829             wiphy->num_iftype_ext_capab &&
 830             wiphy->iftype_ext_capab) {
 831                 u8 supported_on_all, j;
 832                 const struct wiphy_iftype_ext_capab *capab;
 833
 834                 capab = wiphy->iftype_ext_capab;
 835                 for (j = 0; j < wiphy->extended_capabilities_len; j++) {
 836                         if (capab[0].extended_capabilities_len > j)
 837                                 supported_on_all =
 838                                         capab[0].extended_capabilities[j];
 839                         else
 840                                 supported_on_all = 0x00;
 841                         for (i = 1; i < wiphy->num_iftype_ext_capab; i++) {
 842                                 if (j >= capab[i].extended_capabilities_len) {
 843                                         supported_on_all = 0x00;
 844                                         break;
 845                                 }
 846                                 supported_on_all &=
 847                                         capab[i].extended_capabilities[j];
 848                         }
 849                         if (WARN_ON(wiphy->extended_capabilities[j] &
 850                                     ~supported_on_all))
 851                                 break;
 852                 }
 853         }
 854
 855         rdev->wiphy.registered = true;
 856         rtnl_unlock();
 857
 858         res = rfkill_register(rdev->rfkill);
 859         if (res) {
 860                 rfkill_destroy(rdev->rfkill);
 861                 rdev->rfkill = NULL;
 862                 wiphy_unregister(&rdev->wiphy);
 863                 return res;
 864         }
 865
 866         return 0;
 867 }
 868 EXPORT_SYMBOL(wiphy_register);
 869
 870 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
 871 {
 872         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 873
 874         if (!rdev->ops->rfkill_poll)
 875                 return;
 876         rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
 877         rfkill_resume_polling(rdev->rfkill);
 878 }
 879 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
 880
 881 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
 882 {
 883         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 884
 885         rfkill_pause_polling(rdev->rfkill);
 886 }
 887 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
 888
 889 void wiphy_unregister(struct wiphy *wiphy)
 890 {
 891         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 892
 893         wait_event(rdev->dev_wait, ({
 894                 int __count;
 895                 rtnl_lock();
 896                 __count = rdev->opencount;
 897                 rtnl_unlock();
 898                 __count == 0; }));
 899
 900         if (rdev->rfkill)
 901                 rfkill_unregister(rdev->rfkill);
 902
 903         rtnl_lock();
 904         nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
 905         rdev->wiphy.registered = false;
 906
 907         WARN_ON(!list_empty(&rdev->wiphy.wdev_list));
 908
 909         /*
 910          * First remove the hardware from everywhere, this makes
 911          * it impossible to find from userspace.
 912          */
 913         debugfs_remove_recursive(rdev->wiphy.debugfsdir);
 914         list_del_rcu(&rdev->list);
 915         synchronize_rcu();
 916
 917         /*
 918          * If this device got a regulatory hint tell core its
 919          * free to listen now to a new shiny device regulatory hint
 920          */
 921         wiphy_regulatory_deregister(wiphy);
 922
 923         cfg80211_rdev_list_generation++;
 924         device_del(&rdev->wiphy.dev);
 925
 926         rtnl_unlock();
 927
 928         flush_work(&rdev->scan_done_wk);
 929         cancel_work_sync(&rdev->conn_work);
 930         flush_work(&rdev->event_work);
 931         cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
 932         flush_work(&rdev->destroy_work);
 933         flush_work(&rdev->sched_scan_stop_wk);
 934         flush_work(&rdev->mlme_unreg_wk);
 935         flush_work(&rdev->propagate_radar_detect_wk);
 936         flush_work(&rdev->propagate_cac_done_wk);
 937
 938 #ifdef CONFIG_PM
 939         if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
 940                 rdev_set_wakeup(rdev, false);
 941 #endif
 942         cfg80211_rdev_free_wowlan(rdev);
 943         cfg80211_rdev_free_coalesce(rdev);
 944 }
 945 EXPORT_SYMBOL(wiphy_unregister);
 946
 947 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
 948 {
 949         struct cfg80211_internal_bss *scan, *tmp;
 950         struct cfg80211_beacon_registration *reg, *treg;
 951         rfkill_destroy(rdev->rfkill);
 952         list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
 953                 list_del(&reg->list);
 954                 kfree(reg);
 955         }
 956         list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
 957                 cfg80211_put_bss(&rdev->wiphy, &scan->pub);
 958         kfree(rdev);
 959 }
 960
 961 void wiphy_free(struct wiphy *wiphy)
 962 {
 963         put_device(&wiphy->dev);
 964 }
 965 EXPORT_SYMBOL(wiphy_free);
 966
 967 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
 968 {
 969         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 970
 971         if (rfkill_set_hw_state(rdev->rfkill, blocked))
 972                 schedule_work(&rdev->rfkill_sync);
 973 }
 974 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
 975
 976 void cfg80211_cqm_config_free(struct wireless_dev *wdev)
 977 {
 978         kfree(wdev->cqm_config);
 979         wdev->cqm_config = NULL;
 980 }
 981
 982 void cfg80211_unregister_wdev(struct wireless_dev *wdev)
 983 {
 984         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 985
 986         ASSERT_RTNL();
 987
 988         if (WARN_ON(wdev->netdev))
 989                 return;
 990
 991         nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
 992
 993         list_del_rcu(&wdev->list);
 994         rdev->devlist_generation++;
 995
 996         switch (wdev->iftype) {
 997         case NL80211_IFTYPE_P2P_DEVICE:
 998                 cfg80211_mlme_purge_registrations(wdev);
 999                 cfg80211_stop_p2p_device(rdev, wdev);
1000                 break;
1001         case NL80211_IFTYPE_NAN:
1002                 cfg80211_stop_nan(rdev, wdev);
1003                 break;
1004         default:
1005                 WARN_ON_ONCE(1);
1006                 break;
1007         }
1008
1009         cfg80211_cqm_config_free(wdev);
1010 }
1011 EXPORT_SYMBOL(cfg80211_unregister_wdev);
1012
1013 static const struct device_type wiphy_type = {
1014         .name   = "wlan",
1015 };
1016
1017 void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
1018                                enum nl80211_iftype iftype, int num)
1019 {
1020         ASSERT_RTNL();
1021
1022         rdev->num_running_ifaces += num;
1023         if (iftype == NL80211_IFTYPE_MONITOR)
1024                 rdev->num_running_monitor_ifaces += num;
1025 }
1026
1027 void __cfg80211_leave(struct cfg80211_registered_device *rdev,
1028                       struct wireless_dev *wdev)
1029 {
1030         struct net_device *dev = wdev->netdev;
1031         struct cfg80211_sched_scan_request *sched_scan_req;
1032
1033         ASSERT_RTNL();
1034         ASSERT_WDEV_LOCK(wdev);
1035
1036         switch (wdev->iftype) {
1037         case NL80211_IFTYPE_ADHOC:
1038                 __cfg80211_leave_ibss(rdev, dev, true);
1039                 break;
1040         case NL80211_IFTYPE_P2P_CLIENT:
1041         case NL80211_IFTYPE_STATION:
1042                 sched_scan_req = rtnl_dereference(rdev->sched_scan_req);
1043                 if (sched_scan_req && dev == sched_scan_req->dev)
1044                         __cfg80211_stop_sched_scan(rdev, false);
1045
1046 #ifdef CONFIG_CFG80211_WEXT
1047                 kfree(wdev->wext.ie);
1048                 wdev->wext.ie = NULL;
1049                 wdev->wext.ie_len = 0;
1050                 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1051 #endif
1052                 cfg80211_disconnect(rdev, dev,
1053                                     WLAN_REASON_DEAUTH_LEAVING, true);
1054                 break;
1055         case NL80211_IFTYPE_MESH_POINT:
1056                 __cfg80211_leave_mesh(rdev, dev);
1057                 break;
1058         case NL80211_IFTYPE_AP:
1059         case NL80211_IFTYPE_P2P_GO:
1060                 __cfg80211_stop_ap(rdev, dev, true);
1061                 break;
1062         case NL80211_IFTYPE_OCB:
1063                 __cfg80211_leave_ocb(rdev, dev);
1064                 break;
1065         case NL80211_IFTYPE_WDS:
1066                 /* must be handled by mac80211/driver, has no APIs */
1067                 break;
1068         case NL80211_IFTYPE_P2P_DEVICE:
1069         case NL80211_IFTYPE_NAN:
1070                 /* cannot happen, has no netdev */
1071                 break;
1072         case NL80211_IFTYPE_AP_VLAN:
1073         case NL80211_IFTYPE_MONITOR:
1074                 /* nothing to do */
1075                 break;
1076         case NL80211_IFTYPE_UNSPECIFIED:
1077         case NUM_NL80211_IFTYPES:
1078                 /* invalid */
1079                 break;
1080         }
1081 }
1082
1083 void cfg80211_leave(struct cfg80211_registered_device *rdev,
1084                     struct wireless_dev *wdev)
1085 {
1086         wdev_lock(wdev);
1087         __cfg80211_leave(rdev, wdev);
1088         wdev_unlock(wdev);
1089 }
1090
1091 void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
1092                          gfp_t gfp)
1093 {
1094         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1095         struct cfg80211_event *ev;
1096         unsigned long flags;
1097
1098         trace_cfg80211_stop_iface(wiphy, wdev);
1099
1100         ev = kzalloc(sizeof(*ev), gfp);
1101         if (!ev)
1102                 return;
1103
1104         ev->type = EVENT_STOPPED;
1105
1106         spin_lock_irqsave(&wdev->event_lock, flags);
1107         list_add_tail(&ev->list, &wdev->event_list);
1108         spin_unlock_irqrestore(&wdev->event_lock, flags);
1109         queue_work(cfg80211_wq, &rdev->event_work);
1110 }
1111 EXPORT_SYMBOL(cfg80211_stop_iface);
1112
1113 static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
1114                                          unsigned long state, void *ptr)
1115 {
1116         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1117         struct wireless_dev *wdev = dev->ieee80211_ptr;
1118         struct cfg80211_registered_device *rdev;
1119         struct cfg80211_sched_scan_request *sched_scan_req;
1120
1121         if (!wdev)
1122                 return NOTIFY_DONE;
1123
1124         rdev = wiphy_to_rdev(wdev->wiphy);
1125
1126         WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
1127
1128         switch (state) {
1129         case NETDEV_POST_INIT:
1130                 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
1131                 break;
1132         case NETDEV_REGISTER:
1133                 /*
1134                  * NB: cannot take rdev->mtx here because this may be
1135                  * called within code protected by it when interfaces
1136                  * are added with nl80211.
1137                  */
1138                 mutex_init(&wdev->mtx);
1139                 INIT_LIST_HEAD(&wdev->event_list);
1140                 spin_lock_init(&wdev->event_lock);
1141                 INIT_LIST_HEAD(&wdev->mgmt_registrations);
1142                 spin_lock_init(&wdev->mgmt_registrations_lock);
1143
1144                 /*
1145                  * We get here also when the interface changes network namespaces,
1146                  * as it's registered into the new one, but we don't want it to
1147                  * change ID in that case. Checking if the ID is already assigned
1148                  * works, because 0 isn't considered a valid ID and the memory is
1149                  * 0-initialized.
1150                  */
1151                 if (!wdev->identifier)
1152                         wdev->identifier = ++rdev->wdev_id;
1153                 list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
1154                 rdev->devlist_generation++;
1155                 /* can only change netns with wiphy */
1156                 dev->features |= NETIF_F_NETNS_LOCAL;
1157
1158                 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
1159                                       "phy80211")) {
1160                         pr_err("failed to add phy80211 symlink to netdev!\n");
1161                 }
1162                 wdev->netdev = dev;
1163 #ifdef CONFIG_CFG80211_WEXT
1164                 wdev->wext.default_key = -1;
1165                 wdev->wext.default_mgmt_key = -1;
1166                 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
1167 #endif
1168
1169                 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
1170                         wdev->ps = true;
1171                 else
1172                         wdev->ps = false;
1173                 /* allow mac80211 to determine the timeout */
1174                 wdev->ps_timeout = -1;
1175
1176                 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1177                      wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
1178                      wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
1179                         dev->priv_flags |= IFF_DONT_BRIDGE;
1180
1181                 INIT_WORK(&wdev->disconnect_wk, cfg80211_autodisconnect_wk);
1182
1183                 nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
1184                 break;
1185         case NETDEV_GOING_DOWN:
1186                 cfg80211_leave(rdev, wdev);
1187                 break;
1188         case NETDEV_DOWN:
1189                 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
1190                 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1191                         if (WARN_ON(!rdev->scan_req->notified))
1192                                 rdev->scan_req->info.aborted = true;
1193                         ___cfg80211_scan_done(rdev, false);
1194                 }
1195
1196                 sched_scan_req = rtnl_dereference(rdev->sched_scan_req);
1197                 if (WARN_ON(sched_scan_req &&
1198                             sched_scan_req->dev == wdev->netdev)) {
1199                         __cfg80211_stop_sched_scan(rdev, false);
1200                 }
1201
1202                 rdev->opencount--;
1203                 wake_up(&rdev->dev_wait);
1204                 break;
1205         case NETDEV_UP:
1206                 cfg80211_update_iface_num(rdev, wdev->iftype, 1);
1207                 wdev_lock(wdev);
1208                 switch (wdev->iftype) {
1209 #ifdef CONFIG_CFG80211_WEXT
1210                 case NL80211_IFTYPE_ADHOC:
1211                         cfg80211_ibss_wext_join(rdev, wdev);
1212                         break;
1213                 case NL80211_IFTYPE_STATION:
1214                         cfg80211_mgd_wext_connect(rdev, wdev);
1215                         break;
1216 #endif
1217 #ifdef CONFIG_MAC80211_MESH
1218                 case NL80211_IFTYPE_MESH_POINT:
1219                         {
1220                                 /* backward compat code... */
1221                                 struct mesh_setup setup;
1222                                 memcpy(&setup, &default_mesh_setup,
1223                                                 sizeof(setup));
1224                                  /* back compat only needed for mesh_id */
1225                                 setup.mesh_id = wdev->ssid;
1226                                 setup.mesh_id_len = wdev->mesh_id_up_len;
1227                                 if (wdev->mesh_id_up_len)
1228                                         __cfg80211_join_mesh(rdev, dev,
1229                                                         &setup,
1230                                                         &default_mesh_config);
1231                                 break;
1232                         }
1233 #endif
1234                 default:
1235                         break;
1236                 }
1237                 wdev_unlock(wdev);
1238                 rdev->opencount++;
1239
1240                 /*
1241                  * Configure power management to the driver here so that its
1242                  * correctly set also after interface type changes etc.
1243                  */
1244                 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1245                      wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
1246                     rdev->ops->set_power_mgmt &&
1247                     rdev_set_power_mgmt(rdev, dev, wdev->ps,
1248                                         wdev->ps_timeout)) {
1249                         /* assume this means it's off */
1250                         wdev->ps = false;
1251                 }
1252                 break;
1253         case NETDEV_UNREGISTER:
1254                 /*
1255                  * It is possible to get NETDEV_UNREGISTER
1256                  * multiple times. To detect that, check
1257                  * that the interface is still on the list
1258                  * of registered interfaces, and only then
1259                  * remove and clean it up.
1260                  */
1261                 if (!list_empty(&wdev->list)) {
1262                         nl80211_notify_iface(rdev, wdev,
1263                                              NL80211_CMD_DEL_INTERFACE);
1264                         sysfs_remove_link(&dev->dev.kobj, "phy80211");
1265                         list_del_rcu(&wdev->list);
1266                         rdev->devlist_generation++;
1267                         cfg80211_mlme_purge_registrations(wdev);
1268 #ifdef CONFIG_CFG80211_WEXT
1269                         kzfree(wdev->wext.keys);
1270 #endif
1271                         flush_work(&wdev->disconnect_wk);
1272                         cfg80211_cqm_config_free(wdev);
1273                 }
1274                 /*
1275                  * synchronise (so that we won't find this netdev
1276                  * from other code any more) and then clear the list
1277                  * head so that the above code can safely check for
1278                  * !list_empty() to avoid double-cleanup.
1279                  */
1280                 synchronize_rcu();
1281                 INIT_LIST_HEAD(&wdev->list);
1282                 /*
1283                  * Ensure that all events have been processed and
1284                  * freed.
1285                  */
1286                 cfg80211_process_wdev_events(wdev);
1287
1288                 if (WARN_ON(wdev->current_bss)) {
1289                         cfg80211_unhold_bss(wdev->current_bss);
1290                         cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
1291                         wdev->current_bss = NULL;
1292                 }
1293                 break;
1294         case NETDEV_PRE_UP:
1295                 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
1296                         return notifier_from_errno(-EOPNOTSUPP);
1297                 if (rfkill_blocked(rdev->rfkill))
1298                         return notifier_from_errno(-ERFKILL);
1299                 break;
1300         default:
1301                 return NOTIFY_DONE;
1302         }
1303
1304         wireless_nlevent_flush();
1305
1306         return NOTIFY_OK;
1307 }
1308
1309 static struct notifier_block cfg80211_netdev_notifier = {
1310         .notifier_call = cfg80211_netdev_notifier_call,
1311 };
1312
1313 static void __net_exit cfg80211_pernet_exit(struct net *net)
1314 {
1315         struct cfg80211_registered_device *rdev;
1316
1317         rtnl_lock();
1318         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1319                 if (net_eq(wiphy_net(&rdev->wiphy), net))
1320                         WARN_ON(cfg80211_switch_netns(rdev, &init_net));
1321         }
1322         rtnl_unlock();
1323 }
1324
1325 static struct pernet_operations cfg80211_pernet_ops = {
1326         .exit = cfg80211_pernet_exit,
1327 };
1328
1329 static int __init cfg80211_init(void)
1330 {
1331         int err;
1332
1333         err = register_pernet_device(&cfg80211_pernet_ops);
1334         if (err)
1335                 goto out_fail_pernet;
1336
1337         err = wiphy_sysfs_init();
1338         if (err)
1339                 goto out_fail_sysfs;
1340
1341         err = register_netdevice_notifier(&cfg80211_netdev_notifier);
1342         if (err)
1343                 goto out_fail_notifier;
1344
1345         err = nl80211_init();
1346         if (err)
1347                 goto out_fail_nl80211;
1348
1349         ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
1350
1351         err = regulatory_init();
1352         if (err)
1353                 goto out_fail_reg;
1354
1355         cfg80211_wq = alloc_ordered_workqueue("cfg80211", WQ_MEM_RECLAIM);
1356         if (!cfg80211_wq) {
1357                 err = -ENOMEM;
1358                 goto out_fail_wq;
1359         }
1360
1361         return 0;
1362
1363 out_fail_wq:
1364         regulatory_exit();
1365 out_fail_reg:
1366         debugfs_remove(ieee80211_debugfs_dir);
1367         nl80211_exit();
1368 out_fail_nl80211:
1369         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1370 out_fail_notifier:
1371         wiphy_sysfs_exit();
1372 out_fail_sysfs:
1373         unregister_pernet_device(&cfg80211_pernet_ops);
1374 out_fail_pernet:
1375         return err;
1376 }
1377 subsys_initcall(cfg80211_init);
1378
1379 static void __exit cfg80211_exit(void)
1380 {
1381         debugfs_remove(ieee80211_debugfs_dir);
1382         nl80211_exit();
1383         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1384         wiphy_sysfs_exit();
1385         regulatory_exit();
1386         unregister_pernet_device(&cfg80211_pernet_ops);
1387         destroy_workqueue(cfg80211_wq);
1388 }
1389 module_exit(cfg80211_exit);