blob: 62e1ac00879b72df5d7014c314dc299802969055 [file] [log] [blame]
Johannes Berg704232c2007-04-23 12:20:05 -07001/*
2 * This is the linux wireless configuration interface.
3 *
Johannes Berg08645122009-05-11 13:54:58 +02004 * Copyright 2006-2009 Johannes Berg <johannes@sipsolutions.net>
Johannes Berg704232c2007-04-23 12:20:05 -07005 */
6
7#include <linux/if.h>
8#include <linux/module.h>
9#include <linux/err.h>
Johannes Berg704232c2007-04-23 12:20:05 -070010#include <linux/list.h>
11#include <linux/nl80211.h>
12#include <linux/debugfs.h>
13#include <linux/notifier.h>
14#include <linux/device.h>
Johannes Berg1f87f7d2009-06-02 13:01:41 +020015#include <linux/rtnetlink.h>
Johannes Berg704232c2007-04-23 12:20:05 -070016#include <net/genetlink.h>
17#include <net/cfg80211.h>
Johannes Berg55682962007-09-20 13:09:35 -040018#include "nl80211.h"
Johannes Berg704232c2007-04-23 12:20:05 -070019#include "core.h"
20#include "sysfs.h"
Luis R. Rodriguez1ac61302009-05-02 00:37:21 -040021#include "debugfs.h"
Johannes Berga9a11622009-07-27 12:01:53 +020022#include "wext-compat.h"
Johannes Berg704232c2007-04-23 12:20:05 -070023
24/* name for sysfs, %d is appended */
25#define PHY_NAME "phy"
26
27MODULE_AUTHOR("Johannes Berg");
28MODULE_LICENSE("GPL");
29MODULE_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 */
Johannes Berg79c97e92009-07-07 03:56:12 +020034LIST_HEAD(cfg80211_rdev_list);
Johannes Bergf5ea9122009-08-07 16:17:38 +020035int cfg80211_rdev_list_generation;
Luis R. Rodrigueza1794392009-02-21 00:04:21 -050036
37/*
Luis R. Rodriguezabc73812009-07-30 17:38:08 -070038 * This is used to protect the cfg80211_rdev_list
Luis R. Rodrigueza1794392009-02-21 00:04:21 -050039 */
40DEFINE_MUTEX(cfg80211_mutex);
Johannes Berg704232c2007-04-23 12:20:05 -070041
42/* for debugfs */
43static struct dentry *ieee80211_debugfs_dir;
44
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050045/* requires cfg80211_mutex to be held! */
Johannes Berg79c97e92009-07-07 03:56:12 +020046struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
Johannes Berg55682962007-09-20 13:09:35 -040047{
Johannes Berg79c97e92009-07-07 03:56:12 +020048 struct cfg80211_registered_device *result = NULL, *rdev;
Johannes Berg55682962007-09-20 13:09:35 -040049
Luis R. Rodriguez85fd1292009-02-21 00:04:20 -050050 if (!wiphy_idx_valid(wiphy_idx))
51 return NULL;
52
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -050053 assert_cfg80211_lock();
54
Johannes Berg79c97e92009-07-07 03:56:12 +020055 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
56 if (rdev->wiphy_idx == wiphy_idx) {
57 result = rdev;
Johannes Berg55682962007-09-20 13:09:35 -040058 break;
59 }
60 }
61
62 return result;
63}
64
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050065int get_wiphy_idx(struct wiphy *wiphy)
66{
Johannes Berg79c97e92009-07-07 03:56:12 +020067 struct cfg80211_registered_device *rdev;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050068 if (!wiphy)
69 return WIPHY_IDX_STALE;
Johannes Berg79c97e92009-07-07 03:56:12 +020070 rdev = wiphy_to_dev(wiphy);
71 return rdev->wiphy_idx;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050072}
73
Johannes Berg79c97e92009-07-07 03:56:12 +020074/* requires cfg80211_rdev_mutex to be held! */
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050075struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
76{
Johannes Berg79c97e92009-07-07 03:56:12 +020077 struct cfg80211_registered_device *rdev;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050078
79 if (!wiphy_idx_valid(wiphy_idx))
80 return NULL;
81
82 assert_cfg80211_lock();
83
Johannes Berg79c97e92009-07-07 03:56:12 +020084 rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
85 if (!rdev)
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050086 return NULL;
Johannes Berg79c97e92009-07-07 03:56:12 +020087 return &rdev->wiphy;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050088}
89
Luis R. Rodrigueza1794392009-02-21 00:04:21 -050090/* requires cfg80211_mutex to be held! */
Johannes Berg4bbf4d52009-03-24 09:35:46 +010091struct cfg80211_registered_device *
Johannes Berg79c97e92009-07-07 03:56:12 +020092__cfg80211_rdev_from_info(struct genl_info *info)
Johannes Berg55682962007-09-20 13:09:35 -040093{
94 int ifindex;
Luis R. Rodriguezb5850a72009-02-21 00:04:19 -050095 struct cfg80211_registered_device *bywiphyidx = NULL, *byifidx = NULL;
Johannes Berg55682962007-09-20 13:09:35 -040096 struct net_device *dev;
97 int err = -EINVAL;
98
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -050099 assert_cfg80211_lock();
100
Johannes Berg55682962007-09-20 13:09:35 -0400101 if (info->attrs[NL80211_ATTR_WIPHY]) {
Johannes Berg79c97e92009-07-07 03:56:12 +0200102 bywiphyidx = cfg80211_rdev_by_wiphy_idx(
Johannes Berg55682962007-09-20 13:09:35 -0400103 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY]));
104 err = -ENODEV;
105 }
106
107 if (info->attrs[NL80211_ATTR_IFINDEX]) {
108 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
Johannes Berg463d0182009-07-14 00:33:35 +0200109 dev = dev_get_by_index(genl_info_net(info), ifindex);
Johannes Berg55682962007-09-20 13:09:35 -0400110 if (dev) {
111 if (dev->ieee80211_ptr)
112 byifidx =
113 wiphy_to_dev(dev->ieee80211_ptr->wiphy);
114 dev_put(dev);
115 }
116 err = -ENODEV;
117 }
118
Luis R. Rodriguezb5850a72009-02-21 00:04:19 -0500119 if (bywiphyidx && byifidx) {
120 if (bywiphyidx != byifidx)
Johannes Berg55682962007-09-20 13:09:35 -0400121 return ERR_PTR(-EINVAL);
122 else
Luis R. Rodriguezb5850a72009-02-21 00:04:19 -0500123 return bywiphyidx; /* == byifidx */
Johannes Berg55682962007-09-20 13:09:35 -0400124 }
Luis R. Rodriguezb5850a72009-02-21 00:04:19 -0500125 if (bywiphyidx)
126 return bywiphyidx;
Johannes Berg55682962007-09-20 13:09:35 -0400127
128 if (byifidx)
129 return byifidx;
130
131 return ERR_PTR(err);
132}
133
134struct cfg80211_registered_device *
135cfg80211_get_dev_from_info(struct genl_info *info)
136{
Johannes Berg79c97e92009-07-07 03:56:12 +0200137 struct cfg80211_registered_device *rdev;
Johannes Berg55682962007-09-20 13:09:35 -0400138
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500139 mutex_lock(&cfg80211_mutex);
Johannes Berg79c97e92009-07-07 03:56:12 +0200140 rdev = __cfg80211_rdev_from_info(info);
Johannes Berg55682962007-09-20 13:09:35 -0400141
142 /* if it is not an error we grab the lock on
143 * it to assure it won't be going away while
144 * we operate on it */
Johannes Berg79c97e92009-07-07 03:56:12 +0200145 if (!IS_ERR(rdev))
146 mutex_lock(&rdev->mtx);
Johannes Berg55682962007-09-20 13:09:35 -0400147
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500148 mutex_unlock(&cfg80211_mutex);
Johannes Berg55682962007-09-20 13:09:35 -0400149
Johannes Berg79c97e92009-07-07 03:56:12 +0200150 return rdev;
Johannes Berg55682962007-09-20 13:09:35 -0400151}
152
153struct cfg80211_registered_device *
Johannes Berg463d0182009-07-14 00:33:35 +0200154cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
Johannes Berg55682962007-09-20 13:09:35 -0400155{
Johannes Berg79c97e92009-07-07 03:56:12 +0200156 struct cfg80211_registered_device *rdev = ERR_PTR(-ENODEV);
Johannes Berg55682962007-09-20 13:09:35 -0400157 struct net_device *dev;
158
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500159 mutex_lock(&cfg80211_mutex);
Johannes Berg463d0182009-07-14 00:33:35 +0200160 dev = dev_get_by_index(net, ifindex);
Johannes Berg55682962007-09-20 13:09:35 -0400161 if (!dev)
162 goto out;
163 if (dev->ieee80211_ptr) {
Johannes Berg79c97e92009-07-07 03:56:12 +0200164 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
165 mutex_lock(&rdev->mtx);
Johannes Berg55682962007-09-20 13:09:35 -0400166 } else
Johannes Berg79c97e92009-07-07 03:56:12 +0200167 rdev = ERR_PTR(-ENODEV);
Johannes Berg55682962007-09-20 13:09:35 -0400168 dev_put(dev);
169 out:
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500170 mutex_unlock(&cfg80211_mutex);
Johannes Berg79c97e92009-07-07 03:56:12 +0200171 return rdev;
Johannes Berg55682962007-09-20 13:09:35 -0400172}
173
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100174/* requires cfg80211_mutex to be held */
Johannes Berg55682962007-09-20 13:09:35 -0400175int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
176 char *newname)
177{
Johannes Berg79c97e92009-07-07 03:56:12 +0200178 struct cfg80211_registered_device *rdev2;
Luis R. Rodriguezb5850a72009-02-21 00:04:19 -0500179 int wiphy_idx, taken = -1, result, digits;
Johannes Berg55682962007-09-20 13:09:35 -0400180
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100181 assert_cfg80211_lock();
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700182
Johannes Berg55682962007-09-20 13:09:35 -0400183 /* prohibit calling the thing phy%d when %d is not its number */
Luis R. Rodriguezb5850a72009-02-21 00:04:19 -0500184 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
185 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
186 /* count number of places needed to print wiphy_idx */
Johannes Berg55682962007-09-20 13:09:35 -0400187 digits = 1;
Luis R. Rodriguezb5850a72009-02-21 00:04:19 -0500188 while (wiphy_idx /= 10)
Johannes Berg55682962007-09-20 13:09:35 -0400189 digits++;
190 /*
191 * deny the name if it is phy<idx> where <idx> is printed
192 * without leading zeroes. taken == strlen(newname) here
193 */
194 if (taken == strlen(PHY_NAME) + digits)
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100195 return -EINVAL;
Johannes Berg55682962007-09-20 13:09:35 -0400196 }
197
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700198
199 /* Ignore nop renames */
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700200 if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100201 return 0;
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700202
203 /* Ensure another device does not already have this name. */
Johannes Berg79c97e92009-07-07 03:56:12 +0200204 list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
205 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0)
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100206 return -EINVAL;
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700207
Johannes Berg55682962007-09-20 13:09:35 -0400208 result = device_rename(&rdev->wiphy.dev, newname);
209 if (result)
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100210 return result;
Johannes Berg55682962007-09-20 13:09:35 -0400211
Johannes Berg33c03602008-10-08 10:23:48 +0200212 if (rdev->wiphy.debugfsdir &&
213 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
Johannes Berg55682962007-09-20 13:09:35 -0400214 rdev->wiphy.debugfsdir,
215 rdev->wiphy.debugfsdir->d_parent,
216 newname))
217 printk(KERN_ERR "cfg80211: failed to rename debugfs dir to %s!\n",
218 newname);
219
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100220 nl80211_notify_dev_rename(rdev);
Johannes Berg55682962007-09-20 13:09:35 -0400221
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100222 return 0;
Johannes Berg55682962007-09-20 13:09:35 -0400223}
224
Johannes Berg463d0182009-07-14 00:33:35 +0200225int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
226 struct net *net)
227{
228 struct wireless_dev *wdev;
229 int err = 0;
230
231 if (!rdev->wiphy.netnsok)
232 return -EOPNOTSUPP;
233
234 list_for_each_entry(wdev, &rdev->netdev_list, list) {
235 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
236 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
237 if (err)
238 break;
239 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
240 }
241
242 if (err) {
243 /* failed -- clean up to old netns */
244 net = wiphy_net(&rdev->wiphy);
245
246 list_for_each_entry_continue_reverse(wdev, &rdev->netdev_list,
247 list) {
248 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
249 err = dev_change_net_namespace(wdev->netdev, net,
250 "wlan%d");
251 WARN_ON(err);
252 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
253 }
254 }
255
256 wiphy_net_set(&rdev->wiphy, net);
257
258 return err;
259}
260
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200261static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
262{
Johannes Berg79c97e92009-07-07 03:56:12 +0200263 struct cfg80211_registered_device *rdev = data;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200264
Johannes Berg79c97e92009-07-07 03:56:12 +0200265 rdev->ops->rfkill_poll(&rdev->wiphy);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200266}
267
268static int cfg80211_rfkill_set_block(void *data, bool blocked)
269{
Johannes Berg79c97e92009-07-07 03:56:12 +0200270 struct cfg80211_registered_device *rdev = data;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200271 struct wireless_dev *wdev;
272
273 if (!blocked)
274 return 0;
275
276 rtnl_lock();
Johannes Berg79c97e92009-07-07 03:56:12 +0200277 mutex_lock(&rdev->devlist_mtx);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200278
Johannes Berg79c97e92009-07-07 03:56:12 +0200279 list_for_each_entry(wdev, &rdev->netdev_list, list)
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200280 dev_close(wdev->netdev);
281
Johannes Berg79c97e92009-07-07 03:56:12 +0200282 mutex_unlock(&rdev->devlist_mtx);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200283 rtnl_unlock();
284
285 return 0;
286}
287
288static void cfg80211_rfkill_sync_work(struct work_struct *work)
289{
Johannes Berg79c97e92009-07-07 03:56:12 +0200290 struct cfg80211_registered_device *rdev;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200291
Johannes Berg79c97e92009-07-07 03:56:12 +0200292 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
293 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200294}
295
Johannes Berg667503d2009-07-07 03:56:11 +0200296static void cfg80211_process_events(struct wireless_dev *wdev)
297{
298 struct cfg80211_event *ev;
299 unsigned long flags;
300
301 spin_lock_irqsave(&wdev->event_lock, flags);
302 while (!list_empty(&wdev->event_list)) {
303 ev = list_first_entry(&wdev->event_list,
304 struct cfg80211_event, list);
305 list_del(&ev->list);
306 spin_unlock_irqrestore(&wdev->event_lock, flags);
307
308 wdev_lock(wdev);
309 switch (ev->type) {
310 case EVENT_CONNECT_RESULT:
311 __cfg80211_connect_result(
312 wdev->netdev, ev->cr.bssid,
313 ev->cr.req_ie, ev->cr.req_ie_len,
314 ev->cr.resp_ie, ev->cr.resp_ie_len,
315 ev->cr.status,
Johannes Bergdf7fc0f2009-07-29 11:23:49 +0200316 ev->cr.status == WLAN_STATUS_SUCCESS,
317 NULL);
Johannes Berg667503d2009-07-07 03:56:11 +0200318 break;
319 case EVENT_ROAMED:
320 __cfg80211_roamed(wdev, ev->rm.bssid,
321 ev->rm.req_ie, ev->rm.req_ie_len,
322 ev->rm.resp_ie, ev->rm.resp_ie_len);
323 break;
324 case EVENT_DISCONNECTED:
325 __cfg80211_disconnected(wdev->netdev,
326 ev->dc.ie, ev->dc.ie_len,
327 ev->dc.reason, true);
328 break;
329 case EVENT_IBSS_JOINED:
330 __cfg80211_ibss_joined(wdev->netdev, ev->ij.bssid);
331 break;
332 }
333 wdev_unlock(wdev);
334
335 kfree(ev);
336
337 spin_lock_irqsave(&wdev->event_lock, flags);
338 }
339 spin_unlock_irqrestore(&wdev->event_lock, flags);
340}
341
342static void cfg80211_event_work(struct work_struct *work)
343{
344 struct cfg80211_registered_device *rdev;
345 struct wireless_dev *wdev;
346
347 rdev = container_of(work, struct cfg80211_registered_device,
348 event_work);
349
350 rtnl_lock();
351 cfg80211_lock_rdev(rdev);
352 mutex_lock(&rdev->devlist_mtx);
353
354 list_for_each_entry(wdev, &rdev->netdev_list, list)
355 cfg80211_process_events(wdev);
356
357 mutex_unlock(&rdev->devlist_mtx);
358 cfg80211_unlock_rdev(rdev);
359 rtnl_unlock();
360}
361
Johannes Berg704232c2007-04-23 12:20:05 -0700362/* exported functions */
363
David Kilroy3dcf6702009-05-16 23:13:46 +0100364struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
Johannes Berg704232c2007-04-23 12:20:05 -0700365{
Denis ChengRq638af072008-09-23 02:35:37 +0800366 static int wiphy_counter;
367
Johannes Berg79c97e92009-07-07 03:56:12 +0200368 struct cfg80211_registered_device *rdev;
Johannes Berg704232c2007-04-23 12:20:05 -0700369 int alloc_size;
370
Johannes Berg0b206332009-07-07 03:56:13 +0200371 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
372 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
373 WARN_ON(ops->connect && !ops->disconnect);
374 WARN_ON(ops->join_ibss && !ops->leave_ibss);
375 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
376 WARN_ON(ops->add_station && !ops->del_station);
377 WARN_ON(ops->add_mpath && !ops->del_mpath);
Johannes Berg41ade002007-12-19 02:03:29 +0100378
Johannes Berg79c97e92009-07-07 03:56:12 +0200379 alloc_size = sizeof(*rdev) + sizeof_priv;
Johannes Berg704232c2007-04-23 12:20:05 -0700380
Johannes Berg79c97e92009-07-07 03:56:12 +0200381 rdev = kzalloc(alloc_size, GFP_KERNEL);
382 if (!rdev)
Johannes Berg704232c2007-04-23 12:20:05 -0700383 return NULL;
384
Johannes Berg79c97e92009-07-07 03:56:12 +0200385 rdev->ops = ops;
Johannes Berg704232c2007-04-23 12:20:05 -0700386
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500387 mutex_lock(&cfg80211_mutex);
Johannes Berg704232c2007-04-23 12:20:05 -0700388
Johannes Berg79c97e92009-07-07 03:56:12 +0200389 rdev->wiphy_idx = wiphy_counter++;
Johannes Berga4d73ee2007-04-26 20:50:35 -0700390
Johannes Berg79c97e92009-07-07 03:56:12 +0200391 if (unlikely(!wiphy_idx_valid(rdev->wiphy_idx))) {
Denis ChengRq638af072008-09-23 02:35:37 +0800392 wiphy_counter--;
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500393 mutex_unlock(&cfg80211_mutex);
Johannes Berg704232c2007-04-23 12:20:05 -0700394 /* ugh, wrapped! */
Johannes Berg79c97e92009-07-07 03:56:12 +0200395 kfree(rdev);
Johannes Berg704232c2007-04-23 12:20:05 -0700396 return NULL;
397 }
Johannes Berg704232c2007-04-23 12:20:05 -0700398
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500399 mutex_unlock(&cfg80211_mutex);
Denis ChengRq638af072008-09-23 02:35:37 +0800400
Johannes Berg704232c2007-04-23 12:20:05 -0700401 /* give it a proper name */
Johannes Berg79c97e92009-07-07 03:56:12 +0200402 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
Johannes Berg704232c2007-04-23 12:20:05 -0700403
Johannes Berg79c97e92009-07-07 03:56:12 +0200404 mutex_init(&rdev->mtx);
405 mutex_init(&rdev->devlist_mtx);
406 INIT_LIST_HEAD(&rdev->netdev_list);
407 spin_lock_init(&rdev->bss_lock);
408 INIT_LIST_HEAD(&rdev->bss_list);
409 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
Johannes Berg704232c2007-04-23 12:20:05 -0700410
Johannes Berg79c97e92009-07-07 03:56:12 +0200411 device_initialize(&rdev->wiphy.dev);
412 rdev->wiphy.dev.class = &ieee80211_class;
413 rdev->wiphy.dev.platform_data = rdev;
Johannes Berg704232c2007-04-23 12:20:05 -0700414
Johannes Berg463d0182009-07-14 00:33:35 +0200415 wiphy_net_set(&rdev->wiphy, &init_net);
416
Johannes Berg79c97e92009-07-07 03:56:12 +0200417 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
418 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
419 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
420 &rdev->rfkill_ops, rdev);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200421
Johannes Berg79c97e92009-07-07 03:56:12 +0200422 if (!rdev->rfkill) {
423 kfree(rdev);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200424 return NULL;
425 }
426
Johannes Berg79c97e92009-07-07 03:56:12 +0200427 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
428 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
429 INIT_WORK(&rdev->event_work, cfg80211_event_work);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200430
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +0200431 /*
432 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
433 * Fragmentation and RTS threshold are disabled by default with the
434 * special -1 value.
435 */
Johannes Berg79c97e92009-07-07 03:56:12 +0200436 rdev->wiphy.retry_short = 7;
437 rdev->wiphy.retry_long = 4;
438 rdev->wiphy.frag_threshold = (u32) -1;
439 rdev->wiphy.rts_threshold = (u32) -1;
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +0200440
Johannes Berg79c97e92009-07-07 03:56:12 +0200441 return &rdev->wiphy;
Johannes Berg704232c2007-04-23 12:20:05 -0700442}
443EXPORT_SYMBOL(wiphy_new);
444
445int wiphy_register(struct wiphy *wiphy)
446{
Johannes Berg79c97e92009-07-07 03:56:12 +0200447 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg704232c2007-04-23 12:20:05 -0700448 int res;
Johannes Berg8318d782008-01-24 19:38:38 +0100449 enum ieee80211_band band;
450 struct ieee80211_supported_band *sband;
451 bool have_band = false;
452 int i;
Luis R. Rodriguezf59ac042008-08-29 16:26:43 -0700453 u16 ifmodes = wiphy->interface_modes;
454
455 /* sanity check ifmodes */
456 WARN_ON(!ifmodes);
457 ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1;
458 if (WARN_ON(ifmodes != wiphy->interface_modes))
459 wiphy->interface_modes = ifmodes;
Johannes Berg8318d782008-01-24 19:38:38 +0100460
461 /* sanity check supported bands/channels */
462 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
463 sband = wiphy->bands[band];
464 if (!sband)
465 continue;
466
467 sband->band = band;
468
Johannes Berg881d9482009-01-21 15:13:48 +0100469 if (WARN_ON(!sband->n_channels || !sband->n_bitrates))
Johannes Berg8318d782008-01-24 19:38:38 +0100470 return -EINVAL;
Johannes Berg881d9482009-01-21 15:13:48 +0100471
472 /*
473 * Since we use a u32 for rate bitmaps in
474 * ieee80211_get_response_rate, we cannot
475 * have more than 32 legacy rates.
476 */
477 if (WARN_ON(sband->n_bitrates > 32))
478 return -EINVAL;
Johannes Berg8318d782008-01-24 19:38:38 +0100479
480 for (i = 0; i < sband->n_channels; i++) {
481 sband->channels[i].orig_flags =
482 sband->channels[i].flags;
483 sband->channels[i].orig_mag =
484 sband->channels[i].max_antenna_gain;
485 sband->channels[i].orig_mpwr =
486 sband->channels[i].max_power;
487 sband->channels[i].band = band;
488 }
489
490 have_band = true;
491 }
492
493 if (!have_band) {
494 WARN_ON(1);
495 return -EINVAL;
496 }
497
498 /* check and set up bitrates */
499 ieee80211_set_bitrate_flags(wiphy);
500
Johannes Berg79c97e92009-07-07 03:56:12 +0200501 res = device_add(&rdev->wiphy.dev);
Johannes Berg704232c2007-04-23 12:20:05 -0700502 if (res)
Johannes Berg2f0accc2009-06-10 16:50:29 +0200503 return res;
Johannes Berg704232c2007-04-23 12:20:05 -0700504
Johannes Berg79c97e92009-07-07 03:56:12 +0200505 res = rfkill_register(rdev->rfkill);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200506 if (res)
507 goto out_rm_dev;
508
Johannes Berg2f0accc2009-06-10 16:50:29 +0200509 mutex_lock(&cfg80211_mutex);
510
511 /* set up regulatory info */
512 wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
513
Johannes Berg79c97e92009-07-07 03:56:12 +0200514 list_add(&rdev->list, &cfg80211_rdev_list);
Johannes Bergf5ea9122009-08-07 16:17:38 +0200515 cfg80211_rdev_list_generation++;
Johannes Berg704232c2007-04-23 12:20:05 -0700516
Johannes Berg2f0accc2009-06-10 16:50:29 +0200517 mutex_unlock(&cfg80211_mutex);
518
Johannes Berg704232c2007-04-23 12:20:05 -0700519 /* add to debugfs */
Johannes Berg79c97e92009-07-07 03:56:12 +0200520 rdev->wiphy.debugfsdir =
521 debugfs_create_dir(wiphy_name(&rdev->wiphy),
Johannes Berg704232c2007-04-23 12:20:05 -0700522 ieee80211_debugfs_dir);
Johannes Berg79c97e92009-07-07 03:56:12 +0200523 if (IS_ERR(rdev->wiphy.debugfsdir))
524 rdev->wiphy.debugfsdir = NULL;
Johannes Berg704232c2007-04-23 12:20:05 -0700525
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -0400526 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
Johannes Berg79c97e92009-07-07 03:56:12 +0200537 cfg80211_debugfs_rdev_add(rdev);
Luis R. Rodriguez1ac61302009-05-02 00:37:21 -0400538
Johannes Berg2f0accc2009-06-10 16:50:29 +0200539 return 0;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200540
541 out_rm_dev:
Johannes Berg79c97e92009-07-07 03:56:12 +0200542 device_del(&rdev->wiphy.dev);
Johannes Berg704232c2007-04-23 12:20:05 -0700543 return res;
544}
545EXPORT_SYMBOL(wiphy_register);
546
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200547void wiphy_rfkill_start_polling(struct wiphy *wiphy)
548{
Johannes Berg79c97e92009-07-07 03:56:12 +0200549 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200550
Johannes Berg79c97e92009-07-07 03:56:12 +0200551 if (!rdev->ops->rfkill_poll)
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200552 return;
Johannes Berg79c97e92009-07-07 03:56:12 +0200553 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
554 rfkill_resume_polling(rdev->rfkill);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200555}
556EXPORT_SYMBOL(wiphy_rfkill_start_polling);
557
558void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
559{
Johannes Berg79c97e92009-07-07 03:56:12 +0200560 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200561
Johannes Berg79c97e92009-07-07 03:56:12 +0200562 rfkill_pause_polling(rdev->rfkill);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200563}
564EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
565
Johannes Berg704232c2007-04-23 12:20:05 -0700566void wiphy_unregister(struct wiphy *wiphy)
567{
Johannes Berg79c97e92009-07-07 03:56:12 +0200568 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg704232c2007-04-23 12:20:05 -0700569
Johannes Berg79c97e92009-07-07 03:56:12 +0200570 rfkill_unregister(rdev->rfkill);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200571
Johannes Bergf16bfc12007-04-26 20:51:12 -0700572 /* protect the device list */
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500573 mutex_lock(&cfg80211_mutex);
Johannes Berg704232c2007-04-23 12:20:05 -0700574
Johannes Berg79c97e92009-07-07 03:56:12 +0200575 BUG_ON(!list_empty(&rdev->netdev_list));
Johannes Bergf16bfc12007-04-26 20:51:12 -0700576
577 /*
Johannes Berg79c97e92009-07-07 03:56:12 +0200578 * Try to grab rdev->mtx. If a command is still in progress,
Johannes Bergf16bfc12007-04-26 20:51:12 -0700579 * 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 */
Johannes Berg79c97e92009-07-07 03:56:12 +0200587 mutex_lock(&rdev->mtx);
Johannes Bergf16bfc12007-04-26 20:51:12 -0700588 /* unlock again before freeing */
Johannes Berg79c97e92009-07-07 03:56:12 +0200589 mutex_unlock(&rdev->mtx);
Johannes Berg704232c2007-04-23 12:20:05 -0700590
Johannes Berg79c97e92009-07-07 03:56:12 +0200591 cfg80211_debugfs_rdev_del(rdev);
Luis R. Rodriguez1ac61302009-05-02 00:37:21 -0400592
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800593 /* 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
Johannes Berg79c97e92009-07-07 03:56:12 +0200597 list_del(&rdev->list);
Johannes Bergf5ea9122009-08-07 16:17:38 +0200598 cfg80211_rdev_list_generation++;
Johannes Berg79c97e92009-07-07 03:56:12 +0200599 device_del(&rdev->wiphy.dev);
600 debugfs_remove(rdev->wiphy.debugfsdir);
Johannes Berg704232c2007-04-23 12:20:05 -0700601
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500602 mutex_unlock(&cfg80211_mutex);
Johannes Berg66825882009-07-13 13:24:44 +0200603
604 cancel_work_sync(&rdev->conn_work);
605 cancel_work_sync(&rdev->scan_done_wk);
606 kfree(rdev->scan_req);
607 flush_work(&rdev->event_work);
Johannes Berg704232c2007-04-23 12:20:05 -0700608}
609EXPORT_SYMBOL(wiphy_unregister);
610
Johannes Berg79c97e92009-07-07 03:56:12 +0200611void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
Johannes Berg704232c2007-04-23 12:20:05 -0700612{
Johannes Berg2a519312009-02-10 21:25:55 +0100613 struct cfg80211_internal_bss *scan, *tmp;
Johannes Berg79c97e92009-07-07 03:56:12 +0200614 rfkill_destroy(rdev->rfkill);
615 mutex_destroy(&rdev->mtx);
616 mutex_destroy(&rdev->devlist_mtx);
617 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
Johannes Berg78c1c7e2009-02-10 21:25:57 +0100618 cfg80211_put_bss(&scan->pub);
Johannes Berg79c97e92009-07-07 03:56:12 +0200619 kfree(rdev);
Johannes Berg704232c2007-04-23 12:20:05 -0700620}
621
622void wiphy_free(struct wiphy *wiphy)
623{
624 put_device(&wiphy->dev);
625}
626EXPORT_SYMBOL(wiphy_free);
627
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200628void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
629{
Johannes Berg79c97e92009-07-07 03:56:12 +0200630 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200631
Johannes Berg79c97e92009-07-07 03:56:12 +0200632 if (rfkill_set_hw_state(rdev->rfkill, blocked))
633 schedule_work(&rdev->rfkill_sync);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200634}
635EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
636
Johannes Berg704232c2007-04-23 12:20:05 -0700637static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
638 unsigned long state,
639 void *ndev)
640{
641 struct net_device *dev = ndev;
Johannes Berg2a783c12009-07-01 21:26:45 +0200642 struct wireless_dev *wdev = dev->ieee80211_ptr;
Johannes Berg704232c2007-04-23 12:20:05 -0700643 struct cfg80211_registered_device *rdev;
644
Johannes Berg2a783c12009-07-01 21:26:45 +0200645 if (!wdev)
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200646 return NOTIFY_DONE;
Johannes Berg704232c2007-04-23 12:20:05 -0700647
Johannes Berg2a783c12009-07-01 21:26:45 +0200648 rdev = wiphy_to_dev(wdev->wiphy);
Johannes Berg704232c2007-04-23 12:20:05 -0700649
Johannes Berg2a783c12009-07-01 21:26:45 +0200650 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
Johannes Berg60719ff2008-09-16 14:55:09 +0200651
Johannes Berg704232c2007-04-23 12:20:05 -0700652 switch (state) {
653 case NETDEV_REGISTER:
Johannes Berg667503d2009-07-07 03:56:11 +0200654 mutex_init(&wdev->mtx);
655 INIT_LIST_HEAD(&wdev->event_list);
656 spin_lock_init(&wdev->event_lock);
Johannes Berg704232c2007-04-23 12:20:05 -0700657 mutex_lock(&rdev->devlist_mtx);
Johannes Berg2a783c12009-07-01 21:26:45 +0200658 list_add(&wdev->list, &rdev->netdev_list);
Johannes Bergf5ea9122009-08-07 16:17:38 +0200659 rdev->devlist_generation++;
Johannes Berg463d0182009-07-14 00:33:35 +0200660 /* can only change netns with wiphy */
661 dev->features |= NETIF_F_NETNS_LOCAL;
662
Johannes Berg704232c2007-04-23 12:20:05 -0700663 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
664 "phy80211")) {
665 printk(KERN_ERR "wireless: failed to add phy80211 "
666 "symlink to netdev!\n");
667 }
Johannes Berg2a783c12009-07-01 21:26:45 +0200668 wdev->netdev = dev;
Samuel Ortizb23aa672009-07-01 21:26:54 +0200669 wdev->sme_state = CFG80211_SME_IDLE;
Johannes Bergbc92afd2009-07-01 21:26:57 +0200670 mutex_unlock(&rdev->devlist_mtx);
Johannes Berg08645122009-05-11 13:54:58 +0200671#ifdef CONFIG_WIRELESS_EXT
Johannes Berga9a11622009-07-27 12:01:53 +0200672 if (!dev->wireless_handlers)
673 dev->wireless_handlers = &cfg80211_wext_handler;
Johannes Berg2a783c12009-07-01 21:26:45 +0200674 wdev->wext.default_key = -1;
675 wdev->wext.default_mgmt_key = -1;
Johannes Bergf2129352009-07-01 21:26:56 +0200676 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
Johannes Bergbc92afd2009-07-01 21:26:57 +0200677 wdev->wext.ps = CONFIG_CFG80211_DEFAULT_PS_VALUE;
Johannes Berg75e6c3b2009-07-31 11:18:13 +0200678 wdev->wext.ps_timeout = 100;
Johannes Bergbc92afd2009-07-01 21:26:57 +0200679 if (rdev->ops->set_power_mgmt)
680 if (rdev->ops->set_power_mgmt(wdev->wiphy, dev,
681 wdev->wext.ps,
682 wdev->wext.ps_timeout)) {
683 /* assume this means it's off */
684 wdev->wext.ps = false;
685 }
Johannes Berg08645122009-05-11 13:54:58 +0200686#endif
Johannes Berg704232c2007-04-23 12:20:05 -0700687 break;
Johannes Berg04a773a2009-04-19 21:24:32 +0200688 case NETDEV_GOING_DOWN:
Samuel Ortizb23aa672009-07-01 21:26:54 +0200689 switch (wdev->iftype) {
690 case NL80211_IFTYPE_ADHOC:
691 cfg80211_leave_ibss(rdev, dev, true);
692 break;
693 case NL80211_IFTYPE_STATION:
Johannes Berg667503d2009-07-07 03:56:11 +0200694 wdev_lock(wdev);
Johannes Bergf2129352009-07-01 21:26:56 +0200695#ifdef CONFIG_WIRELESS_EXT
696 kfree(wdev->wext.ie);
697 wdev->wext.ie = NULL;
698 wdev->wext.ie_len = 0;
Johannes Berg0eb14642009-07-02 15:49:03 +0200699 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
Johannes Bergf2129352009-07-01 21:26:56 +0200700#endif
Johannes Berg667503d2009-07-07 03:56:11 +0200701 __cfg80211_disconnect(rdev, dev,
702 WLAN_REASON_DEAUTH_LEAVING, true);
Johannes Berg19957bb2009-07-02 17:20:43 +0200703 cfg80211_mlme_down(rdev, dev);
Johannes Berg667503d2009-07-07 03:56:11 +0200704 wdev_unlock(wdev);
Samuel Ortizb23aa672009-07-01 21:26:54 +0200705 break;
706 default:
707 break;
708 }
Johannes Berg04a773a2009-04-19 21:24:32 +0200709 break;
710 case NETDEV_UP:
711#ifdef CONFIG_WIRELESS_EXT
Johannes Berg667503d2009-07-07 03:56:11 +0200712 cfg80211_lock_rdev(rdev);
713 wdev_lock(wdev);
Johannes Bergf2129352009-07-01 21:26:56 +0200714 switch (wdev->iftype) {
715 case NL80211_IFTYPE_ADHOC:
Johannes Bergfffd0932009-07-08 14:22:54 +0200716 cfg80211_ibss_wext_join(rdev, wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200717 break;
Johannes Bergf2129352009-07-01 21:26:56 +0200718 case NL80211_IFTYPE_STATION:
Johannes Bergfffd0932009-07-08 14:22:54 +0200719 cfg80211_mgd_wext_connect(rdev, wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200720 break;
Johannes Bergf2129352009-07-01 21:26:56 +0200721 default:
722 break;
723 }
Johannes Berg667503d2009-07-07 03:56:11 +0200724 wdev_unlock(wdev);
725 cfg80211_unlock_rdev(rdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200726#endif
Johannes Berg2a783c12009-07-01 21:26:45 +0200727 break;
Johannes Berg704232c2007-04-23 12:20:05 -0700728 case NETDEV_UNREGISTER:
729 mutex_lock(&rdev->devlist_mtx);
Johannes Berge40cbda2009-07-30 14:04:01 +0200730 /*
731 * It is possible to get NETDEV_UNREGISTER
732 * multiple times. To detect that, check
733 * that the interface is still on the list
734 * of registered interfaces, and only then
735 * remove and clean it up.
736 */
Johannes Berg2a783c12009-07-01 21:26:45 +0200737 if (!list_empty(&wdev->list)) {
Johannes Berg704232c2007-04-23 12:20:05 -0700738 sysfs_remove_link(&dev->dev.kobj, "phy80211");
Johannes Berg2a783c12009-07-01 21:26:45 +0200739 list_del_init(&wdev->list);
Johannes Bergf5ea9122009-08-07 16:17:38 +0200740 rdev->devlist_generation++;
Johannes Berge40cbda2009-07-30 14:04:01 +0200741 mutex_destroy(&wdev->mtx);
742#ifdef CONFIG_WIRELESS_EXT
743 kfree(wdev->wext.keys);
744#endif
Johannes Berg704232c2007-04-23 12:20:05 -0700745 }
746 mutex_unlock(&rdev->devlist_mtx);
747 break;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200748 case NETDEV_PRE_UP:
Johannes Berg0b206332009-07-07 03:56:13 +0200749 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
750 return notifier_from_errno(-EOPNOTSUPP);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200751 if (rfkill_blocked(rdev->rfkill))
752 return notifier_from_errno(-ERFKILL);
753 break;
Johannes Berg704232c2007-04-23 12:20:05 -0700754 }
755
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200756 return NOTIFY_DONE;
Johannes Berg704232c2007-04-23 12:20:05 -0700757}
758
759static struct notifier_block cfg80211_netdev_notifier = {
760 .notifier_call = cfg80211_netdev_notifier_call,
761};
762
Johannes Berg463d0182009-07-14 00:33:35 +0200763static void __net_exit cfg80211_pernet_exit(struct net *net)
764{
765 struct cfg80211_registered_device *rdev;
766
767 rtnl_lock();
768 mutex_lock(&cfg80211_mutex);
769 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
770 if (net_eq(wiphy_net(&rdev->wiphy), net))
771 WARN_ON(cfg80211_switch_netns(rdev, &init_net));
772 }
773 mutex_unlock(&cfg80211_mutex);
774 rtnl_unlock();
775}
776
777static struct pernet_operations cfg80211_pernet_ops = {
778 .exit = cfg80211_pernet_exit,
779};
780
781static int __init cfg80211_init(void)
Johannes Berg704232c2007-04-23 12:20:05 -0700782{
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700783 int err;
784
Johannes Berg463d0182009-07-14 00:33:35 +0200785 err = register_pernet_device(&cfg80211_pernet_ops);
786 if (err)
787 goto out_fail_pernet;
788
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700789 err = wiphy_sysfs_init();
Johannes Berg704232c2007-04-23 12:20:05 -0700790 if (err)
791 goto out_fail_sysfs;
792
793 err = register_netdevice_notifier(&cfg80211_netdev_notifier);
794 if (err)
795 goto out_fail_notifier;
796
Johannes Berg55682962007-09-20 13:09:35 -0400797 err = nl80211_init();
798 if (err)
799 goto out_fail_nl80211;
800
Johannes Berg704232c2007-04-23 12:20:05 -0700801 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
802
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700803 err = regulatory_init();
804 if (err)
805 goto out_fail_reg;
806
Johannes Berg704232c2007-04-23 12:20:05 -0700807 return 0;
808
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700809out_fail_reg:
810 debugfs_remove(ieee80211_debugfs_dir);
Johannes Berg55682962007-09-20 13:09:35 -0400811out_fail_nl80211:
812 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
Johannes Berg704232c2007-04-23 12:20:05 -0700813out_fail_notifier:
814 wiphy_sysfs_exit();
815out_fail_sysfs:
Johannes Berg463d0182009-07-14 00:33:35 +0200816 unregister_pernet_device(&cfg80211_pernet_ops);
817out_fail_pernet:
Johannes Berg704232c2007-04-23 12:20:05 -0700818 return err;
819}
Johannes Berg3a462462007-09-10 13:44:45 +0200820subsys_initcall(cfg80211_init);
Johannes Berg704232c2007-04-23 12:20:05 -0700821
822static void cfg80211_exit(void)
823{
824 debugfs_remove(ieee80211_debugfs_dir);
Johannes Berg55682962007-09-20 13:09:35 -0400825 nl80211_exit();
Johannes Berg704232c2007-04-23 12:20:05 -0700826 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
827 wiphy_sysfs_exit();
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700828 regulatory_exit();
Johannes Berg463d0182009-07-14 00:33:35 +0200829 unregister_pernet_device(&cfg80211_pernet_ops);
Johannes Berg704232c2007-04-23 12:20:05 -0700830}
831module_exit(cfg80211_exit);