cfg80211: allow registering more than one beacon listener
[linux-3.10.git] / net / wireless / core.c
1 /*
2  * This is the linux wireless configuration interface.
3  *
4  * Copyright 2006-2010          Johannes Berg <johannes@sipsolutions.net>
5  */
6
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8
9 #include <linux/if.h>
10 #include <linux/module.h>
11 #include <linux/err.h>
12 #include <linux/list.h>
13 #include <linux/slab.h>
14 #include <linux/nl80211.h>
15 #include <linux/debugfs.h>
16 #include <linux/notifier.h>
17 #include <linux/device.h>
18 #include <linux/etherdevice.h>
19 #include <linux/rtnetlink.h>
20 #include <linux/sched.h>
21 #include <net/genetlink.h>
22 #include <net/cfg80211.h>
23 #include "nl80211.h"
24 #include "core.h"
25 #include "sysfs.h"
26 #include "debugfs.h"
27 #include "wext-compat.h"
28 #include "ethtool.h"
29 #include "rdev-ops.h"
30
31 /* name for sysfs, %d is appended */
32 #define PHY_NAME "phy"
33
34 MODULE_AUTHOR("Johannes Berg");
35 MODULE_LICENSE("GPL");
36 MODULE_DESCRIPTION("wireless configuration support");
37
38 /* RCU-protected (and cfg80211_mutex for writers) */
39 LIST_HEAD(cfg80211_rdev_list);
40 int cfg80211_rdev_list_generation;
41
42 DEFINE_MUTEX(cfg80211_mutex);
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 /* requires cfg80211_mutex to be held! */
56 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
57 {
58         struct cfg80211_registered_device *result = NULL, *rdev;
59
60         if (!wiphy_idx_valid(wiphy_idx))
61                 return NULL;
62
63         assert_cfg80211_lock();
64
65         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
66                 if (rdev->wiphy_idx == wiphy_idx) {
67                         result = rdev;
68                         break;
69                 }
70         }
71
72         return result;
73 }
74
75 int get_wiphy_idx(struct wiphy *wiphy)
76 {
77         struct cfg80211_registered_device *rdev;
78         if (!wiphy)
79                 return WIPHY_IDX_STALE;
80         rdev = wiphy_to_dev(wiphy);
81         return rdev->wiphy_idx;
82 }
83
84 /* requires cfg80211_rdev_mutex to be held! */
85 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
86 {
87         struct cfg80211_registered_device *rdev;
88
89         if (!wiphy_idx_valid(wiphy_idx))
90                 return NULL;
91
92         assert_cfg80211_lock();
93
94         rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
95         if (!rdev)
96                 return NULL;
97         return &rdev->wiphy;
98 }
99
100 struct cfg80211_registered_device *
101 cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
102 {
103         struct cfg80211_registered_device *rdev = ERR_PTR(-ENODEV);
104         struct net_device *dev;
105
106         mutex_lock(&cfg80211_mutex);
107         dev = dev_get_by_index(net, ifindex);
108         if (!dev)
109                 goto out;
110         if (dev->ieee80211_ptr) {
111                 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
112                 mutex_lock(&rdev->mtx);
113         } else
114                 rdev = ERR_PTR(-ENODEV);
115         dev_put(dev);
116  out:
117         mutex_unlock(&cfg80211_mutex);
118         return rdev;
119 }
120
121 /* requires cfg80211_mutex to be held */
122 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
123                         char *newname)
124 {
125         struct cfg80211_registered_device *rdev2;
126         int wiphy_idx, taken = -1, result, digits;
127
128         assert_cfg80211_lock();
129
130         /* prohibit calling the thing phy%d when %d is not its number */
131         sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
132         if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
133                 /* count number of places needed to print wiphy_idx */
134                 digits = 1;
135                 while (wiphy_idx /= 10)
136                         digits++;
137                 /*
138                  * deny the name if it is phy<idx> where <idx> is printed
139                  * without leading zeroes. taken == strlen(newname) here
140                  */
141                 if (taken == strlen(PHY_NAME) + digits)
142                         return -EINVAL;
143         }
144
145
146         /* Ignore nop renames */
147         if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
148                 return 0;
149
150         /* Ensure another device does not already have this name. */
151         list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
152                 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0)
153                         return -EINVAL;
154
155         result = device_rename(&rdev->wiphy.dev, newname);
156         if (result)
157                 return result;
158
159         if (rdev->wiphy.debugfsdir &&
160             !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
161                             rdev->wiphy.debugfsdir,
162                             rdev->wiphy.debugfsdir->d_parent,
163                             newname))
164                 pr_err("failed to rename debugfs dir to %s!\n", newname);
165
166         nl80211_notify_dev_rename(rdev);
167
168         return 0;
169 }
170
171 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
172                           struct net *net)
173 {
174         struct wireless_dev *wdev;
175         int err = 0;
176
177         if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
178                 return -EOPNOTSUPP;
179
180         list_for_each_entry(wdev, &rdev->wdev_list, list) {
181                 if (!wdev->netdev)
182                         continue;
183                 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
184                 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
185                 if (err)
186                         break;
187                 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
188         }
189
190         if (err) {
191                 /* failed -- clean up to old netns */
192                 net = wiphy_net(&rdev->wiphy);
193
194                 list_for_each_entry_continue_reverse(wdev, &rdev->wdev_list,
195                                                      list) {
196                         if (!wdev->netdev)
197                                 continue;
198                         wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
199                         err = dev_change_net_namespace(wdev->netdev, net,
200                                                         "wlan%d");
201                         WARN_ON(err);
202                         wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
203                 }
204
205                 return err;
206         }
207
208         wiphy_net_set(&rdev->wiphy, net);
209
210         err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
211         WARN_ON(err);
212
213         return 0;
214 }
215
216 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
217 {
218         struct cfg80211_registered_device *rdev = data;
219
220         rdev_rfkill_poll(rdev);
221 }
222
223 static int cfg80211_rfkill_set_block(void *data, bool blocked)
224 {
225         struct cfg80211_registered_device *rdev = data;
226         struct wireless_dev *wdev;
227
228         if (!blocked)
229                 return 0;
230
231         rtnl_lock();
232         mutex_lock(&rdev->devlist_mtx);
233
234         list_for_each_entry(wdev, &rdev->wdev_list, list) {
235                 if (wdev->netdev) {
236                         dev_close(wdev->netdev);
237                         continue;
238                 }
239                 /* otherwise, check iftype */
240                 switch (wdev->iftype) {
241                 case NL80211_IFTYPE_P2P_DEVICE:
242                         if (!wdev->p2p_started)
243                                 break;
244                         rdev_stop_p2p_device(rdev, wdev);
245                         wdev->p2p_started = false;
246                         rdev->opencount--;
247                         break;
248                 default:
249                         break;
250                 }
251         }
252
253         mutex_unlock(&rdev->devlist_mtx);
254         rtnl_unlock();
255
256         return 0;
257 }
258
259 static void cfg80211_rfkill_sync_work(struct work_struct *work)
260 {
261         struct cfg80211_registered_device *rdev;
262
263         rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
264         cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
265 }
266
267 static void cfg80211_event_work(struct work_struct *work)
268 {
269         struct cfg80211_registered_device *rdev;
270
271         rdev = container_of(work, struct cfg80211_registered_device,
272                             event_work);
273
274         rtnl_lock();
275         cfg80211_lock_rdev(rdev);
276
277         cfg80211_process_rdev_events(rdev);
278         cfg80211_unlock_rdev(rdev);
279         rtnl_unlock();
280 }
281
282 /* exported functions */
283
284 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
285 {
286         static int wiphy_counter;
287
288         struct cfg80211_registered_device *rdev;
289         int alloc_size;
290
291         WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
292         WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
293         WARN_ON(ops->connect && !ops->disconnect);
294         WARN_ON(ops->join_ibss && !ops->leave_ibss);
295         WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
296         WARN_ON(ops->add_station && !ops->del_station);
297         WARN_ON(ops->add_mpath && !ops->del_mpath);
298         WARN_ON(ops->join_mesh && !ops->leave_mesh);
299
300         alloc_size = sizeof(*rdev) + sizeof_priv;
301
302         rdev = kzalloc(alloc_size, GFP_KERNEL);
303         if (!rdev)
304                 return NULL;
305
306         rdev->ops = ops;
307
308         mutex_lock(&cfg80211_mutex);
309
310         rdev->wiphy_idx = wiphy_counter++;
311
312         if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) {
313                 wiphy_counter--;
314                 mutex_unlock(&cfg80211_mutex);
315                 /* ugh, wrapped! */
316                 kfree(rdev);
317                 return NULL;
318         }
319
320         mutex_unlock(&cfg80211_mutex);
321
322         /* give it a proper name */
323         dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
324
325         mutex_init(&rdev->mtx);
326         mutex_init(&rdev->devlist_mtx);
327         mutex_init(&rdev->sched_scan_mtx);
328         INIT_LIST_HEAD(&rdev->wdev_list);
329         INIT_LIST_HEAD(&rdev->beacon_registrations);
330         spin_lock_init(&rdev->beacon_registrations_lock);
331         spin_lock_init(&rdev->bss_lock);
332         INIT_LIST_HEAD(&rdev->bss_list);
333         INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
334         INIT_WORK(&rdev->sched_scan_results_wk, __cfg80211_sched_scan_results);
335 #ifdef CONFIG_CFG80211_WEXT
336         rdev->wiphy.wext = &cfg80211_wext_handler;
337 #endif
338
339         device_initialize(&rdev->wiphy.dev);
340         rdev->wiphy.dev.class = &ieee80211_class;
341         rdev->wiphy.dev.platform_data = rdev;
342
343 #ifdef CONFIG_CFG80211_DEFAULT_PS
344         rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
345 #endif
346
347         wiphy_net_set(&rdev->wiphy, &init_net);
348
349         rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
350         rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
351                                    &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
352                                    &rdev->rfkill_ops, rdev);
353
354         if (!rdev->rfkill) {
355                 kfree(rdev);
356                 return NULL;
357         }
358
359         INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
360         INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
361         INIT_WORK(&rdev->event_work, cfg80211_event_work);
362
363         init_waitqueue_head(&rdev->dev_wait);
364
365         /*
366          * Initialize wiphy parameters to IEEE 802.11 MIB default values.
367          * Fragmentation and RTS threshold are disabled by default with the
368          * special -1 value.
369          */
370         rdev->wiphy.retry_short = 7;
371         rdev->wiphy.retry_long = 4;
372         rdev->wiphy.frag_threshold = (u32) -1;
373         rdev->wiphy.rts_threshold = (u32) -1;
374         rdev->wiphy.coverage_class = 0;
375
376         rdev->wiphy.features = NL80211_FEATURE_SCAN_FLUSH;
377
378         return &rdev->wiphy;
379 }
380 EXPORT_SYMBOL(wiphy_new);
381
382 static int wiphy_verify_combinations(struct wiphy *wiphy)
383 {
384         const struct ieee80211_iface_combination *c;
385         int i, j;
386
387         for (i = 0; i < wiphy->n_iface_combinations; i++) {
388                 u32 cnt = 0;
389                 u16 all_iftypes = 0;
390
391                 c = &wiphy->iface_combinations[i];
392
393                 /* Combinations with just one interface aren't real */
394                 if (WARN_ON(c->max_interfaces < 2))
395                         return -EINVAL;
396
397                 /* Need at least one channel */
398                 if (WARN_ON(!c->num_different_channels))
399                         return -EINVAL;
400
401                 /*
402                  * Put a sane limit on maximum number of different
403                  * channels to simplify channel accounting code.
404                  */
405                 if (WARN_ON(c->num_different_channels >
406                                 CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
407                         return -EINVAL;
408
409                 if (WARN_ON(!c->n_limits))
410                         return -EINVAL;
411
412                 for (j = 0; j < c->n_limits; j++) {
413                         u16 types = c->limits[j].types;
414
415                         /*
416                          * interface types shouldn't overlap, this is
417                          * used in cfg80211_can_change_interface()
418                          */
419                         if (WARN_ON(types & all_iftypes))
420                                 return -EINVAL;
421                         all_iftypes |= types;
422
423                         if (WARN_ON(!c->limits[j].max))
424                                 return -EINVAL;
425
426                         /* Shouldn't list software iftypes in combinations! */
427                         if (WARN_ON(wiphy->software_iftypes & types))
428                                 return -EINVAL;
429
430                         /* Only a single P2P_DEVICE can be allowed */
431                         if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
432                                     c->limits[j].max > 1))
433                                 return -EINVAL;
434
435                         cnt += c->limits[j].max;
436                         /*
437                          * Don't advertise an unsupported type
438                          * in a combination.
439                          */
440                         if (WARN_ON((wiphy->interface_modes & types) != types))
441                                 return -EINVAL;
442                 }
443
444                 /* You can't even choose that many! */
445                 if (WARN_ON(cnt < c->max_interfaces))
446                         return -EINVAL;
447         }
448
449         return 0;
450 }
451
452 int wiphy_register(struct wiphy *wiphy)
453 {
454         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
455         int res;
456         enum ieee80211_band band;
457         struct ieee80211_supported_band *sband;
458         bool have_band = false;
459         int i;
460         u16 ifmodes = wiphy->interface_modes;
461
462 #ifdef CONFIG_PM
463         if (WARN_ON((wiphy->wowlan.flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
464                     !(wiphy->wowlan.flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
465                 return -EINVAL;
466 #endif
467
468         if (WARN_ON(wiphy->ap_sme_capa &&
469                     !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
470                 return -EINVAL;
471
472         if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
473                 return -EINVAL;
474
475         if (WARN_ON(wiphy->addresses &&
476                     !is_zero_ether_addr(wiphy->perm_addr) &&
477                     memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
478                            ETH_ALEN)))
479                 return -EINVAL;
480
481         if (wiphy->addresses)
482                 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
483
484         /* sanity check ifmodes */
485         WARN_ON(!ifmodes);
486         ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
487         if (WARN_ON(ifmodes != wiphy->interface_modes))
488                 wiphy->interface_modes = ifmodes;
489
490         res = wiphy_verify_combinations(wiphy);
491         if (res)
492                 return res;
493
494         /* sanity check supported bands/channels */
495         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
496                 sband = wiphy->bands[band];
497                 if (!sband)
498                         continue;
499
500                 sband->band = band;
501                 if (WARN_ON(!sband->n_channels))
502                         return -EINVAL;
503                 /*
504                  * on 60gHz band, there are no legacy rates, so
505                  * n_bitrates is 0
506                  */
507                 if (WARN_ON(band != IEEE80211_BAND_60GHZ &&
508                             !sband->n_bitrates))
509                         return -EINVAL;
510
511                 /*
512                  * Since cfg80211_disable_40mhz_24ghz is global, we can
513                  * modify the sband's ht data even if the driver uses a
514                  * global structure for that.
515                  */
516                 if (cfg80211_disable_40mhz_24ghz &&
517                     band == IEEE80211_BAND_2GHZ &&
518                     sband->ht_cap.ht_supported) {
519                         sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
520                         sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
521                 }
522
523                 /*
524                  * Since we use a u32 for rate bitmaps in
525                  * ieee80211_get_response_rate, we cannot
526                  * have more than 32 legacy rates.
527                  */
528                 if (WARN_ON(sband->n_bitrates > 32))
529                         return -EINVAL;
530
531                 for (i = 0; i < sband->n_channels; i++) {
532                         sband->channels[i].orig_flags =
533                                 sband->channels[i].flags;
534                         sband->channels[i].orig_mag = INT_MAX;
535                         sband->channels[i].orig_mpwr =
536                                 sband->channels[i].max_power;
537                         sband->channels[i].band = band;
538                 }
539
540                 have_band = true;
541         }
542
543         if (!have_band) {
544                 WARN_ON(1);
545                 return -EINVAL;
546         }
547
548 #ifdef CONFIG_PM
549         if (rdev->wiphy.wowlan.n_patterns) {
550                 if (WARN_ON(!rdev->wiphy.wowlan.pattern_min_len ||
551                             rdev->wiphy.wowlan.pattern_min_len >
552                             rdev->wiphy.wowlan.pattern_max_len))
553                         return -EINVAL;
554         }
555 #endif
556
557         /* check and set up bitrates */
558         ieee80211_set_bitrate_flags(wiphy);
559
560         mutex_lock(&cfg80211_mutex);
561
562         res = device_add(&rdev->wiphy.dev);
563         if (res) {
564                 mutex_unlock(&cfg80211_mutex);
565                 return res;
566         }
567
568         /* set up regulatory info */
569         wiphy_regulatory_register(wiphy);
570
571         list_add_rcu(&rdev->list, &cfg80211_rdev_list);
572         cfg80211_rdev_list_generation++;
573
574         /* add to debugfs */
575         rdev->wiphy.debugfsdir =
576                 debugfs_create_dir(wiphy_name(&rdev->wiphy),
577                                    ieee80211_debugfs_dir);
578         if (IS_ERR(rdev->wiphy.debugfsdir))
579                 rdev->wiphy.debugfsdir = NULL;
580
581         if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
582                 struct regulatory_request request;
583
584                 request.wiphy_idx = get_wiphy_idx(wiphy);
585                 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
586                 request.alpha2[0] = '9';
587                 request.alpha2[1] = '9';
588
589                 nl80211_send_reg_change_event(&request);
590         }
591
592         cfg80211_debugfs_rdev_add(rdev);
593         mutex_unlock(&cfg80211_mutex);
594
595         /*
596          * due to a locking dependency this has to be outside of the
597          * cfg80211_mutex lock
598          */
599         res = rfkill_register(rdev->rfkill);
600         if (res)
601                 goto out_rm_dev;
602
603         rtnl_lock();
604         rdev->wiphy.registered = true;
605         rtnl_unlock();
606         return 0;
607
608 out_rm_dev:
609         device_del(&rdev->wiphy.dev);
610         return res;
611 }
612 EXPORT_SYMBOL(wiphy_register);
613
614 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
615 {
616         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
617
618         if (!rdev->ops->rfkill_poll)
619                 return;
620         rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
621         rfkill_resume_polling(rdev->rfkill);
622 }
623 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
624
625 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
626 {
627         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
628
629         rfkill_pause_polling(rdev->rfkill);
630 }
631 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
632
633 void wiphy_unregister(struct wiphy *wiphy)
634 {
635         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
636
637         rtnl_lock();
638         rdev->wiphy.registered = false;
639         rtnl_unlock();
640
641         rfkill_unregister(rdev->rfkill);
642
643         /* protect the device list */
644         mutex_lock(&cfg80211_mutex);
645
646         wait_event(rdev->dev_wait, ({
647                 int __count;
648                 mutex_lock(&rdev->devlist_mtx);
649                 __count = rdev->opencount;
650                 mutex_unlock(&rdev->devlist_mtx);
651                 __count == 0; }));
652
653         mutex_lock(&rdev->devlist_mtx);
654         BUG_ON(!list_empty(&rdev->wdev_list));
655         mutex_unlock(&rdev->devlist_mtx);
656
657         /*
658          * First remove the hardware from everywhere, this makes
659          * it impossible to find from userspace.
660          */
661         debugfs_remove_recursive(rdev->wiphy.debugfsdir);
662         list_del_rcu(&rdev->list);
663         synchronize_rcu();
664
665         /*
666          * Try to grab rdev->mtx. If a command is still in progress,
667          * hopefully the driver will refuse it since it's tearing
668          * down the device already. We wait for this command to complete
669          * before unlinking the item from the list.
670          * Note: as codified by the BUG_ON above we cannot get here if
671          * a virtual interface is still present. Hence, we can only get
672          * to lock contention here if userspace issues a command that
673          * identified the hardware by wiphy index.
674          */
675         cfg80211_lock_rdev(rdev);
676         /* nothing */
677         cfg80211_unlock_rdev(rdev);
678
679         /*
680          * If this device got a regulatory hint tell core its
681          * free to listen now to a new shiny device regulatory hint
682          */
683         wiphy_regulatory_deregister(wiphy);
684
685         cfg80211_rdev_list_generation++;
686         device_del(&rdev->wiphy.dev);
687
688         mutex_unlock(&cfg80211_mutex);
689
690         flush_work(&rdev->scan_done_wk);
691         cancel_work_sync(&rdev->conn_work);
692         flush_work(&rdev->event_work);
693
694         if (rdev->wowlan && rdev->ops->set_wakeup)
695                 rdev_set_wakeup(rdev, false);
696         cfg80211_rdev_free_wowlan(rdev);
697 }
698 EXPORT_SYMBOL(wiphy_unregister);
699
700 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
701 {
702         struct cfg80211_internal_bss *scan, *tmp;
703         struct cfg80211_beacon_registration *reg, *treg;
704         rfkill_destroy(rdev->rfkill);
705         mutex_destroy(&rdev->mtx);
706         mutex_destroy(&rdev->devlist_mtx);
707         mutex_destroy(&rdev->sched_scan_mtx);
708         list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
709                 list_del(&reg->list);
710                 kfree(reg);
711         }
712         list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
713                 cfg80211_put_bss(&scan->pub);
714         kfree(rdev);
715 }
716
717 void wiphy_free(struct wiphy *wiphy)
718 {
719         put_device(&wiphy->dev);
720 }
721 EXPORT_SYMBOL(wiphy_free);
722
723 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
724 {
725         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
726
727         if (rfkill_set_hw_state(rdev->rfkill, blocked))
728                 schedule_work(&rdev->rfkill_sync);
729 }
730 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
731
732 static void wdev_cleanup_work(struct work_struct *work)
733 {
734         struct wireless_dev *wdev;
735         struct cfg80211_registered_device *rdev;
736
737         wdev = container_of(work, struct wireless_dev, cleanup_work);
738         rdev = wiphy_to_dev(wdev->wiphy);
739
740         cfg80211_lock_rdev(rdev);
741
742         if (WARN_ON(rdev->scan_req && rdev->scan_req->wdev == wdev)) {
743                 rdev->scan_req->aborted = true;
744                 ___cfg80211_scan_done(rdev, true);
745         }
746
747         cfg80211_unlock_rdev(rdev);
748
749         mutex_lock(&rdev->sched_scan_mtx);
750
751         if (WARN_ON(rdev->sched_scan_req &&
752                     rdev->sched_scan_req->dev == wdev->netdev)) {
753                 __cfg80211_stop_sched_scan(rdev, false);
754         }
755
756         mutex_unlock(&rdev->sched_scan_mtx);
757
758         mutex_lock(&rdev->devlist_mtx);
759         rdev->opencount--;
760         mutex_unlock(&rdev->devlist_mtx);
761         wake_up(&rdev->dev_wait);
762
763         dev_put(wdev->netdev);
764 }
765
766 void cfg80211_unregister_wdev(struct wireless_dev *wdev)
767 {
768         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
769
770         ASSERT_RTNL();
771
772         if (WARN_ON(wdev->netdev))
773                 return;
774
775         mutex_lock(&rdev->devlist_mtx);
776         list_del_rcu(&wdev->list);
777         rdev->devlist_generation++;
778
779         switch (wdev->iftype) {
780         case NL80211_IFTYPE_P2P_DEVICE:
781                 if (!wdev->p2p_started)
782                         break;
783                 rdev_stop_p2p_device(rdev, wdev);
784                 wdev->p2p_started = false;
785                 rdev->opencount--;
786                 break;
787         default:
788                 WARN_ON_ONCE(1);
789                 break;
790         }
791         mutex_unlock(&rdev->devlist_mtx);
792 }
793 EXPORT_SYMBOL(cfg80211_unregister_wdev);
794
795 static struct device_type wiphy_type = {
796         .name   = "wlan",
797 };
798
799 void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
800                                enum nl80211_iftype iftype, int num)
801 {
802         ASSERT_RTNL();
803
804         rdev->num_running_ifaces += num;
805         if (iftype == NL80211_IFTYPE_MONITOR)
806                 rdev->num_running_monitor_ifaces += num;
807 }
808
809 static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
810                                          unsigned long state,
811                                          void *ndev)
812 {
813         struct net_device *dev = ndev;
814         struct wireless_dev *wdev = dev->ieee80211_ptr;
815         struct cfg80211_registered_device *rdev;
816         int ret;
817
818         if (!wdev)
819                 return NOTIFY_DONE;
820
821         rdev = wiphy_to_dev(wdev->wiphy);
822
823         WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
824
825         switch (state) {
826         case NETDEV_POST_INIT:
827                 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
828                 break;
829         case NETDEV_REGISTER:
830                 /*
831                  * NB: cannot take rdev->mtx here because this may be
832                  * called within code protected by it when interfaces
833                  * are added with nl80211.
834                  */
835                 mutex_init(&wdev->mtx);
836                 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
837                 INIT_LIST_HEAD(&wdev->event_list);
838                 spin_lock_init(&wdev->event_lock);
839                 INIT_LIST_HEAD(&wdev->mgmt_registrations);
840                 spin_lock_init(&wdev->mgmt_registrations_lock);
841
842                 mutex_lock(&rdev->devlist_mtx);
843                 wdev->identifier = ++rdev->wdev_id;
844                 list_add_rcu(&wdev->list, &rdev->wdev_list);
845                 rdev->devlist_generation++;
846                 /* can only change netns with wiphy */
847                 dev->features |= NETIF_F_NETNS_LOCAL;
848
849                 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
850                                       "phy80211")) {
851                         pr_err("failed to add phy80211 symlink to netdev!\n");
852                 }
853                 wdev->netdev = dev;
854                 wdev->sme_state = CFG80211_SME_IDLE;
855                 mutex_unlock(&rdev->devlist_mtx);
856 #ifdef CONFIG_CFG80211_WEXT
857                 wdev->wext.default_key = -1;
858                 wdev->wext.default_mgmt_key = -1;
859                 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
860 #endif
861
862                 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
863                         wdev->ps = true;
864                 else
865                         wdev->ps = false;
866                 /* allow mac80211 to determine the timeout */
867                 wdev->ps_timeout = -1;
868
869                 if (!dev->ethtool_ops)
870                         dev->ethtool_ops = &cfg80211_ethtool_ops;
871
872                 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
873                      wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
874                      wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
875                         dev->priv_flags |= IFF_DONT_BRIDGE;
876                 break;
877         case NETDEV_GOING_DOWN:
878                 switch (wdev->iftype) {
879                 case NL80211_IFTYPE_ADHOC:
880                         cfg80211_leave_ibss(rdev, dev, true);
881                         break;
882                 case NL80211_IFTYPE_P2P_CLIENT:
883                 case NL80211_IFTYPE_STATION:
884                         mutex_lock(&rdev->sched_scan_mtx);
885                         __cfg80211_stop_sched_scan(rdev, false);
886                         mutex_unlock(&rdev->sched_scan_mtx);
887
888                         wdev_lock(wdev);
889 #ifdef CONFIG_CFG80211_WEXT
890                         kfree(wdev->wext.ie);
891                         wdev->wext.ie = NULL;
892                         wdev->wext.ie_len = 0;
893                         wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
894 #endif
895                         __cfg80211_disconnect(rdev, dev,
896                                               WLAN_REASON_DEAUTH_LEAVING, true);
897                         cfg80211_mlme_down(rdev, dev);
898                         wdev_unlock(wdev);
899                         break;
900                 case NL80211_IFTYPE_MESH_POINT:
901                         cfg80211_leave_mesh(rdev, dev);
902                         break;
903                 case NL80211_IFTYPE_AP:
904                         cfg80211_stop_ap(rdev, dev);
905                         break;
906                 default:
907                         break;
908                 }
909                 wdev->beacon_interval = 0;
910                 break;
911         case NETDEV_DOWN:
912                 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
913                 dev_hold(dev);
914                 queue_work(cfg80211_wq, &wdev->cleanup_work);
915                 break;
916         case NETDEV_UP:
917                 /*
918                  * If we have a really quick DOWN/UP succession we may
919                  * have this work still pending ... cancel it and see
920                  * if it was pending, in which case we need to account
921                  * for some of the work it would have done.
922                  */
923                 if (cancel_work_sync(&wdev->cleanup_work)) {
924                         mutex_lock(&rdev->devlist_mtx);
925                         rdev->opencount--;
926                         mutex_unlock(&rdev->devlist_mtx);
927                         dev_put(dev);
928                 }
929                 cfg80211_update_iface_num(rdev, wdev->iftype, 1);
930                 cfg80211_lock_rdev(rdev);
931                 mutex_lock(&rdev->devlist_mtx);
932                 wdev_lock(wdev);
933                 switch (wdev->iftype) {
934 #ifdef CONFIG_CFG80211_WEXT
935                 case NL80211_IFTYPE_ADHOC:
936                         cfg80211_ibss_wext_join(rdev, wdev);
937                         break;
938                 case NL80211_IFTYPE_STATION:
939                         cfg80211_mgd_wext_connect(rdev, wdev);
940                         break;
941 #endif
942 #ifdef CONFIG_MAC80211_MESH
943                 case NL80211_IFTYPE_MESH_POINT:
944                         {
945                                 /* backward compat code... */
946                                 struct mesh_setup setup;
947                                 memcpy(&setup, &default_mesh_setup,
948                                                 sizeof(setup));
949                                  /* back compat only needed for mesh_id */
950                                 setup.mesh_id = wdev->ssid;
951                                 setup.mesh_id_len = wdev->mesh_id_up_len;
952                                 if (wdev->mesh_id_up_len)
953                                         __cfg80211_join_mesh(rdev, dev,
954                                                         &setup,
955                                                         &default_mesh_config);
956                                 break;
957                         }
958 #endif
959                 default:
960                         break;
961                 }
962                 wdev_unlock(wdev);
963                 rdev->opencount++;
964                 mutex_unlock(&rdev->devlist_mtx);
965                 cfg80211_unlock_rdev(rdev);
966
967                 /*
968                  * Configure power management to the driver here so that its
969                  * correctly set also after interface type changes etc.
970                  */
971                 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
972                      wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
973                     rdev->ops->set_power_mgmt)
974                         if (rdev_set_power_mgmt(rdev, dev, wdev->ps,
975                                                 wdev->ps_timeout)) {
976                                 /* assume this means it's off */
977                                 wdev->ps = false;
978                         }
979                 break;
980         case NETDEV_UNREGISTER:
981                 /*
982                  * NB: cannot take rdev->mtx here because this may be
983                  * called within code protected by it when interfaces
984                  * are removed with nl80211.
985                  */
986                 mutex_lock(&rdev->devlist_mtx);
987                 /*
988                  * It is possible to get NETDEV_UNREGISTER
989                  * multiple times. To detect that, check
990                  * that the interface is still on the list
991                  * of registered interfaces, and only then
992                  * remove and clean it up.
993                  */
994                 if (!list_empty(&wdev->list)) {
995                         sysfs_remove_link(&dev->dev.kobj, "phy80211");
996                         list_del_rcu(&wdev->list);
997                         rdev->devlist_generation++;
998                         cfg80211_mlme_purge_registrations(wdev);
999 #ifdef CONFIG_CFG80211_WEXT
1000                         kfree(wdev->wext.keys);
1001 #endif
1002                 }
1003                 mutex_unlock(&rdev->devlist_mtx);
1004                 /*
1005                  * synchronise (so that we won't find this netdev
1006                  * from other code any more) and then clear the list
1007                  * head so that the above code can safely check for
1008                  * !list_empty() to avoid double-cleanup.
1009                  */
1010                 synchronize_rcu();
1011                 INIT_LIST_HEAD(&wdev->list);
1012                 /*
1013                  * Ensure that all events have been processed and
1014                  * freed.
1015                  */
1016                 cfg80211_process_wdev_events(wdev);
1017                 break;
1018         case NETDEV_PRE_UP:
1019                 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
1020                         return notifier_from_errno(-EOPNOTSUPP);
1021                 if (rfkill_blocked(rdev->rfkill))
1022                         return notifier_from_errno(-ERFKILL);
1023                 mutex_lock(&rdev->devlist_mtx);
1024                 ret = cfg80211_can_add_interface(rdev, wdev->iftype);
1025                 mutex_unlock(&rdev->devlist_mtx);
1026                 if (ret)
1027                         return notifier_from_errno(ret);
1028                 break;
1029         }
1030
1031         return NOTIFY_DONE;
1032 }
1033
1034 static struct notifier_block cfg80211_netdev_notifier = {
1035         .notifier_call = cfg80211_netdev_notifier_call,
1036 };
1037
1038 static void __net_exit cfg80211_pernet_exit(struct net *net)
1039 {
1040         struct cfg80211_registered_device *rdev;
1041
1042         rtnl_lock();
1043         mutex_lock(&cfg80211_mutex);
1044         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1045                 if (net_eq(wiphy_net(&rdev->wiphy), net))
1046                         WARN_ON(cfg80211_switch_netns(rdev, &init_net));
1047         }
1048         mutex_unlock(&cfg80211_mutex);
1049         rtnl_unlock();
1050 }
1051
1052 static struct pernet_operations cfg80211_pernet_ops = {
1053         .exit = cfg80211_pernet_exit,
1054 };
1055
1056 static int __init cfg80211_init(void)
1057 {
1058         int err;
1059
1060         err = register_pernet_device(&cfg80211_pernet_ops);
1061         if (err)
1062                 goto out_fail_pernet;
1063
1064         err = wiphy_sysfs_init();
1065         if (err)
1066                 goto out_fail_sysfs;
1067
1068         err = register_netdevice_notifier(&cfg80211_netdev_notifier);
1069         if (err)
1070                 goto out_fail_notifier;
1071
1072         err = nl80211_init();
1073         if (err)
1074                 goto out_fail_nl80211;
1075
1076         ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
1077
1078         err = regulatory_init();
1079         if (err)
1080                 goto out_fail_reg;
1081
1082         cfg80211_wq = create_singlethread_workqueue("cfg80211");
1083         if (!cfg80211_wq)
1084                 goto out_fail_wq;
1085
1086         return 0;
1087
1088 out_fail_wq:
1089         regulatory_exit();
1090 out_fail_reg:
1091         debugfs_remove(ieee80211_debugfs_dir);
1092 out_fail_nl80211:
1093         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1094 out_fail_notifier:
1095         wiphy_sysfs_exit();
1096 out_fail_sysfs:
1097         unregister_pernet_device(&cfg80211_pernet_ops);
1098 out_fail_pernet:
1099         return err;
1100 }
1101 subsys_initcall(cfg80211_init);
1102
1103 static void __exit cfg80211_exit(void)
1104 {
1105         debugfs_remove(ieee80211_debugfs_dir);
1106         nl80211_exit();
1107         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1108         wiphy_sysfs_exit();
1109         regulatory_exit();
1110         unregister_pernet_device(&cfg80211_pernet_ops);
1111         destroy_workqueue(cfg80211_wq);
1112 }
1113 module_exit(cfg80211_exit);