wext: refactor
[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 #ifdef CONFIG_CFG80211_WEXT
362         rdev->wiphy.wext = &cfg80211_wext_handler;
363 #endif
364
365         device_initialize(&rdev->wiphy.dev);
366         rdev->wiphy.dev.class = &ieee80211_class;
367         rdev->wiphy.dev.platform_data = rdev;
368
369         rdev->wiphy.ps_default = CONFIG_CFG80211_DEFAULT_PS_VALUE;
370
371         wiphy_net_set(&rdev->wiphy, &init_net);
372
373         rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
374         rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
375                                    &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
376                                    &rdev->rfkill_ops, rdev);
377
378         if (!rdev->rfkill) {
379                 kfree(rdev);
380                 return NULL;
381         }
382
383         INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
384         INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
385         INIT_WORK(&rdev->event_work, cfg80211_event_work);
386
387         init_waitqueue_head(&rdev->dev_wait);
388
389         /*
390          * Initialize wiphy parameters to IEEE 802.11 MIB default values.
391          * Fragmentation and RTS threshold are disabled by default with the
392          * special -1 value.
393          */
394         rdev->wiphy.retry_short = 7;
395         rdev->wiphy.retry_long = 4;
396         rdev->wiphy.frag_threshold = (u32) -1;
397         rdev->wiphy.rts_threshold = (u32) -1;
398
399         return &rdev->wiphy;
400 }
401 EXPORT_SYMBOL(wiphy_new);
402
403 int wiphy_register(struct wiphy *wiphy)
404 {
405         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
406         int res;
407         enum ieee80211_band band;
408         struct ieee80211_supported_band *sband;
409         bool have_band = false;
410         int i;
411         u16 ifmodes = wiphy->interface_modes;
412
413         /* sanity check ifmodes */
414         WARN_ON(!ifmodes);
415         ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1;
416         if (WARN_ON(ifmodes != wiphy->interface_modes))
417                 wiphy->interface_modes = ifmodes;
418
419         /* sanity check supported bands/channels */
420         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
421                 sband = wiphy->bands[band];
422                 if (!sband)
423                         continue;
424
425                 sband->band = band;
426
427                 if (WARN_ON(!sband->n_channels || !sband->n_bitrates))
428                         return -EINVAL;
429
430                 /*
431                  * Since we use a u32 for rate bitmaps in
432                  * ieee80211_get_response_rate, we cannot
433                  * have more than 32 legacy rates.
434                  */
435                 if (WARN_ON(sband->n_bitrates > 32))
436                         return -EINVAL;
437
438                 for (i = 0; i < sband->n_channels; i++) {
439                         sband->channels[i].orig_flags =
440                                 sband->channels[i].flags;
441                         sband->channels[i].orig_mag =
442                                 sband->channels[i].max_antenna_gain;
443                         sband->channels[i].orig_mpwr =
444                                 sband->channels[i].max_power;
445                         sband->channels[i].band = band;
446                 }
447
448                 have_band = true;
449         }
450
451         if (!have_band) {
452                 WARN_ON(1);
453                 return -EINVAL;
454         }
455
456         /* check and set up bitrates */
457         ieee80211_set_bitrate_flags(wiphy);
458
459         res = device_add(&rdev->wiphy.dev);
460         if (res)
461                 return res;
462
463         res = rfkill_register(rdev->rfkill);
464         if (res)
465                 goto out_rm_dev;
466
467         mutex_lock(&cfg80211_mutex);
468
469         /* set up regulatory info */
470         wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
471
472         list_add(&rdev->list, &cfg80211_rdev_list);
473         cfg80211_rdev_list_generation++;
474
475         mutex_unlock(&cfg80211_mutex);
476
477         /* add to debugfs */
478         rdev->wiphy.debugfsdir =
479                 debugfs_create_dir(wiphy_name(&rdev->wiphy),
480                                    ieee80211_debugfs_dir);
481         if (IS_ERR(rdev->wiphy.debugfsdir))
482                 rdev->wiphy.debugfsdir = NULL;
483
484         if (wiphy->custom_regulatory) {
485                 struct regulatory_request request;
486
487                 request.wiphy_idx = get_wiphy_idx(wiphy);
488                 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
489                 request.alpha2[0] = '9';
490                 request.alpha2[1] = '9';
491
492                 nl80211_send_reg_change_event(&request);
493         }
494
495         cfg80211_debugfs_rdev_add(rdev);
496
497         return 0;
498
499  out_rm_dev:
500         device_del(&rdev->wiphy.dev);
501         return res;
502 }
503 EXPORT_SYMBOL(wiphy_register);
504
505 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
506 {
507         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
508
509         if (!rdev->ops->rfkill_poll)
510                 return;
511         rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
512         rfkill_resume_polling(rdev->rfkill);
513 }
514 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
515
516 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
517 {
518         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
519
520         rfkill_pause_polling(rdev->rfkill);
521 }
522 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
523
524 void wiphy_unregister(struct wiphy *wiphy)
525 {
526         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
527
528         rfkill_unregister(rdev->rfkill);
529
530         /* protect the device list */
531         mutex_lock(&cfg80211_mutex);
532
533         wait_event(rdev->dev_wait, ({
534                 int __count;
535                 mutex_lock(&rdev->devlist_mtx);
536                 __count = rdev->opencount;
537                 mutex_unlock(&rdev->devlist_mtx);
538                 __count == 0;}));
539
540         mutex_lock(&rdev->devlist_mtx);
541         BUG_ON(!list_empty(&rdev->netdev_list));
542         mutex_unlock(&rdev->devlist_mtx);
543
544         /*
545          * First remove the hardware from everywhere, this makes
546          * it impossible to find from userspace.
547          */
548         cfg80211_debugfs_rdev_del(rdev);
549         list_del(&rdev->list);
550
551         /*
552          * Try to grab rdev->mtx. If a command is still in progress,
553          * hopefully the driver will refuse it since it's tearing
554          * down the device already. We wait for this command to complete
555          * before unlinking the item from the list.
556          * Note: as codified by the BUG_ON above we cannot get here if
557          * a virtual interface is still present. Hence, we can only get
558          * to lock contention here if userspace issues a command that
559          * identified the hardware by wiphy index.
560          */
561         cfg80211_lock_rdev(rdev);
562         /* nothing */
563         cfg80211_unlock_rdev(rdev);
564
565         /* If this device got a regulatory hint tell core its
566          * free to listen now to a new shiny device regulatory hint */
567         reg_device_remove(wiphy);
568
569         cfg80211_rdev_list_generation++;
570         device_del(&rdev->wiphy.dev);
571         debugfs_remove(rdev->wiphy.debugfsdir);
572
573         mutex_unlock(&cfg80211_mutex);
574
575         flush_work(&rdev->scan_done_wk);
576         cancel_work_sync(&rdev->conn_work);
577         flush_work(&rdev->event_work);
578 }
579 EXPORT_SYMBOL(wiphy_unregister);
580
581 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
582 {
583         struct cfg80211_internal_bss *scan, *tmp;
584         rfkill_destroy(rdev->rfkill);
585         mutex_destroy(&rdev->mtx);
586         mutex_destroy(&rdev->devlist_mtx);
587         list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
588                 cfg80211_put_bss(&scan->pub);
589         kfree(rdev);
590 }
591
592 void wiphy_free(struct wiphy *wiphy)
593 {
594         put_device(&wiphy->dev);
595 }
596 EXPORT_SYMBOL(wiphy_free);
597
598 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
599 {
600         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
601
602         if (rfkill_set_hw_state(rdev->rfkill, blocked))
603                 schedule_work(&rdev->rfkill_sync);
604 }
605 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
606
607 static void wdev_cleanup_work(struct work_struct *work)
608 {
609         struct wireless_dev *wdev;
610         struct cfg80211_registered_device *rdev;
611
612         wdev = container_of(work, struct wireless_dev, cleanup_work);
613         rdev = wiphy_to_dev(wdev->wiphy);
614
615         cfg80211_lock_rdev(rdev);
616
617         if (WARN_ON(rdev->scan_req && rdev->scan_req->dev == wdev->netdev)) {
618                 rdev->scan_req->aborted = true;
619                 ___cfg80211_scan_done(rdev, true);
620         }
621
622         cfg80211_unlock_rdev(rdev);
623
624         mutex_lock(&rdev->devlist_mtx);
625         rdev->opencount--;
626         mutex_unlock(&rdev->devlist_mtx);
627         wake_up(&rdev->dev_wait);
628
629         dev_put(wdev->netdev);
630 }
631
632 static struct device_type wiphy_type = {
633         .name   = "wlan",
634 };
635
636 static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
637                                          unsigned long state,
638                                          void *ndev)
639 {
640         struct net_device *dev = ndev;
641         struct wireless_dev *wdev = dev->ieee80211_ptr;
642         struct cfg80211_registered_device *rdev;
643
644         if (!wdev)
645                 return NOTIFY_DONE;
646
647         rdev = wiphy_to_dev(wdev->wiphy);
648
649         WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
650
651         switch (state) {
652         case NETDEV_POST_INIT:
653                 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
654                 break;
655         case NETDEV_REGISTER:
656                 /*
657                  * NB: cannot take rdev->mtx here because this may be
658                  * called within code protected by it when interfaces
659                  * are added with nl80211.
660                  */
661                 mutex_init(&wdev->mtx);
662                 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
663                 INIT_LIST_HEAD(&wdev->event_list);
664                 spin_lock_init(&wdev->event_lock);
665                 mutex_lock(&rdev->devlist_mtx);
666                 list_add(&wdev->list, &rdev->netdev_list);
667                 rdev->devlist_generation++;
668                 /* can only change netns with wiphy */
669                 dev->features |= NETIF_F_NETNS_LOCAL;
670
671                 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
672                                       "phy80211")) {
673                         printk(KERN_ERR "wireless: failed to add phy80211 "
674                                 "symlink to netdev!\n");
675                 }
676                 wdev->netdev = dev;
677                 wdev->sme_state = CFG80211_SME_IDLE;
678                 mutex_unlock(&rdev->devlist_mtx);
679 #ifdef CONFIG_CFG80211_WEXT
680                 wdev->wext.default_key = -1;
681                 wdev->wext.default_mgmt_key = -1;
682                 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
683                 wdev->wext.ps = wdev->wiphy->ps_default;
684                 wdev->wext.ps_timeout = 100;
685                 if (rdev->ops->set_power_mgmt)
686                         if (rdev->ops->set_power_mgmt(wdev->wiphy, dev,
687                                                       wdev->wext.ps,
688                                                       wdev->wext.ps_timeout)) {
689                                 /* assume this means it's off */
690                                 wdev->wext.ps = false;
691                         }
692 #endif
693                 break;
694         case NETDEV_GOING_DOWN:
695                 switch (wdev->iftype) {
696                 case NL80211_IFTYPE_ADHOC:
697                         cfg80211_leave_ibss(rdev, dev, true);
698                         break;
699                 case NL80211_IFTYPE_STATION:
700                         wdev_lock(wdev);
701 #ifdef CONFIG_CFG80211_WEXT
702                         kfree(wdev->wext.ie);
703                         wdev->wext.ie = NULL;
704                         wdev->wext.ie_len = 0;
705                         wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
706 #endif
707                         __cfg80211_disconnect(rdev, dev,
708                                               WLAN_REASON_DEAUTH_LEAVING, true);
709                         cfg80211_mlme_down(rdev, dev);
710                         wdev_unlock(wdev);
711                         break;
712                 default:
713                         break;
714                 }
715                 break;
716         case NETDEV_DOWN:
717                 dev_hold(dev);
718                 schedule_work(&wdev->cleanup_work);
719                 break;
720         case NETDEV_UP:
721                 /*
722                  * If we have a really quick DOWN/UP succession we may
723                  * have this work still pending ... cancel it and see
724                  * if it was pending, in which case we need to account
725                  * for some of the work it would have done.
726                  */
727                 if (cancel_work_sync(&wdev->cleanup_work)) {
728                         mutex_lock(&rdev->devlist_mtx);
729                         rdev->opencount--;
730                         mutex_unlock(&rdev->devlist_mtx);
731                         dev_put(dev);
732                 }
733 #ifdef CONFIG_CFG80211_WEXT
734                 cfg80211_lock_rdev(rdev);
735                 mutex_lock(&rdev->devlist_mtx);
736                 wdev_lock(wdev);
737                 switch (wdev->iftype) {
738                 case NL80211_IFTYPE_ADHOC:
739                         cfg80211_ibss_wext_join(rdev, wdev);
740                         break;
741                 case NL80211_IFTYPE_STATION:
742                         cfg80211_mgd_wext_connect(rdev, wdev);
743                         break;
744                 default:
745                         break;
746                 }
747                 wdev_unlock(wdev);
748                 rdev->opencount++;
749                 mutex_unlock(&rdev->devlist_mtx);
750                 cfg80211_unlock_rdev(rdev);
751 #endif
752                 break;
753         case NETDEV_UNREGISTER:
754                 /*
755                  * NB: cannot take rdev->mtx here because this may be
756                  * called within code protected by it when interfaces
757                  * are removed with nl80211.
758                  */
759                 mutex_lock(&rdev->devlist_mtx);
760                 /*
761                  * It is possible to get NETDEV_UNREGISTER
762                  * multiple times. To detect that, check
763                  * that the interface is still on the list
764                  * of registered interfaces, and only then
765                  * remove and clean it up.
766                  */
767                 if (!list_empty(&wdev->list)) {
768                         sysfs_remove_link(&dev->dev.kobj, "phy80211");
769                         list_del_init(&wdev->list);
770                         rdev->devlist_generation++;
771 #ifdef CONFIG_CFG80211_WEXT
772                         kfree(wdev->wext.keys);
773 #endif
774                 }
775                 mutex_unlock(&rdev->devlist_mtx);
776                 break;
777         case NETDEV_PRE_UP:
778                 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
779                         return notifier_from_errno(-EOPNOTSUPP);
780                 if (rfkill_blocked(rdev->rfkill))
781                         return notifier_from_errno(-ERFKILL);
782                 break;
783         }
784
785         return NOTIFY_DONE;
786 }
787
788 static struct notifier_block cfg80211_netdev_notifier = {
789         .notifier_call = cfg80211_netdev_notifier_call,
790 };
791
792 static void __net_exit cfg80211_pernet_exit(struct net *net)
793 {
794         struct cfg80211_registered_device *rdev;
795
796         rtnl_lock();
797         mutex_lock(&cfg80211_mutex);
798         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
799                 if (net_eq(wiphy_net(&rdev->wiphy), net))
800                         WARN_ON(cfg80211_switch_netns(rdev, &init_net));
801         }
802         mutex_unlock(&cfg80211_mutex);
803         rtnl_unlock();
804 }
805
806 static struct pernet_operations cfg80211_pernet_ops = {
807         .exit = cfg80211_pernet_exit,
808 };
809
810 static int __init cfg80211_init(void)
811 {
812         int err;
813
814         err = register_pernet_device(&cfg80211_pernet_ops);
815         if (err)
816                 goto out_fail_pernet;
817
818         err = wiphy_sysfs_init();
819         if (err)
820                 goto out_fail_sysfs;
821
822         err = register_netdevice_notifier(&cfg80211_netdev_notifier);
823         if (err)
824                 goto out_fail_notifier;
825
826         err = nl80211_init();
827         if (err)
828                 goto out_fail_nl80211;
829
830         ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
831
832         err = regulatory_init();
833         if (err)
834                 goto out_fail_reg;
835
836         return 0;
837
838 out_fail_reg:
839         debugfs_remove(ieee80211_debugfs_dir);
840 out_fail_nl80211:
841         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
842 out_fail_notifier:
843         wiphy_sysfs_exit();
844 out_fail_sysfs:
845         unregister_pernet_device(&cfg80211_pernet_ops);
846 out_fail_pernet:
847         return err;
848 }
849 subsys_initcall(cfg80211_init);
850
851 static void cfg80211_exit(void)
852 {
853         debugfs_remove(ieee80211_debugfs_dir);
854         nl80211_exit();
855         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
856         wiphy_sysfs_exit();
857         regulatory_exit();
858         unregister_pernet_device(&cfg80211_pernet_ops);
859 }
860 module_exit(cfg80211_exit);