cfg80211: fix NETDEV_UNREGISTER notifier
[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/rtnetlink.h>
16 #include <net/genetlink.h>
17 #include <net/cfg80211.h>
18 #include "nl80211.h"
19 #include "core.h"
20 #include "sysfs.h"
21 #include "debugfs.h"
22 #include "wext-compat.h"
23
24 /* name for sysfs, %d is appended */
25 #define PHY_NAME "phy"
26
27 MODULE_AUTHOR("Johannes Berg");
28 MODULE_LICENSE("GPL");
29 MODULE_DESCRIPTION("wireless configuration support");
30
31 /* RCU might be appropriate here since we usually
32  * only read the list, and that can happen quite
33  * often because we need to do it for each command */
34 LIST_HEAD(cfg80211_rdev_list);
35
36 /*
37  * This is used to protect the cfg80211_rdev_list, cfg80211_regdomain,
38  * country_ie_regdomain, the reg_beacon_list and the the last regulatory
39  * request receipt (last_request).
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_process_events(struct wireless_dev *wdev)
298 {
299         struct cfg80211_event *ev;
300         unsigned long flags;
301
302         spin_lock_irqsave(&wdev->event_lock, flags);
303         while (!list_empty(&wdev->event_list)) {
304                 ev = list_first_entry(&wdev->event_list,
305                                       struct cfg80211_event, list);
306                 list_del(&ev->list);
307                 spin_unlock_irqrestore(&wdev->event_lock, flags);
308
309                 wdev_lock(wdev);
310                 switch (ev->type) {
311                 case EVENT_CONNECT_RESULT:
312                         __cfg80211_connect_result(
313                                 wdev->netdev, ev->cr.bssid,
314                                 ev->cr.req_ie, ev->cr.req_ie_len,
315                                 ev->cr.resp_ie, ev->cr.resp_ie_len,
316                                 ev->cr.status,
317                                 ev->cr.status == WLAN_STATUS_SUCCESS,
318                                 NULL);
319                         break;
320                 case EVENT_ROAMED:
321                         __cfg80211_roamed(wdev, ev->rm.bssid,
322                                           ev->rm.req_ie, ev->rm.req_ie_len,
323                                           ev->rm.resp_ie, ev->rm.resp_ie_len);
324                         break;
325                 case EVENT_DISCONNECTED:
326                         __cfg80211_disconnected(wdev->netdev,
327                                                 ev->dc.ie, ev->dc.ie_len,
328                                                 ev->dc.reason, true);
329                         break;
330                 case EVENT_IBSS_JOINED:
331                         __cfg80211_ibss_joined(wdev->netdev, ev->ij.bssid);
332                         break;
333                 }
334                 wdev_unlock(wdev);
335
336                 kfree(ev);
337
338                 spin_lock_irqsave(&wdev->event_lock, flags);
339         }
340         spin_unlock_irqrestore(&wdev->event_lock, flags);
341 }
342
343 static void cfg80211_event_work(struct work_struct *work)
344 {
345         struct cfg80211_registered_device *rdev;
346         struct wireless_dev *wdev;
347
348         rdev = container_of(work, struct cfg80211_registered_device,
349                             event_work);
350
351         rtnl_lock();
352         cfg80211_lock_rdev(rdev);
353         mutex_lock(&rdev->devlist_mtx);
354
355         list_for_each_entry(wdev, &rdev->netdev_list, list)
356                 cfg80211_process_events(wdev);
357
358         mutex_unlock(&rdev->devlist_mtx);
359         cfg80211_unlock_rdev(rdev);
360         rtnl_unlock();
361 }
362
363 /* exported functions */
364
365 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
366 {
367         static int wiphy_counter;
368
369         struct cfg80211_registered_device *rdev;
370         int alloc_size;
371
372         WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
373         WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
374         WARN_ON(ops->connect && !ops->disconnect);
375         WARN_ON(ops->join_ibss && !ops->leave_ibss);
376         WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
377         WARN_ON(ops->add_station && !ops->del_station);
378         WARN_ON(ops->add_mpath && !ops->del_mpath);
379
380         alloc_size = sizeof(*rdev) + sizeof_priv;
381
382         rdev = kzalloc(alloc_size, GFP_KERNEL);
383         if (!rdev)
384                 return NULL;
385
386         rdev->ops = ops;
387
388         mutex_lock(&cfg80211_mutex);
389
390         rdev->wiphy_idx = wiphy_counter++;
391
392         if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) {
393                 wiphy_counter--;
394                 mutex_unlock(&cfg80211_mutex);
395                 /* ugh, wrapped! */
396                 kfree(rdev);
397                 return NULL;
398         }
399
400         mutex_unlock(&cfg80211_mutex);
401
402         /* give it a proper name */
403         dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
404
405         mutex_init(&rdev->mtx);
406         mutex_init(&rdev->devlist_mtx);
407         INIT_LIST_HEAD(&rdev->netdev_list);
408         spin_lock_init(&rdev->bss_lock);
409         INIT_LIST_HEAD(&rdev->bss_list);
410         INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
411
412         device_initialize(&rdev->wiphy.dev);
413         rdev->wiphy.dev.class = &ieee80211_class;
414         rdev->wiphy.dev.platform_data = rdev;
415
416         wiphy_net_set(&rdev->wiphy, &init_net);
417
418         rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
419         rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
420                                    &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
421                                    &rdev->rfkill_ops, rdev);
422
423         if (!rdev->rfkill) {
424                 kfree(rdev);
425                 return NULL;
426         }
427
428         INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
429         INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
430         INIT_WORK(&rdev->event_work, cfg80211_event_work);
431
432         /*
433          * Initialize wiphy parameters to IEEE 802.11 MIB default values.
434          * Fragmentation and RTS threshold are disabled by default with the
435          * special -1 value.
436          */
437         rdev->wiphy.retry_short = 7;
438         rdev->wiphy.retry_long = 4;
439         rdev->wiphy.frag_threshold = (u32) -1;
440         rdev->wiphy.rts_threshold = (u32) -1;
441
442         return &rdev->wiphy;
443 }
444 EXPORT_SYMBOL(wiphy_new);
445
446 int wiphy_register(struct wiphy *wiphy)
447 {
448         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
449         int res;
450         enum ieee80211_band band;
451         struct ieee80211_supported_band *sband;
452         bool have_band = false;
453         int i;
454         u16 ifmodes = wiphy->interface_modes;
455
456         /* sanity check ifmodes */
457         WARN_ON(!ifmodes);
458         ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1;
459         if (WARN_ON(ifmodes != wiphy->interface_modes))
460                 wiphy->interface_modes = ifmodes;
461
462         /* sanity check supported bands/channels */
463         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
464                 sband = wiphy->bands[band];
465                 if (!sband)
466                         continue;
467
468                 sband->band = band;
469
470                 if (WARN_ON(!sband->n_channels || !sband->n_bitrates))
471                         return -EINVAL;
472
473                 /*
474                  * Since we use a u32 for rate bitmaps in
475                  * ieee80211_get_response_rate, we cannot
476                  * have more than 32 legacy rates.
477                  */
478                 if (WARN_ON(sband->n_bitrates > 32))
479                         return -EINVAL;
480
481                 for (i = 0; i < sband->n_channels; i++) {
482                         sband->channels[i].orig_flags =
483                                 sband->channels[i].flags;
484                         sband->channels[i].orig_mag =
485                                 sband->channels[i].max_antenna_gain;
486                         sband->channels[i].orig_mpwr =
487                                 sband->channels[i].max_power;
488                         sband->channels[i].band = band;
489                 }
490
491                 have_band = true;
492         }
493
494         if (!have_band) {
495                 WARN_ON(1);
496                 return -EINVAL;
497         }
498
499         /* check and set up bitrates */
500         ieee80211_set_bitrate_flags(wiphy);
501
502         res = device_add(&rdev->wiphy.dev);
503         if (res)
504                 return res;
505
506         res = rfkill_register(rdev->rfkill);
507         if (res)
508                 goto out_rm_dev;
509
510         mutex_lock(&cfg80211_mutex);
511
512         /* set up regulatory info */
513         wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
514
515         list_add(&rdev->list, &cfg80211_rdev_list);
516
517         mutex_unlock(&cfg80211_mutex);
518
519         /* add to debugfs */
520         rdev->wiphy.debugfsdir =
521                 debugfs_create_dir(wiphy_name(&rdev->wiphy),
522                                    ieee80211_debugfs_dir);
523         if (IS_ERR(rdev->wiphy.debugfsdir))
524                 rdev->wiphy.debugfsdir = NULL;
525
526         if (wiphy->custom_regulatory) {
527                 struct regulatory_request request;
528
529                 request.wiphy_idx = get_wiphy_idx(wiphy);
530                 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
531                 request.alpha2[0] = '9';
532                 request.alpha2[1] = '9';
533
534                 nl80211_send_reg_change_event(&request);
535         }
536
537         cfg80211_debugfs_rdev_add(rdev);
538
539         return 0;
540
541  out_rm_dev:
542         device_del(&rdev->wiphy.dev);
543         return res;
544 }
545 EXPORT_SYMBOL(wiphy_register);
546
547 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
548 {
549         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
550
551         if (!rdev->ops->rfkill_poll)
552                 return;
553         rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
554         rfkill_resume_polling(rdev->rfkill);
555 }
556 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
557
558 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
559 {
560         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
561
562         rfkill_pause_polling(rdev->rfkill);
563 }
564 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
565
566 void wiphy_unregister(struct wiphy *wiphy)
567 {
568         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
569
570         rfkill_unregister(rdev->rfkill);
571
572         /* protect the device list */
573         mutex_lock(&cfg80211_mutex);
574
575         BUG_ON(!list_empty(&rdev->netdev_list));
576
577         /*
578          * Try to grab rdev->mtx. If a command is still in progress,
579          * hopefully the driver will refuse it since it's tearing
580          * down the device already. We wait for this command to complete
581          * before unlinking the item from the list.
582          * Note: as codified by the BUG_ON above we cannot get here if
583          * a virtual interface is still associated. Hence, we can only
584          * get to lock contention here if userspace issues a command
585          * that identified the hardware by wiphy index.
586          */
587         mutex_lock(&rdev->mtx);
588         /* unlock again before freeing */
589         mutex_unlock(&rdev->mtx);
590
591         cfg80211_debugfs_rdev_del(rdev);
592
593         /* If this device got a regulatory hint tell core its
594          * free to listen now to a new shiny device regulatory hint */
595         reg_device_remove(wiphy);
596
597         list_del(&rdev->list);
598         device_del(&rdev->wiphy.dev);
599         debugfs_remove(rdev->wiphy.debugfsdir);
600
601         mutex_unlock(&cfg80211_mutex);
602
603         cancel_work_sync(&rdev->conn_work);
604         cancel_work_sync(&rdev->scan_done_wk);
605         kfree(rdev->scan_req);
606         flush_work(&rdev->event_work);
607 }
608 EXPORT_SYMBOL(wiphy_unregister);
609
610 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
611 {
612         struct cfg80211_internal_bss *scan, *tmp;
613         rfkill_destroy(rdev->rfkill);
614         mutex_destroy(&rdev->mtx);
615         mutex_destroy(&rdev->devlist_mtx);
616         list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
617                 cfg80211_put_bss(&scan->pub);
618         kfree(rdev);
619 }
620
621 void wiphy_free(struct wiphy *wiphy)
622 {
623         put_device(&wiphy->dev);
624 }
625 EXPORT_SYMBOL(wiphy_free);
626
627 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
628 {
629         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
630
631         if (rfkill_set_hw_state(rdev->rfkill, blocked))
632                 schedule_work(&rdev->rfkill_sync);
633 }
634 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
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_REGISTER:
653                 mutex_init(&wdev->mtx);
654                 INIT_LIST_HEAD(&wdev->event_list);
655                 spin_lock_init(&wdev->event_lock);
656                 mutex_lock(&rdev->devlist_mtx);
657                 list_add(&wdev->list, &rdev->netdev_list);
658                 /* can only change netns with wiphy */
659                 dev->features |= NETIF_F_NETNS_LOCAL;
660
661                 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
662                                       "phy80211")) {
663                         printk(KERN_ERR "wireless: failed to add phy80211 "
664                                 "symlink to netdev!\n");
665                 }
666                 wdev->netdev = dev;
667                 wdev->sme_state = CFG80211_SME_IDLE;
668                 mutex_unlock(&rdev->devlist_mtx);
669 #ifdef CONFIG_WIRELESS_EXT
670                 if (!dev->wireless_handlers)
671                         dev->wireless_handlers = &cfg80211_wext_handler;
672                 wdev->wext.default_key = -1;
673                 wdev->wext.default_mgmt_key = -1;
674                 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
675                 wdev->wext.ps = CONFIG_CFG80211_DEFAULT_PS_VALUE;
676                 wdev->wext.ps_timeout = 500;
677                 if (rdev->ops->set_power_mgmt)
678                         if (rdev->ops->set_power_mgmt(wdev->wiphy, dev,
679                                                       wdev->wext.ps,
680                                                       wdev->wext.ps_timeout)) {
681                                 /* assume this means it's off */
682                                 wdev->wext.ps = false;
683                         }
684 #endif
685                 break;
686         case NETDEV_GOING_DOWN:
687                 switch (wdev->iftype) {
688                 case NL80211_IFTYPE_ADHOC:
689                         cfg80211_leave_ibss(rdev, dev, true);
690                         break;
691                 case NL80211_IFTYPE_STATION:
692                         wdev_lock(wdev);
693 #ifdef CONFIG_WIRELESS_EXT
694                         kfree(wdev->wext.ie);
695                         wdev->wext.ie = NULL;
696                         wdev->wext.ie_len = 0;
697                         wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
698 #endif
699                         __cfg80211_disconnect(rdev, dev,
700                                               WLAN_REASON_DEAUTH_LEAVING, true);
701                         cfg80211_mlme_down(rdev, dev);
702                         wdev_unlock(wdev);
703                         break;
704                 default:
705                         break;
706                 }
707                 break;
708         case NETDEV_UP:
709 #ifdef CONFIG_WIRELESS_EXT
710                 cfg80211_lock_rdev(rdev);
711                 wdev_lock(wdev);
712                 switch (wdev->iftype) {
713                 case NL80211_IFTYPE_ADHOC:
714                         cfg80211_ibss_wext_join(rdev, wdev);
715                         break;
716                 case NL80211_IFTYPE_STATION:
717                         cfg80211_mgd_wext_connect(rdev, wdev);
718                         break;
719                 default:
720                         break;
721                 }
722                 wdev_unlock(wdev);
723                 cfg80211_unlock_rdev(rdev);
724 #endif
725                 break;
726         case NETDEV_UNREGISTER:
727                 mutex_lock(&rdev->devlist_mtx);
728                 /*
729                  * It is possible to get NETDEV_UNREGISTER
730                  * multiple times. To detect that, check
731                  * that the interface is still on the list
732                  * of registered interfaces, and only then
733                  * remove and clean it up.
734                  */
735                 if (!list_empty(&wdev->list)) {
736                         sysfs_remove_link(&dev->dev.kobj, "phy80211");
737                         list_del_init(&wdev->list);
738                         mutex_destroy(&wdev->mtx);
739 #ifdef CONFIG_WIRELESS_EXT
740                         kfree(wdev->wext.keys);
741 #endif
742                 }
743                 mutex_unlock(&rdev->devlist_mtx);
744                 break;
745         case NETDEV_PRE_UP:
746                 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
747                         return notifier_from_errno(-EOPNOTSUPP);
748                 if (rfkill_blocked(rdev->rfkill))
749                         return notifier_from_errno(-ERFKILL);
750                 break;
751         }
752
753         return NOTIFY_DONE;
754 }
755
756 static struct notifier_block cfg80211_netdev_notifier = {
757         .notifier_call = cfg80211_netdev_notifier_call,
758 };
759
760 static void __net_exit cfg80211_pernet_exit(struct net *net)
761 {
762         struct cfg80211_registered_device *rdev;
763
764         rtnl_lock();
765         mutex_lock(&cfg80211_mutex);
766         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
767                 if (net_eq(wiphy_net(&rdev->wiphy), net))
768                         WARN_ON(cfg80211_switch_netns(rdev, &init_net));
769         }
770         mutex_unlock(&cfg80211_mutex);
771         rtnl_unlock();
772 }
773
774 static struct pernet_operations cfg80211_pernet_ops = {
775         .exit = cfg80211_pernet_exit,
776 };
777
778 static int __init cfg80211_init(void)
779 {
780         int err;
781
782         err = register_pernet_device(&cfg80211_pernet_ops);
783         if (err)
784                 goto out_fail_pernet;
785
786         err = wiphy_sysfs_init();
787         if (err)
788                 goto out_fail_sysfs;
789
790         err = register_netdevice_notifier(&cfg80211_netdev_notifier);
791         if (err)
792                 goto out_fail_notifier;
793
794         err = nl80211_init();
795         if (err)
796                 goto out_fail_nl80211;
797
798         ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
799
800         err = regulatory_init();
801         if (err)
802                 goto out_fail_reg;
803
804         return 0;
805
806 out_fail_reg:
807         debugfs_remove(ieee80211_debugfs_dir);
808 out_fail_nl80211:
809         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
810 out_fail_notifier:
811         wiphy_sysfs_exit();
812 out_fail_sysfs:
813         unregister_pernet_device(&cfg80211_pernet_ops);
814 out_fail_pernet:
815         return err;
816 }
817 subsys_initcall(cfg80211_init);
818
819 static void cfg80211_exit(void)
820 {
821         debugfs_remove(ieee80211_debugfs_dir);
822         nl80211_exit();
823         unregister_netdevice_notifier(&cfg80211_netdev_notifier);
824         wiphy_sysfs_exit();
825         regulatory_exit();
826         unregister_pernet_device(&cfg80211_pernet_ops);
827 }
828 module_exit(cfg80211_exit);