cfg80211: assign device type in netdev notifier callback
[linux-2.6.git] / net / wireless / core.c
1 /*
2  * This is the linux wireless configuration interface.
3  *
4  * Copyright 2006-2009          Johannes Berg <johannes@sipsolutions.net>
5  */
6
7 #include <linux/if.h>
8 #include <linux/module.h>
9 #include <linux/err.h>
10 #include <linux/list.h>
11 #include <linux/nl80211.h>
12 #include <linux/debugfs.h>
13 #include <linux/notifier.h>
14 #include <linux/device.h>
15 #include <linux/etherdevice.h>
16 #include <linux/rtnetlink.h>
17 #include <net/genetlink.h>
18 #include <net/cfg80211.h>
19 #include "nl80211.h"
20 #include "core.h"
21 #include "sysfs.h"
22 #include "debugfs.h"
23 #include "wext-compat.h"
24
25 /* name for sysfs, %d is appended */
26 #define PHY_NAME "phy"
27
28 MODULE_AUTHOR("Johannes Berg");
29 MODULE_LICENSE("GPL");
30 MODULE_DESCRIPTION("wireless configuration support");
31
32 /* RCU might be appropriate here since we usually
33  * only read the list, and that can happen quite
34  * often because we need to do it for each command */
35 LIST_HEAD(cfg80211_rdev_list);
36 int cfg80211_rdev_list_generation;
37
38 /*
39  * This is used to protect the cfg80211_rdev_list
40  */
41 DEFINE_MUTEX(cfg80211_mutex);
42
43 /* for debugfs */
44 static struct dentry *ieee80211_debugfs_dir;
45
46 /* requires cfg80211_mutex to be held! */
47 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
48 {
49         struct cfg80211_registered_device *result = NULL, *rdev;
50
51         if (!wiphy_idx_valid(wiphy_idx))
52                 return NULL;
53
54         assert_cfg80211_lock();
55
56         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
57                 if (rdev->wiphy_idx == wiphy_idx) {
58                         result = rdev;
59                         break;
60                 }
61         }
62
63         return result;
64 }
65
66 int get_wiphy_idx(struct wiphy *wiphy)
67 {
68         struct cfg80211_registered_device *rdev;
69         if (!wiphy)
70                 return WIPHY_IDX_STALE;
71         rdev = wiphy_to_dev(wiphy);
72         return rdev->wiphy_idx;
73 }
74
75 /* requires cfg80211_rdev_mutex to be held! */
76 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
77 {
78         struct cfg80211_registered_device *rdev;
79
80         if (!wiphy_idx_valid(wiphy_idx))
81                 return NULL;
82
83         assert_cfg80211_lock();
84
85         rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
86         if (!rdev)
87                 return NULL;
88         return &rdev->wiphy;
89 }
90
91 /* requires cfg80211_mutex to be held! */
92 struct cfg80211_registered_device *
93 __cfg80211_rdev_from_info(struct genl_info *info)
94 {
95         int ifindex;
96         struct cfg80211_registered_device *bywiphyidx = NULL, *byifidx = NULL;
97         struct net_device *dev;
98         int err = -EINVAL;
99
100         assert_cfg80211_lock();
101
102         if (info->attrs[NL80211_ATTR_WIPHY]) {
103                 bywiphyidx = cfg80211_rdev_by_wiphy_idx(
104                                 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY]));
105                 err = -ENODEV;
106         }
107
108         if (info->attrs[NL80211_ATTR_IFINDEX]) {
109                 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
110                 dev = dev_get_by_index(genl_info_net(info), ifindex);
111                 if (dev) {
112                         if (dev->ieee80211_ptr)
113                                 byifidx =
114                                         wiphy_to_dev(dev->ieee80211_ptr->wiphy);
115                         dev_put(dev);
116                 }
117                 err = -ENODEV;
118         }
119
120         if (bywiphyidx && byifidx) {
121                 if (bywiphyidx != byifidx)
122                         return ERR_PTR(-EINVAL);
123                 else
124                         return bywiphyidx; /* == byifidx */
125         }
126         if (bywiphyidx)
127                 return bywiphyidx;
128
129         if (byifidx)
130                 return byifidx;
131
132         return ERR_PTR(err);
133 }
134
135 struct cfg80211_registered_device *
136 cfg80211_get_dev_from_info(struct genl_info *info)
137 {
138         struct cfg80211_registered_device *rdev;
139
140         mutex_lock(&cfg80211_mutex);
141         rdev = __cfg80211_rdev_from_info(info);
142
143         /* if it is not an error we grab the lock on
144          * it to assure it won't be going away while
145          * we operate on it */
146         if (!IS_ERR(rdev))
147                 mutex_lock(&rdev->mtx);
148
149         mutex_unlock(&cfg80211_mutex);
150
151         return rdev;
152 }
153
154 struct cfg80211_registered_device *
155 cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
156 {
157         struct cfg80211_registered_device *rdev = ERR_PTR(-ENODEV);
158         struct net_device *dev;
159
160         mutex_lock(&cfg80211_mutex);
161         dev = dev_get_by_index(net, ifindex);
162         if (!dev)
163                 goto out;
164         if (dev->ieee80211_ptr) {
165                 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
166                 mutex_lock(&rdev->mtx);
167         } else
168                 rdev = ERR_PTR(-ENODEV);
169         dev_put(dev);
170  out:
171         mutex_unlock(&cfg80211_mutex);
172         return rdev;
173 }
174
175 /* requires cfg80211_mutex to be held */
176 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
177                         char *newname)
178 {
179         struct cfg80211_registered_device *rdev2;
180         int wiphy_idx, taken = -1, result, digits;
181
182         assert_cfg80211_lock();
183
184         /* prohibit calling the thing phy%d when %d is not its number */
185         sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
186         if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
187                 /* count number of places needed to print wiphy_idx */
188                 digits = 1;
189                 while (wiphy_idx /= 10)
190                         digits++;
191                 /*
192                  * deny the name if it is phy<idx> where <idx> is printed
193                  * without leading zeroes. taken == strlen(newname) here
194                  */
195                 if (taken == strlen(PHY_NAME) + digits)
196                         return -EINVAL;
197         }
198
199
200         /* Ignore nop renames */
201         if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
202                 return 0;
203
204         /* Ensure another device does not already have this name. */
205         list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
206                 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0)
207                         return -EINVAL;
208
209         result = device_rename(&rdev->wiphy.dev, newname);
210         if (result)
211                 return result;
212
213         if (rdev->wiphy.debugfsdir &&
214             !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
215                             rdev->wiphy.debugfsdir,
216                             rdev->wiphy.debugfsdir->d_parent,
217                             newname))
218                 printk(KERN_ERR "cfg80211: failed to rename debugfs dir to %s!\n",
219                        newname);
220
221         nl80211_notify_dev_rename(rdev);
222
223         return 0;
224 }
225
226 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
227                           struct net *net)
228 {
229         struct wireless_dev *wdev;
230         int err = 0;
231
232         if (!rdev->wiphy.netnsok)
233                 return -EOPNOTSUPP;
234
235         list_for_each_entry(wdev, &rdev->netdev_list, list) {
236                 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
237                 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
238                 if (err)
239                         break;
240                 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
241         }
242
243         if (err) {
244                 /* failed -- clean up to old netns */
245                 net = wiphy_net(&rdev->wiphy);
246
247                 list_for_each_entry_continue_reverse(wdev, &rdev->netdev_list,
248                                                      list) {
249                         wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
250                         err = dev_change_net_namespace(wdev->netdev, net,
251                                                         "wlan%d");
252                         WARN_ON(err);
253                         wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
254                 }
255         }
256
257         wiphy_net_set(&rdev->wiphy, net);
258
259         return err;
260 }
261
262 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
263 {
264         struct cfg80211_registered_device *rdev = data;
265
266         rdev->ops->rfkill_poll(&rdev->wiphy);
267 }
268
269 static int cfg80211_rfkill_set_block(void *data, bool blocked)
270 {
271         struct cfg80211_registered_device *rdev = data;
272         struct wireless_dev *wdev;
273
274         if (!blocked)
275                 return 0;
276
277         rtnl_lock();
278         mutex_lock(&rdev->devlist_mtx);
279
280         list_for_each_entry(wdev, &rdev->netdev_list, list)
281                 dev_close(wdev->netdev);
282
283         mutex_unlock(&rdev->devlist_mtx);
284         rtnl_unlock();
285
286         return 0;
287 }
288
289 static void cfg80211_rfkill_sync_work(struct work_struct *work)
290 {
291         struct cfg80211_registered_device *rdev;
292
293         rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
294         cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
295 }
296
297 static void cfg80211_event_work(struct work_struct *work)
298 {
299         struct cfg80211_registered_device *rdev;
300
301         rdev = container_of(work, struct cfg80211_registered_device,
302                             event_work);
303
304         rtnl_lock();
305         cfg80211_lock_rdev(rdev);
306
307         cfg80211_process_rdev_events(rdev);
308         cfg80211_unlock_rdev(rdev);
309         rtnl_unlock();
310 }
311
312 /* exported functions */
313
314 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
315 {
316         static int wiphy_counter;
317
318         struct cfg80211_registered_device *rdev;
319         int alloc_size;
320
321         WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
322         WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
323         WARN_ON(ops->connect && !ops->disconnect);
324         WARN_ON(ops->join_ibss && !ops->leave_ibss);
325         WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
326         WARN_ON(ops->add_station && !ops->del_station);
327         WARN_ON(ops->add_mpath && !ops->del_mpath);
328
329         alloc_size = sizeof(*rdev) + sizeof_priv;
330
331         rdev = kzalloc(alloc_size, GFP_KERNEL);
332         if (!rdev)
333                 return NULL;
334
335         rdev->ops = ops;
336
337         mutex_lock(&cfg80211_mutex);
338
339         rdev->wiphy_idx = wiphy_counter++;
340
341         if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) {
342                 wiphy_counter--;
343                 mutex_unlock(&cfg80211_mutex);
344                 /* ugh, wrapped! */
345                 kfree(rdev);
346                 return NULL;
347         }
348
349         mutex_unlock(&cfg80211_mutex);
350
351         /* give it a proper name */
352         dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
353
354         mutex_init(&rdev->mtx);
355         mutex_init(&rdev->devlist_mtx);
356         INIT_LIST_HEAD(&rdev->netdev_list);
357         spin_lock_init(&rdev->bss_lock);
358         INIT_LIST_HEAD(&rdev->bss_list);
359         INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
360
361         device_initialize(&rdev->wiphy.dev);
362         rdev->wiphy.dev.class = &ieee80211_class;
363         rdev->wiphy.dev.platform_data = rdev;
364
365         rdev->wiphy.ps_default = CONFIG_CFG80211_DEFAULT_PS_VALUE;
366
367         wiphy_net_set(&rdev->wiphy, &init_net);
368
369         rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
370         rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
371                                    &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
372                                    &rdev->rfkill_ops, rdev);
373
374         if (!rdev->rfkill) {
375                 kfree(rdev);
376                 return NULL;
377         }
378
379         INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
380         INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
381         INIT_WORK(&rdev->event_work, cfg80211_event_work);
382
383         init_waitqueue_head(&rdev->dev_wait);
384
385         /*
386          * Initialize wiphy parameters to IEEE 802.11 MIB default values.
387          * Fragmentation and RTS threshold are disabled by default with the
388          * special -1 value.
389          */
390         rdev->wiphy.retry_short = 7;
391         rdev->wiphy.retry_long = 4;
392         rdev->wiphy.frag_threshold = (u32) -1;
393         rdev->wiphy.rts_threshold = (u32) -1;
394
395         return &rdev->wiphy;
396 }
397 EXPORT_SYMBOL(wiphy_new);
398
399 int wiphy_register(struct wiphy *wiphy)
400 {
401         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
402         int res;
403         enum ieee80211_band band;
404         struct ieee80211_supported_band *sband;
405         bool have_band = false;
406         int i;
407         u16 ifmodes = wiphy->interface_modes;
408
409         /* sanity check ifmodes */
410         WARN_ON(!ifmodes);
411         ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1;
412         if (WARN_ON(ifmodes != wiphy->interface_modes))
413                 wiphy->interface_modes = ifmodes;
414
415         /* sanity check supported bands/channels */
416         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
417                 sband = wiphy->bands[band];
418                 if (!sband)
419                         continue;
420
421                 sband->band = band;
422
423                 if (WARN_ON(!sband->n_channels || !sband->n_bitrates))
424                         return -EINVAL;
425
426                 /*
427                  * Since we use a u32 for rate bitmaps in
428                  * ieee80211_get_response_rate, we cannot
429                  * have more than 32 legacy rates.
430                  */
431                 if (WARN_ON(sband->n_bitrates > 32))
432                         return -EINVAL;
433
434                 for (i = 0; i < sband->n_channels; i++) {
435                         sband->channels[i].orig_flags =
436                                 sband->channels[i].flags;
437                         sband->channels[i].orig_mag =
438                                 sband->channels[i].max_antenna_gain;
439                         sband->channels[i].orig_mpwr =
440                                 sband->channels[i].max_power;
441                         sband->channels[i].band = band;
442                 }
443
444                 have_band = true;
445         }
446
447         if (!have_band) {
448                 WARN_ON(1);
449                 return -EINVAL;
450         }
451
452         /* check and set up bitrates */
453         ieee80211_set_bitrate_flags(wiphy);
454
455         res = device_add(&rdev->wiphy.dev);
456         if (res)
457                 return res;
458
459         res = rfkill_register(rdev->rfkill);
460         if (res)
461                 goto out_rm_dev;
462
463         mutex_lock(&cfg80211_mutex);
464
465         /* set up regulatory info */
466         wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
467
468         list_add(&rdev->list, &cfg80211_rdev_list);
469         cfg80211_rdev_list_generation++;
470
471         mutex_unlock(&cfg80211_mutex);
472
473         /* add to debugfs */
474         rdev->wiphy.debugfsdir =
475                 debugfs_create_dir(wiphy_name(&rdev->wiphy),
476                                    ieee80211_debugfs_dir);
477         if (IS_ERR(rdev->wiphy.debugfsdir))
478                 rdev->wiphy.debugfsdir = NULL;
479
480         if (wiphy->custom_regulatory) {
481                 struct regulatory_request request;
482
483                 request.wiphy_idx = get_wiphy_idx(wiphy);
484                 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
485                 request.alpha2[0] = '9';
486                 request.alpha2[1] = '9';
487
488                 nl80211_send_reg_change_event(&request);
489         }
490
491         cfg80211_debugfs_rdev_add(rdev);
492
493         return 0;
494
495  out_rm_dev:
496         device_del(&rdev->wiphy.dev);
497         return res;
498 }
499 EXPORT_SYMBOL(wiphy_register);
500
501 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
502 {
503         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
504
505         if (!rdev->ops->rfkill_poll)
506                 return;
507         rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
508         rfkill_resume_polling(rdev->rfkill);
509 }
510 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
511
512 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
513 {
514         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
515
516         rfkill_pause_polling(rdev->rfkill);
517 }
518 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
519
520 void wiphy_unregister(struct wiphy *wiphy)
521 {
522         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
523
524         rfkill_unregister(rdev->rfkill);
525
526         /* protect the device list */
527         mutex_lock(&cfg80211_mutex);
528
529         wait_event(rdev->dev_wait, ({
530                 int __count;
531                 mutex_lock(&rdev->devlist_mtx);
532                 __count = rdev->opencount;
533                 mutex_unlock(&rdev->devlist_mtx);
534                 __count == 0;}));
535
536         mutex_lock(&rdev->devlist_mtx);
537         BUG_ON(!list_empty(&rdev->netdev_list));
538         mutex_unlock(&rdev->devlist_mtx);
539
540         /*
541          * First remove the hardware from everywhere, this makes
542          * it impossible to find from userspace.
543          */
544         cfg80211_debugfs_rdev_del(rdev);
545         list_del(&rdev->list);
546
547         /*
548          * Try to grab rdev->mtx. If a command is still in progress,
549          * hopefully the driver will refuse it since it's tearing
550          * down the device already. We wait for this command to complete
551          * before unlinking the item from the list.
552          * Note: as codified by the BUG_ON above we cannot get here if
553          * a virtual interface is still present. Hence, we can only get
554          * to lock contention here if userspace issues a command that
555          * identified the hardware by wiphy index.
556          */
557         cfg80211_lock_rdev(rdev);
558         /* nothing */
559         cfg80211_unlock_rdev(rdev);
560
561         /* If this device got a regulatory hint tell core its
562          * free to listen now to a new shiny device regulatory hint */
563         reg_device_remove(wiphy);
564
565         cfg80211_rdev_list_generation++;
566         device_del(&rdev->wiphy.dev);
567         debugfs_remove(rdev->wiphy.debugfsdir);
568
569         mutex_unlock(&cfg80211_mutex);
570
571         flush_work(&rdev->scan_done_wk);
572         cancel_work_sync(&rdev->conn_work);
573         flush_work(&rdev->event_work);
574 }
575 EXPORT_SYMBOL(wiphy_unregister);
576
577 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
578 {
579         struct cfg80211_internal_bss *scan, *tmp;
580         rfkill_destroy(rdev->rfkill);
581         mutex_destroy(&rdev->mtx);
582         mutex_destroy(&rdev->devlist_mtx);
583         list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
584                 cfg80211_put_bss(&scan->pub);
585         kfree(rdev);
586 }
587
588 void wiphy_free(struct wiphy *wiphy)
589 {
590         put_device(&wiphy->dev);
591 }
592 EXPORT_SYMBOL(wiphy_free);
593
594 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
595 {
596         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
597
598         if (rfkill_set_hw_state(rdev->rfkill, blocked))
599                 schedule_work(&rdev->rfkill_sync);
600 }
601 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
602
603 static void wdev_cleanup_work(struct work_struct *work)
604 {
605         struct wireless_dev *wdev;
606         struct cfg80211_registered_device *rdev;
607
608         wdev = container_of(work, struct wireless_dev, cleanup_work);
609         rdev = wiphy_to_dev(wdev->wiphy);
610
611         cfg80211_lock_rdev(rdev);
612
613         if (WARN_ON(rdev->scan_req && rdev->scan_req->dev == wdev->netdev)) {
614                 rdev->scan_req->aborted = true;
615                 ___cfg80211_scan_done(rdev, true);
616         }
617
618         cfg80211_unlock_rdev(rdev);
619
620         mutex_lock(&rdev->devlist_mtx);
621         rdev->opencount--;
622         mutex_unlock(&rdev->devlist_mtx);
623         wake_up(&rdev->dev_wait);
624
625         dev_put(wdev->netdev);
626 }
627
628 static struct device_type wiphy_type = {
629         .name   = "wlan",
630 };
631
632 static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
633                                          unsigned long state,
634                                          void *ndev)
635 {
636         struct net_device *dev = ndev;
637         struct wireless_dev *wdev = dev->ieee80211_ptr;
638         struct cfg80211_registered_device *rdev;
639
640         if (!wdev)
641                 return NOTIFY_DONE;
642
643         rdev = wiphy_to_dev(wdev->wiphy);
644
645         WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
646
647         switch (state) {
648         case NETDEV_POST_INIT:
649                 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
650                 break;
651         case NETDEV_REGISTER:
652                 /*
653                  * NB: cannot take rdev->mtx here because this may be
654                  * called within code protected by it when interfaces
655                  * are added with nl80211.
656                  */
657                 mutex_init(&wdev->mtx);
658                 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
659                 INIT_LIST_HEAD(&wdev->event_list);
660                 spin_lock_init(&wdev->event_lock);
661                 mutex_lock(&rdev->devlist_mtx);
662                 list_add(&wdev->list, &rdev->netdev_list);
663                 rdev->devlist_generation++;
664                 /* can only change netns with wiphy */
665                 dev->features |= NETIF_F_NETNS_LOCAL;
666
667                 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
668                                       "phy80211")) {
669                         printk(KERN_ERR "wireless: failed to add phy80211 "
670                                 "symlink to netdev!\n");
671                 }
672                 wdev->netdev = dev;
673                 wdev->sme_state = CFG80211_SME_IDLE;
674                 mutex_unlock(&rdev->devlist_mtx);
675 #ifdef CONFIG_WIRELESS_EXT
676                 if (!dev->wireless_handlers)
677                         dev->wireless_handlers = &cfg80211_wext_handler;
678                 wdev->wext.default_key = -1;
679                 wdev->wext.default_mgmt_key = -1;
680                 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
681                 wdev->wext.ps = wdev->wiphy->ps_default;
682                 wdev->wext.ps_timeout = 100;
683                 if (rdev->ops->set_power_mgmt)
684                         if (rdev->ops->set_power_mgmt(wdev->wiphy, dev,
685                                                       wdev->wext.ps,
686                                                       wdev->wext.ps_timeout)) {
687                                 /* assume this means it's off */
688                                 wdev->wext.ps = false;
689                         }
690 #endif
691                 break;
692         case NETDEV_GOING_DOWN:
693                 switch (wdev->iftype) {
694                 case NL80211_IFTYPE_ADHOC:
695                         cfg80211_leave_ibss(rdev, dev, true);
696                         break;
697                 case NL80211_IFTYPE_STATION:
698                         wdev_lock(wdev);
699 #ifdef CONFIG_WIRELESS_EXT
700                         kfree(wdev->wext.ie);
701                         wdev->wext.ie = NULL;
702                         wdev->wext.ie_len = 0;
703                         wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
704 #endif
705                         __cfg80211_disconnect(rdev, dev,
706                                               WLAN_REASON_DEAUTH_LEAVING, true);
707                         cfg80211_mlme_down(rdev, dev);
708                         wdev_unlock(wdev);
709                         break;
710                 default:
711                         break;
712                 }
713                 break;
714         case NETDEV_DOWN:
715                 dev_hold(dev);
716                 schedule_work(&wdev->cleanup_work);
717                 break;
718         case NETDEV_UP:
719                 /*
720                  * If we have a really quick DOWN/UP succession we may
721                  * have this work still pending ... cancel it and see
722                  * if it was pending, in which case we need to account
723                  * for some of the work it would have done.
724                  */
725                 if (cancel_work_sync(&wdev->cleanup_work)) {
726                         mutex_lock(&rdev->devlist_mtx);
727                         rdev->opencount--;
728                         mutex_unlock(&rdev->devlist_mtx);
729                         dev_put(dev);
730                 }
731 #ifdef CONFIG_WIRELESS_EXT
732                 cfg80211_lock_rdev(rdev);
733                 mutex_lock(&rdev->devlist_mtx);
734                 wdev_lock(wdev);
735                 switch (wdev->iftype) {
736                 case NL80211_IFTYPE_ADHOC:
737                         cfg80211_ibss_wext_join(rdev, wdev);
738                         break;
739                 case NL80211_IFTYPE_STATION:
740                         cfg80211_mgd_wext_connect(rdev, wdev);
741                         break;
742                 default:
743                         break;
744                 }
745                 wdev_unlock(wdev);
746                 rdev->opencount++;
747                 mutex_unlock(&rdev->devlist_mtx);
748                 cfg80211_unlock_rdev(rdev);
749 #endif
750                 break;
751         case NETDEV_UNREGISTER:
752                 /*
753                  * NB: cannot take rdev->mtx here because this may be
754                  * called within code protected by it when interfaces
755                  * are removed with nl80211.
756                  */
757                 mutex_lock(&rdev->devlist_mtx);
758                 /*
759                  * It is possible to get NETDEV_UNREGISTER
760                  * multiple times. To detect that, check
761                  * that the interface is still on the list
762                  * of registered interfaces, and only then
763                  * remove and clean it up.
764                  */
765                 if (!list_empty(&wdev->list)) {
766                         sysfs_remove_link(&dev->dev.kobj, "phy80211");
767                         list_del_init(&wdev->list);
768                         rdev->devlist_generation++;
769 #ifdef CONFIG_WIRELESS_EXT
770                         kfree(wdev->wext.keys);
771 #endif
772                 }
773                 mutex_unlock(&rdev->devlist_mtx);
774                 break;
775         case NETDEV_PRE_UP:
776                 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
777                         return notifier_from_errno(-EOPNOTSUPP);
778                 if (rfkill_blocked(rdev->rfkill))
779                         return notifier_from_errno(-ERFKILL);
780                 break;
781         }
782
783         return NOTIFY_DONE;
784 }
785
786 static struct notifier_block cfg80211_netdev_notifier = {
787         .notifier_call = cfg80211_netdev_notifier_call,
788 };
789
790 static void __net_exit cfg80211_pernet_exit(struct net *net)
791 {
792         struct cfg80211_registered_device *rdev;
793
794         rtnl_lock();
795         mutex_lock(&cfg80211_mutex);
796         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
797                 if (net_eq(wiphy_net(&rdev->wiphy), net))
798                         WARN_ON(cfg80211_switch_netns(rdev, &init_net));
799         }
800         mutex_unlock(&cfg80211_mutex);
801         rtnl_unlock();
802 }
803
804 static struct pernet_operations cfg80211_pernet_ops = {
805         .exit = cfg80211_pernet_exit,
806 };
807
808 static int __init cfg80211_init(void)
809 {
810         int err;
811
812         err = register_pernet_device(&cfg80211_pernet_ops);
813         if (err)
814                 goto out_fail_pernet;
815
816         err = wiphy_sysfs_init();
817         if (err)
818                 goto out_fail_sysfs;
819
820         err = register_netdevice_notifier(&cfg80211_netdev_notifier);
821         if (err)
822                 goto out_fail_notifier;
823
824         err = nl80211_init();
825         if (err)
826                 goto out_fail_nl80211;
827
828         ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
829
830         err = regulatory_init();
831         if (err)
832                 goto out_fail_reg;
833
834         return 0;
835
836 out_fail_reg:
837         debugfs_remove(ieee80211_debugfs_dir);
838 out_fail_nl80211:
839         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
840 out_fail_notifier:
841         wiphy_sysfs_exit();
842 out_fail_sysfs:
843         unregister_pernet_device(&cfg80211_pernet_ops);
844 out_fail_pernet:
845         return err;
846 }
847 subsys_initcall(cfg80211_init);
848
849 static void cfg80211_exit(void)
850 {
851         debugfs_remove(ieee80211_debugfs_dir);
852         nl80211_exit();
853         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
854         wiphy_sysfs_exit();
855         regulatory_exit();
856         unregister_pernet_device(&cfg80211_pernet_ops);
857 }
858 module_exit(cfg80211_exit);