blob: 5ffff039b0174eefb8f3967dc6f5307ea7cb2f8c [file] [log] [blame]
Johannes Berg704232c2007-04-23 12:20:05 -07001/*
2 * This is the linux wireless configuration interface.
3 *
Johannes Berg5f2aa252010-01-17 15:49:02 +01004 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
Johannes Berg704232c2007-04-23 12:20:05 -07005 */
6
Joe Perchese9c02682010-11-16 19:56:49 -08007#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8
Johannes Berg704232c2007-04-23 12:20:05 -07009#include <linux/if.h>
10#include <linux/module.h>
11#include <linux/err.h>
Johannes Berg704232c2007-04-23 12:20:05 -070012#include <linux/list.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090013#include <linux/slab.h>
Johannes Berg704232c2007-04-23 12:20:05 -070014#include <linux/nl80211.h>
15#include <linux/debugfs.h>
16#include <linux/notifier.h>
17#include <linux/device.h>
Zhu Yi16a832e2009-08-19 16:08:22 +080018#include <linux/etherdevice.h>
Johannes Berg1f87f7d2009-06-02 13:01:41 +020019#include <linux/rtnetlink.h>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040020#include <linux/sched.h>
Johannes Berg704232c2007-04-23 12:20:05 -070021#include <net/genetlink.h>
22#include <net/cfg80211.h>
Johannes Berg55682962007-09-20 13:09:35 -040023#include "nl80211.h"
Johannes Berg704232c2007-04-23 12:20:05 -070024#include "core.h"
25#include "sysfs.h"
Luis R. Rodriguez1ac61302009-05-02 00:37:21 -040026#include "debugfs.h"
Johannes Berga9a11622009-07-27 12:01:53 +020027#include "wext-compat.h"
John W. Linville4890e3b2009-09-30 14:50:17 -040028#include "ethtool.h"
Hila Gonene35e4d22012-06-27 17:19:42 +030029#include "rdev-ops.h"
Johannes Berg704232c2007-04-23 12:20:05 -070030
31/* name for sysfs, %d is appended */
32#define PHY_NAME "phy"
33
34MODULE_AUTHOR("Johannes Berg");
35MODULE_LICENSE("GPL");
36MODULE_DESCRIPTION("wireless configuration support");
37
Johannes Berg5f2aa252010-01-17 15:49:02 +010038/* RCU-protected (and cfg80211_mutex for writers) */
Johannes Berg79c97e92009-07-07 03:56:12 +020039LIST_HEAD(cfg80211_rdev_list);
Johannes Bergf5ea9122009-08-07 16:17:38 +020040int cfg80211_rdev_list_generation;
Luis R. Rodrigueza1794392009-02-21 00:04:21 -050041
Luis R. Rodrigueza1794392009-02-21 00:04:21 -050042DEFINE_MUTEX(cfg80211_mutex);
Johannes Berg704232c2007-04-23 12:20:05 -070043
44/* for debugfs */
45static struct dentry *ieee80211_debugfs_dir;
46
Alban Browaeyse60d7442009-11-25 15:13:00 +010047/* for the cleanup, scan and event works */
48struct workqueue_struct *cfg80211_wq;
49
Amitkumar Karwar40db6c72011-04-21 14:10:27 -070050static bool cfg80211_disable_40mhz_24ghz;
51module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
52MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
53 "Disable 40MHz support in the 2.4GHz band");
54
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050055/* requires cfg80211_mutex to be held! */
Johannes Berg79c97e92009-07-07 03:56:12 +020056struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
Johannes Berg55682962007-09-20 13:09:35 -040057{
Johannes Berg79c97e92009-07-07 03:56:12 +020058 struct cfg80211_registered_device *result = NULL, *rdev;
Johannes Berg55682962007-09-20 13:09:35 -040059
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -050060 assert_cfg80211_lock();
61
Johannes Berg79c97e92009-07-07 03:56:12 +020062 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
63 if (rdev->wiphy_idx == wiphy_idx) {
64 result = rdev;
Johannes Berg55682962007-09-20 13:09:35 -040065 break;
66 }
67 }
68
69 return result;
70}
71
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050072int get_wiphy_idx(struct wiphy *wiphy)
73{
Johannes Bergf4173762012-12-03 18:23:37 +010074 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
75
Johannes Berg79c97e92009-07-07 03:56:12 +020076 return rdev->wiphy_idx;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050077}
78
Johannes Berg79c97e92009-07-07 03:56:12 +020079/* requires cfg80211_rdev_mutex to be held! */
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050080struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
81{
Johannes Berg79c97e92009-07-07 03:56:12 +020082 struct cfg80211_registered_device *rdev;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050083
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050084 assert_cfg80211_lock();
85
Johannes Berg79c97e92009-07-07 03:56:12 +020086 rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
87 if (!rdev)
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050088 return NULL;
Johannes Berg79c97e92009-07-07 03:56:12 +020089 return &rdev->wiphy;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -050090}
91
Johannes Berg55682962007-09-20 13:09:35 -040092struct cfg80211_registered_device *
Johannes Berg463d0182009-07-14 00:33:35 +020093cfg80211_get_dev_from_ifindex(struct net *net, int ifindex)
Johannes Berg55682962007-09-20 13:09:35 -040094{
Johannes Berg79c97e92009-07-07 03:56:12 +020095 struct cfg80211_registered_device *rdev = ERR_PTR(-ENODEV);
Johannes Berg55682962007-09-20 13:09:35 -040096 struct net_device *dev;
97
Luis R. Rodrigueza1794392009-02-21 00:04:21 -050098 mutex_lock(&cfg80211_mutex);
Johannes Berg463d0182009-07-14 00:33:35 +020099 dev = dev_get_by_index(net, ifindex);
Johannes Berg55682962007-09-20 13:09:35 -0400100 if (!dev)
101 goto out;
102 if (dev->ieee80211_ptr) {
Johannes Berg79c97e92009-07-07 03:56:12 +0200103 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
104 mutex_lock(&rdev->mtx);
Johannes Berg55682962007-09-20 13:09:35 -0400105 } else
Johannes Berg79c97e92009-07-07 03:56:12 +0200106 rdev = ERR_PTR(-ENODEV);
Johannes Berg55682962007-09-20 13:09:35 -0400107 dev_put(dev);
108 out:
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500109 mutex_unlock(&cfg80211_mutex);
Johannes Berg79c97e92009-07-07 03:56:12 +0200110 return rdev;
Johannes Berg55682962007-09-20 13:09:35 -0400111}
112
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100113/* requires cfg80211_mutex to be held */
Johannes Berg55682962007-09-20 13:09:35 -0400114int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
115 char *newname)
116{
Johannes Berg79c97e92009-07-07 03:56:12 +0200117 struct cfg80211_registered_device *rdev2;
Johannes Berg76232252010-10-11 14:46:52 -0400118 int wiphy_idx, taken = -1, result, digits;
Johannes Berg55682962007-09-20 13:09:35 -0400119
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100120 assert_cfg80211_lock();
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700121
Johannes Berg76232252010-10-11 14:46:52 -0400122 /* prohibit calling the thing phy%d when %d is not its number */
123 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
124 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
125 /* count number of places needed to print wiphy_idx */
126 digits = 1;
127 while (wiphy_idx /= 10)
128 digits++;
129 /*
130 * deny the name if it is phy<idx> where <idx> is printed
131 * without leading zeroes. taken == strlen(newname) here
132 */
133 if (taken == strlen(PHY_NAME) + digits)
134 return -EINVAL;
135 }
136
137
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700138 /* Ignore nop renames */
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700139 if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100140 return 0;
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700141
142 /* Ensure another device does not already have this name. */
Johannes Berg79c97e92009-07-07 03:56:12 +0200143 list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
144 if (strcmp(newname, dev_name(&rdev2->wiphy.dev)) == 0)
Johannes Berg76232252010-10-11 14:46:52 -0400145 return -EINVAL;
Eric W. Biederman2940bb62008-05-08 14:30:18 -0700146
Johannes Berg55682962007-09-20 13:09:35 -0400147 result = device_rename(&rdev->wiphy.dev, newname);
148 if (result)
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100149 return result;
Johannes Berg55682962007-09-20 13:09:35 -0400150
Johannes Berg33c03602008-10-08 10:23:48 +0200151 if (rdev->wiphy.debugfsdir &&
152 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
Johannes Berg55682962007-09-20 13:09:35 -0400153 rdev->wiphy.debugfsdir,
154 rdev->wiphy.debugfsdir->d_parent,
155 newname))
Joe Perchese9c02682010-11-16 19:56:49 -0800156 pr_err("failed to rename debugfs dir to %s!\n", newname);
Johannes Berg55682962007-09-20 13:09:35 -0400157
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100158 nl80211_notify_dev_rename(rdev);
Johannes Berg55682962007-09-20 13:09:35 -0400159
Johannes Berg4bbf4d52009-03-24 09:35:46 +0100160 return 0;
Johannes Berg55682962007-09-20 13:09:35 -0400161}
162
Johannes Berg463d0182009-07-14 00:33:35 +0200163int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
164 struct net *net)
165{
166 struct wireless_dev *wdev;
167 int err = 0;
168
Johannes Berg5be83de2009-11-19 00:56:28 +0100169 if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
Johannes Berg463d0182009-07-14 00:33:35 +0200170 return -EOPNOTSUPP;
171
Johannes Berg89a54e42012-06-15 14:33:17 +0200172 list_for_each_entry(wdev, &rdev->wdev_list, list) {
Johannes Bergba22fb52012-06-15 18:00:00 +0200173 if (!wdev->netdev)
174 continue;
Johannes Berg463d0182009-07-14 00:33:35 +0200175 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
176 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
177 if (err)
178 break;
179 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
180 }
181
182 if (err) {
183 /* failed -- clean up to old netns */
184 net = wiphy_net(&rdev->wiphy);
185
Johannes Berg89a54e42012-06-15 14:33:17 +0200186 list_for_each_entry_continue_reverse(wdev, &rdev->wdev_list,
Johannes Berg463d0182009-07-14 00:33:35 +0200187 list) {
Johannes Bergba22fb52012-06-15 18:00:00 +0200188 if (!wdev->netdev)
189 continue;
Johannes Berg463d0182009-07-14 00:33:35 +0200190 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
191 err = dev_change_net_namespace(wdev->netdev, net,
192 "wlan%d");
193 WARN_ON(err);
194 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
195 }
Johannes Berg04600792010-08-05 17:45:15 +0200196
197 return err;
Johannes Berg463d0182009-07-14 00:33:35 +0200198 }
199
200 wiphy_net_set(&rdev->wiphy, net);
201
Johannes Berg04600792010-08-05 17:45:15 +0200202 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
203 WARN_ON(err);
204
205 return 0;
Johannes Berg463d0182009-07-14 00:33:35 +0200206}
207
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200208static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
209{
Johannes Berg79c97e92009-07-07 03:56:12 +0200210 struct cfg80211_registered_device *rdev = data;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200211
Hila Gonene35e4d22012-06-27 17:19:42 +0300212 rdev_rfkill_poll(rdev);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200213}
214
215static int cfg80211_rfkill_set_block(void *data, bool blocked)
216{
Johannes Berg79c97e92009-07-07 03:56:12 +0200217 struct cfg80211_registered_device *rdev = data;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200218 struct wireless_dev *wdev;
219
220 if (!blocked)
221 return 0;
222
223 rtnl_lock();
Johannes Berg79c97e92009-07-07 03:56:12 +0200224 mutex_lock(&rdev->devlist_mtx);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200225
Johannes Berg98104fde2012-06-16 00:19:54 +0200226 list_for_each_entry(wdev, &rdev->wdev_list, list) {
227 if (wdev->netdev) {
Johannes Bergba22fb52012-06-15 18:00:00 +0200228 dev_close(wdev->netdev);
Johannes Berg98104fde2012-06-16 00:19:54 +0200229 continue;
230 }
231 /* otherwise, check iftype */
232 switch (wdev->iftype) {
233 case NL80211_IFTYPE_P2P_DEVICE:
234 if (!wdev->p2p_started)
235 break;
Johannes Bergeeb126e2012-10-23 15:16:50 +0200236 rdev_stop_p2p_device(rdev, wdev);
Johannes Berg98104fde2012-06-16 00:19:54 +0200237 wdev->p2p_started = false;
238 rdev->opencount--;
239 break;
240 default:
241 break;
242 }
243 }
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200244
Johannes Berg79c97e92009-07-07 03:56:12 +0200245 mutex_unlock(&rdev->devlist_mtx);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200246 rtnl_unlock();
247
248 return 0;
249}
250
251static void cfg80211_rfkill_sync_work(struct work_struct *work)
252{
Johannes Berg79c97e92009-07-07 03:56:12 +0200253 struct cfg80211_registered_device *rdev;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200254
Johannes Berg79c97e92009-07-07 03:56:12 +0200255 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
256 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200257}
258
Johannes Berg667503dd2009-07-07 03:56:11 +0200259static void cfg80211_event_work(struct work_struct *work)
260{
261 struct cfg80211_registered_device *rdev;
Johannes Berg667503dd2009-07-07 03:56:11 +0200262
263 rdev = container_of(work, struct cfg80211_registered_device,
264 event_work);
265
266 rtnl_lock();
267 cfg80211_lock_rdev(rdev);
Johannes Berg667503dd2009-07-07 03:56:11 +0200268
Johannes Berg3d54d252009-08-21 14:51:05 +0200269 cfg80211_process_rdev_events(rdev);
Johannes Berg667503dd2009-07-07 03:56:11 +0200270 cfg80211_unlock_rdev(rdev);
271 rtnl_unlock();
272}
273
Johannes Berg704232c2007-04-23 12:20:05 -0700274/* exported functions */
275
David Kilroy3dcf6702009-05-16 23:13:46 +0100276struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
Johannes Berg704232c2007-04-23 12:20:05 -0700277{
Denis ChengRq638af072008-09-23 02:35:37 +0800278 static int wiphy_counter;
Johannes Berg76232252010-10-11 14:46:52 -0400279
280 struct cfg80211_registered_device *rdev;
Johannes Berg704232c2007-04-23 12:20:05 -0700281 int alloc_size;
282
Johannes Berg0b20633d2009-07-07 03:56:13 +0200283 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
284 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
285 WARN_ON(ops->connect && !ops->disconnect);
286 WARN_ON(ops->join_ibss && !ops->leave_ibss);
287 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
288 WARN_ON(ops->add_station && !ops->del_station);
289 WARN_ON(ops->add_mpath && !ops->del_mpath);
Johannes Berg29cbe682010-12-03 09:20:44 +0100290 WARN_ON(ops->join_mesh && !ops->leave_mesh);
Johannes Berg41ade002007-12-19 02:03:29 +0100291
Johannes Berg79c97e92009-07-07 03:56:12 +0200292 alloc_size = sizeof(*rdev) + sizeof_priv;
Johannes Berg704232c2007-04-23 12:20:05 -0700293
Johannes Berg79c97e92009-07-07 03:56:12 +0200294 rdev = kzalloc(alloc_size, GFP_KERNEL);
295 if (!rdev)
Johannes Berg704232c2007-04-23 12:20:05 -0700296 return NULL;
297
Johannes Berg79c97e92009-07-07 03:56:12 +0200298 rdev->ops = ops;
Johannes Berg704232c2007-04-23 12:20:05 -0700299
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500300 mutex_lock(&cfg80211_mutex);
Johannes Berg704232c2007-04-23 12:20:05 -0700301
Johannes Berg79c97e92009-07-07 03:56:12 +0200302 rdev->wiphy_idx = wiphy_counter++;
Johannes Berga4d73ee2007-04-26 20:50:35 -0700303
Johannes Bergf4173762012-12-03 18:23:37 +0100304 if (unlikely(rdev->wiphy_idx < 0)) {
Denis ChengRq638af072008-09-23 02:35:37 +0800305 wiphy_counter--;
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500306 mutex_unlock(&cfg80211_mutex);
Johannes Berg76232252010-10-11 14:46:52 -0400307 /* ugh, wrapped! */
Johannes Berg79c97e92009-07-07 03:56:12 +0200308 kfree(rdev);
Johannes Berg704232c2007-04-23 12:20:05 -0700309 return NULL;
310 }
Johannes Berg704232c2007-04-23 12:20:05 -0700311
Ben Greear5a254ff2010-09-27 09:07:26 -0700312 mutex_unlock(&cfg80211_mutex);
Johannes Berg704232c2007-04-23 12:20:05 -0700313
Johannes Berg76232252010-10-11 14:46:52 -0400314 /* give it a proper name */
315 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
316
Johannes Berg79c97e92009-07-07 03:56:12 +0200317 mutex_init(&rdev->mtx);
318 mutex_init(&rdev->devlist_mtx);
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300319 mutex_init(&rdev->sched_scan_mtx);
Johannes Berg89a54e42012-06-15 14:33:17 +0200320 INIT_LIST_HEAD(&rdev->wdev_list);
Ben Greear37c73b52012-10-26 14:49:25 -0700321 INIT_LIST_HEAD(&rdev->beacon_registrations);
322 spin_lock_init(&rdev->beacon_registrations_lock);
Johannes Berg79c97e92009-07-07 03:56:12 +0200323 spin_lock_init(&rdev->bss_lock);
324 INIT_LIST_HEAD(&rdev->bss_list);
325 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300326 INIT_WORK(&rdev->sched_scan_results_wk, __cfg80211_sched_scan_results);
Simon Wunderlich04f39042013-02-08 18:16:19 +0100327 INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
328 cfg80211_dfs_channels_update_work);
Johannes Berg3d23e342009-09-29 23:27:28 +0200329#ifdef CONFIG_CFG80211_WEXT
330 rdev->wiphy.wext = &cfg80211_wext_handler;
331#endif
332
Johannes Berg79c97e92009-07-07 03:56:12 +0200333 device_initialize(&rdev->wiphy.dev);
334 rdev->wiphy.dev.class = &ieee80211_class;
335 rdev->wiphy.dev.platform_data = rdev;
Johannes Berg704232c2007-04-23 12:20:05 -0700336
Johannes Berg5be83de2009-11-19 00:56:28 +0100337#ifdef CONFIG_CFG80211_DEFAULT_PS
338 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
339#endif
Johannes Berg16cb9d42009-08-12 23:33:20 +0200340
Johannes Berg463d0182009-07-14 00:33:35 +0200341 wiphy_net_set(&rdev->wiphy, &init_net);
342
Johannes Berg79c97e92009-07-07 03:56:12 +0200343 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
344 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
345 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
346 &rdev->rfkill_ops, rdev);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200347
Johannes Berg79c97e92009-07-07 03:56:12 +0200348 if (!rdev->rfkill) {
349 kfree(rdev);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200350 return NULL;
351 }
352
Johannes Berg79c97e92009-07-07 03:56:12 +0200353 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
354 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
355 INIT_WORK(&rdev->event_work, cfg80211_event_work);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200356
Johannes Bergad002392009-08-18 19:51:57 +0200357 init_waitqueue_head(&rdev->dev_wait);
358
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +0200359 /*
360 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
361 * Fragmentation and RTS threshold are disabled by default with the
362 * special -1 value.
363 */
Johannes Berg79c97e92009-07-07 03:56:12 +0200364 rdev->wiphy.retry_short = 7;
365 rdev->wiphy.retry_long = 4;
366 rdev->wiphy.frag_threshold = (u32) -1;
367 rdev->wiphy.rts_threshold = (u32) -1;
Lukáš Turek81077e82009-12-21 22:50:47 +0100368 rdev->wiphy.coverage_class = 0;
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +0200369
Johannes Berg50640f12012-12-12 17:59:39 +0100370 rdev->wiphy.features = NL80211_FEATURE_SCAN_FLUSH |
371 NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
Sam Leffler15d60302012-10-11 21:03:34 -0700372
Johannes Berg79c97e92009-07-07 03:56:12 +0200373 return &rdev->wiphy;
Johannes Berg704232c2007-04-23 12:20:05 -0700374}
375EXPORT_SYMBOL(wiphy_new);
376
Johannes Berg7527a782011-05-13 10:58:57 +0200377static int wiphy_verify_combinations(struct wiphy *wiphy)
378{
379 const struct ieee80211_iface_combination *c;
380 int i, j;
381
Johannes Berg7527a782011-05-13 10:58:57 +0200382 for (i = 0; i < wiphy->n_iface_combinations; i++) {
383 u32 cnt = 0;
384 u16 all_iftypes = 0;
385
386 c = &wiphy->iface_combinations[i];
387
Simon Wunderlich11c4a072013-01-08 14:04:07 +0100388 /*
389 * Combinations with just one interface aren't real,
390 * however we make an exception for DFS.
391 */
392 if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
Johannes Berg7527a782011-05-13 10:58:57 +0200393 return -EINVAL;
394
395 /* Need at least one channel */
396 if (WARN_ON(!c->num_different_channels))
397 return -EINVAL;
398
Michal Kaziord4e50c52012-06-29 12:47:07 +0200399 /*
400 * Put a sane limit on maximum number of different
401 * channels to simplify channel accounting code.
402 */
403 if (WARN_ON(c->num_different_channels >
404 CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
405 return -EINVAL;
406
Simon Wunderlich11c4a072013-01-08 14:04:07 +0100407 /* DFS only works on one channel. */
408 if (WARN_ON(c->radar_detect_widths &&
409 (c->num_different_channels > 1)))
410 return -EINVAL;
411
Johannes Berg7527a782011-05-13 10:58:57 +0200412 if (WARN_ON(!c->n_limits))
413 return -EINVAL;
414
415 for (j = 0; j < c->n_limits; j++) {
416 u16 types = c->limits[j].types;
417
418 /*
419 * interface types shouldn't overlap, this is
420 * used in cfg80211_can_change_interface()
421 */
422 if (WARN_ON(types & all_iftypes))
423 return -EINVAL;
424 all_iftypes |= types;
425
426 if (WARN_ON(!c->limits[j].max))
427 return -EINVAL;
428
429 /* Shouldn't list software iftypes in combinations! */
430 if (WARN_ON(wiphy->software_iftypes & types))
431 return -EINVAL;
432
Johannes Berg98104fde2012-06-16 00:19:54 +0200433 /* Only a single P2P_DEVICE can be allowed */
434 if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
435 c->limits[j].max > 1))
436 return -EINVAL;
437
Johannes Berg7527a782011-05-13 10:58:57 +0200438 cnt += c->limits[j].max;
439 /*
440 * Don't advertise an unsupported type
441 * in a combination.
442 */
443 if (WARN_ON((wiphy->interface_modes & types) != types))
444 return -EINVAL;
445 }
446
447 /* You can't even choose that many! */
448 if (WARN_ON(cnt < c->max_interfaces))
449 return -EINVAL;
450 }
451
452 return 0;
453}
454
Johannes Berg704232c2007-04-23 12:20:05 -0700455int wiphy_register(struct wiphy *wiphy)
456{
Johannes Berg79c97e92009-07-07 03:56:12 +0200457 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg704232c2007-04-23 12:20:05 -0700458 int res;
Johannes Berg8318d782008-01-24 19:38:38 +0100459 enum ieee80211_band band;
460 struct ieee80211_supported_band *sband;
461 bool have_band = false;
462 int i;
Luis R. Rodriguezf59ac042008-08-29 16:26:43 -0700463 u16 ifmodes = wiphy->interface_modes;
464
Johannes Bergdfb89c52012-06-27 09:23:48 +0200465#ifdef CONFIG_PM
Johannes Berg77dbbb12011-07-13 10:48:55 +0200466 if (WARN_ON((wiphy->wowlan.flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
467 !(wiphy->wowlan.flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
468 return -EINVAL;
Johannes Bergdfb89c52012-06-27 09:23:48 +0200469#endif
Johannes Berg77dbbb12011-07-13 10:48:55 +0200470
Johannes Berg562a7482011-11-07 12:39:33 +0100471 if (WARN_ON(wiphy->ap_sme_capa &&
472 !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
473 return -EINVAL;
474
Johannes Bergef15aac2010-01-20 12:02:33 +0100475 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
476 return -EINVAL;
477
478 if (WARN_ON(wiphy->addresses &&
479 !is_zero_ether_addr(wiphy->perm_addr) &&
480 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
481 ETH_ALEN)))
482 return -EINVAL;
483
Vasanthakumar Thiagarajan77765ea2013-01-18 11:18:45 +0530484 if (WARN_ON(wiphy->max_acl_mac_addrs &&
485 (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
486 !rdev->ops->set_mac_acl)))
487 return -EINVAL;
488
Johannes Bergef15aac2010-01-20 12:02:33 +0100489 if (wiphy->addresses)
490 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
491
Luis R. Rodriguezf59ac042008-08-29 16:26:43 -0700492 /* sanity check ifmodes */
493 WARN_ON(!ifmodes);
Johannes Berg2e161f72010-08-12 15:38:38 +0200494 ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
Luis R. Rodriguezf59ac042008-08-29 16:26:43 -0700495 if (WARN_ON(ifmodes != wiphy->interface_modes))
496 wiphy->interface_modes = ifmodes;
Johannes Berg8318d782008-01-24 19:38:38 +0100497
Johannes Berg7527a782011-05-13 10:58:57 +0200498 res = wiphy_verify_combinations(wiphy);
499 if (res)
500 return res;
501
Johannes Berg8318d782008-01-24 19:38:38 +0100502 /* sanity check supported bands/channels */
503 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
504 sband = wiphy->bands[band];
505 if (!sband)
506 continue;
507
508 sband->band = band;
Vladimir Kondratiev3a0c52a2012-07-02 09:32:32 +0300509 if (WARN_ON(!sband->n_channels))
510 return -EINVAL;
511 /*
512 * on 60gHz band, there are no legacy rates, so
513 * n_bitrates is 0
514 */
515 if (WARN_ON(band != IEEE80211_BAND_60GHZ &&
516 !sband->n_bitrates))
Johannes Berg8318d782008-01-24 19:38:38 +0100517 return -EINVAL;
Johannes Berg881d9482009-01-21 15:13:48 +0100518
519 /*
Amitkumar Karwar40db6c72011-04-21 14:10:27 -0700520 * Since cfg80211_disable_40mhz_24ghz is global, we can
521 * modify the sband's ht data even if the driver uses a
522 * global structure for that.
523 */
524 if (cfg80211_disable_40mhz_24ghz &&
525 band == IEEE80211_BAND_2GHZ &&
526 sband->ht_cap.ht_supported) {
527 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
528 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
529 }
530
531 /*
Johannes Berg881d9482009-01-21 15:13:48 +0100532 * Since we use a u32 for rate bitmaps in
533 * ieee80211_get_response_rate, we cannot
534 * have more than 32 legacy rates.
535 */
536 if (WARN_ON(sband->n_bitrates > 32))
537 return -EINVAL;
Johannes Berg8318d782008-01-24 19:38:38 +0100538
539 for (i = 0; i < sband->n_channels; i++) {
540 sband->channels[i].orig_flags =
541 sband->channels[i].flags;
Felix Fietkauc4a9faf2012-10-17 13:56:19 +0200542 sband->channels[i].orig_mag = INT_MAX;
Johannes Berg8318d782008-01-24 19:38:38 +0100543 sband->channels[i].orig_mpwr =
544 sband->channels[i].max_power;
545 sband->channels[i].band = band;
546 }
547
548 have_band = true;
549 }
550
551 if (!have_band) {
552 WARN_ON(1);
553 return -EINVAL;
554 }
555
Johannes Bergdfb89c52012-06-27 09:23:48 +0200556#ifdef CONFIG_PM
Johannes Bergff1b6e62011-05-04 15:37:28 +0200557 if (rdev->wiphy.wowlan.n_patterns) {
558 if (WARN_ON(!rdev->wiphy.wowlan.pattern_min_len ||
559 rdev->wiphy.wowlan.pattern_min_len >
560 rdev->wiphy.wowlan.pattern_max_len))
561 return -EINVAL;
562 }
Johannes Bergdfb89c52012-06-27 09:23:48 +0200563#endif
Johannes Bergff1b6e62011-05-04 15:37:28 +0200564
Johannes Berg8318d782008-01-24 19:38:38 +0100565 /* check and set up bitrates */
566 ieee80211_set_bitrate_flags(wiphy);
567
Maxime Bizon5a652052010-07-21 17:21:38 +0200568 mutex_lock(&cfg80211_mutex);
569
Johannes Berg79c97e92009-07-07 03:56:12 +0200570 res = device_add(&rdev->wiphy.dev);
John W. Linvillec3d34d52010-08-30 17:36:40 -0400571 if (res) {
572 mutex_unlock(&cfg80211_mutex);
573 return res;
574 }
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200575
Johannes Berg2f0accc2009-06-10 16:50:29 +0200576 /* set up regulatory info */
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700577 wiphy_regulatory_register(wiphy);
Johannes Berg2f0accc2009-06-10 16:50:29 +0200578
Johannes Berg5f2aa252010-01-17 15:49:02 +0100579 list_add_rcu(&rdev->list, &cfg80211_rdev_list);
Johannes Bergf5ea9122009-08-07 16:17:38 +0200580 cfg80211_rdev_list_generation++;
Johannes Berg704232c2007-04-23 12:20:05 -0700581
582 /* add to debugfs */
Johannes Berg79c97e92009-07-07 03:56:12 +0200583 rdev->wiphy.debugfsdir =
584 debugfs_create_dir(wiphy_name(&rdev->wiphy),
Johannes Berg704232c2007-04-23 12:20:05 -0700585 ieee80211_debugfs_dir);
Johannes Berg79c97e92009-07-07 03:56:12 +0200586 if (IS_ERR(rdev->wiphy.debugfsdir))
587 rdev->wiphy.debugfsdir = NULL;
Johannes Berg704232c2007-04-23 12:20:05 -0700588
Johannes Berg5be83de2009-11-19 00:56:28 +0100589 if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -0400590 struct regulatory_request request;
591
592 request.wiphy_idx = get_wiphy_idx(wiphy);
593 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
594 request.alpha2[0] = '9';
595 request.alpha2[1] = '9';
596
597 nl80211_send_reg_change_event(&request);
598 }
599
Johannes Berg79c97e92009-07-07 03:56:12 +0200600 cfg80211_debugfs_rdev_add(rdev);
Maxime Bizon5a652052010-07-21 17:21:38 +0200601 mutex_unlock(&cfg80211_mutex);
Luis R. Rodriguez1ac61302009-05-02 00:37:21 -0400602
John W. Linvillec3d34d52010-08-30 17:36:40 -0400603 /*
604 * due to a locking dependency this has to be outside of the
605 * cfg80211_mutex lock
606 */
607 res = rfkill_register(rdev->rfkill);
608 if (res)
609 goto out_rm_dev;
610
Stanislaw Gruszkaecb44332011-08-12 14:00:59 +0200611 rtnl_lock();
612 rdev->wiphy.registered = true;
613 rtnl_unlock();
Johannes Berg2f0accc2009-06-10 16:50:29 +0200614 return 0;
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200615
Maxime Bizon5a652052010-07-21 17:21:38 +0200616out_rm_dev:
Johannes Berg79c97e92009-07-07 03:56:12 +0200617 device_del(&rdev->wiphy.dev);
Johannes Berg704232c2007-04-23 12:20:05 -0700618 return res;
619}
620EXPORT_SYMBOL(wiphy_register);
621
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200622void wiphy_rfkill_start_polling(struct wiphy *wiphy)
623{
Johannes Berg79c97e92009-07-07 03:56:12 +0200624 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200625
Johannes Berg79c97e92009-07-07 03:56:12 +0200626 if (!rdev->ops->rfkill_poll)
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200627 return;
Johannes Berg79c97e92009-07-07 03:56:12 +0200628 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
629 rfkill_resume_polling(rdev->rfkill);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200630}
631EXPORT_SYMBOL(wiphy_rfkill_start_polling);
632
633void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
634{
Johannes Berg79c97e92009-07-07 03:56:12 +0200635 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200636
Johannes Berg79c97e92009-07-07 03:56:12 +0200637 rfkill_pause_polling(rdev->rfkill);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200638}
639EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
640
Johannes Berg704232c2007-04-23 12:20:05 -0700641void wiphy_unregister(struct wiphy *wiphy)
642{
Johannes Berg79c97e92009-07-07 03:56:12 +0200643 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg704232c2007-04-23 12:20:05 -0700644
Stanislaw Gruszkaecb44332011-08-12 14:00:59 +0200645 rtnl_lock();
646 rdev->wiphy.registered = false;
647 rtnl_unlock();
648
Johannes Berg79c97e92009-07-07 03:56:12 +0200649 rfkill_unregister(rdev->rfkill);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200650
Johannes Bergf16bfc12007-04-26 20:51:12 -0700651 /* protect the device list */
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500652 mutex_lock(&cfg80211_mutex);
Johannes Berg704232c2007-04-23 12:20:05 -0700653
Johannes Bergad002392009-08-18 19:51:57 +0200654 wait_event(rdev->dev_wait, ({
655 int __count;
656 mutex_lock(&rdev->devlist_mtx);
657 __count = rdev->opencount;
658 mutex_unlock(&rdev->devlist_mtx);
Cristian Chilipireac4f60842012-05-08 12:38:53 +0300659 __count == 0; }));
Johannes Bergad002392009-08-18 19:51:57 +0200660
661 mutex_lock(&rdev->devlist_mtx);
Johannes Berg89a54e42012-06-15 14:33:17 +0200662 BUG_ON(!list_empty(&rdev->wdev_list));
Johannes Bergad002392009-08-18 19:51:57 +0200663 mutex_unlock(&rdev->devlist_mtx);
664
665 /*
666 * First remove the hardware from everywhere, this makes
667 * it impossible to find from userspace.
668 */
Johannes Berg7bcfaf22009-10-27 12:59:03 +0100669 debugfs_remove_recursive(rdev->wiphy.debugfsdir);
Johannes Berg5f2aa252010-01-17 15:49:02 +0100670 list_del_rcu(&rdev->list);
671 synchronize_rcu();
Johannes Bergf16bfc12007-04-26 20:51:12 -0700672
673 /*
Johannes Berg79c97e92009-07-07 03:56:12 +0200674 * Try to grab rdev->mtx. If a command is still in progress,
Johannes Bergf16bfc12007-04-26 20:51:12 -0700675 * hopefully the driver will refuse it since it's tearing
676 * down the device already. We wait for this command to complete
677 * before unlinking the item from the list.
678 * Note: as codified by the BUG_ON above we cannot get here if
Johannes Bergad002392009-08-18 19:51:57 +0200679 * a virtual interface is still present. Hence, we can only get
680 * to lock contention here if userspace issues a command that
681 * identified the hardware by wiphy index.
Johannes Bergf16bfc12007-04-26 20:51:12 -0700682 */
Johannes Berg0ff6ce72009-08-17 12:25:37 +0200683 cfg80211_lock_rdev(rdev);
Johannes Bergad002392009-08-18 19:51:57 +0200684 /* nothing */
Johannes Berg0ff6ce72009-08-17 12:25:37 +0200685 cfg80211_unlock_rdev(rdev);
Johannes Berg704232c2007-04-23 12:20:05 -0700686
Luis R. Rodriguezbfead082012-07-12 11:49:19 -0700687 /*
688 * If this device got a regulatory hint tell core its
689 * free to listen now to a new shiny device regulatory hint
690 */
691 wiphy_regulatory_deregister(wiphy);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800692
Johannes Bergf5ea9122009-08-07 16:17:38 +0200693 cfg80211_rdev_list_generation++;
Johannes Berg79c97e92009-07-07 03:56:12 +0200694 device_del(&rdev->wiphy.dev);
Johannes Berg704232c2007-04-23 12:20:05 -0700695
Luis R. Rodrigueza1794392009-02-21 00:04:21 -0500696 mutex_unlock(&cfg80211_mutex);
Johannes Berg66825882009-07-13 13:24:44 +0200697
Johannes Berg36e6fea2009-08-12 22:21:21 +0200698 flush_work(&rdev->scan_done_wk);
Johannes Berg66825882009-07-13 13:24:44 +0200699 cancel_work_sync(&rdev->conn_work);
Johannes Berg66825882009-07-13 13:24:44 +0200700 flush_work(&rdev->event_work);
Simon Wunderlich04f39042013-02-08 18:16:19 +0100701 cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
Johannes Berg6d525632012-04-04 15:05:25 +0200702
703 if (rdev->wowlan && rdev->ops->set_wakeup)
Hila Gonene35e4d22012-06-27 17:19:42 +0300704 rdev_set_wakeup(rdev, false);
Johannes Berg6d525632012-04-04 15:05:25 +0200705 cfg80211_rdev_free_wowlan(rdev);
Johannes Berg704232c2007-04-23 12:20:05 -0700706}
707EXPORT_SYMBOL(wiphy_unregister);
708
Johannes Berg79c97e92009-07-07 03:56:12 +0200709void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
Johannes Berg704232c2007-04-23 12:20:05 -0700710{
Johannes Berg2a519312009-02-10 21:25:55 +0100711 struct cfg80211_internal_bss *scan, *tmp;
Ben Greear37c73b52012-10-26 14:49:25 -0700712 struct cfg80211_beacon_registration *reg, *treg;
Johannes Berg79c97e92009-07-07 03:56:12 +0200713 rfkill_destroy(rdev->rfkill);
714 mutex_destroy(&rdev->mtx);
715 mutex_destroy(&rdev->devlist_mtx);
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300716 mutex_destroy(&rdev->sched_scan_mtx);
Ben Greear37c73b52012-10-26 14:49:25 -0700717 list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
718 list_del(&reg->list);
719 kfree(reg);
720 }
Johannes Berg79c97e92009-07-07 03:56:12 +0200721 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
Johannes Berg5b112d32013-02-01 01:49:58 +0100722 cfg80211_put_bss(&rdev->wiphy, &scan->pub);
Johannes Berg79c97e92009-07-07 03:56:12 +0200723 kfree(rdev);
Johannes Berg704232c2007-04-23 12:20:05 -0700724}
725
726void wiphy_free(struct wiphy *wiphy)
727{
728 put_device(&wiphy->dev);
729}
730EXPORT_SYMBOL(wiphy_free);
731
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200732void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
733{
Johannes Berg79c97e92009-07-07 03:56:12 +0200734 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200735
Johannes Berg79c97e92009-07-07 03:56:12 +0200736 if (rfkill_set_hw_state(rdev->rfkill, blocked))
737 schedule_work(&rdev->rfkill_sync);
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200738}
739EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
740
Johannes Bergad002392009-08-18 19:51:57 +0200741static void wdev_cleanup_work(struct work_struct *work)
742{
743 struct wireless_dev *wdev;
744 struct cfg80211_registered_device *rdev;
745
746 wdev = container_of(work, struct wireless_dev, cleanup_work);
747 rdev = wiphy_to_dev(wdev->wiphy);
748
749 cfg80211_lock_rdev(rdev);
750
Johannes Bergfd014282012-06-18 19:17:03 +0200751 if (WARN_ON(rdev->scan_req && rdev->scan_req->wdev == wdev)) {
Johannes Bergad002392009-08-18 19:51:57 +0200752 rdev->scan_req->aborted = true;
Johannes Berg01a0ac42009-08-20 21:36:16 +0200753 ___cfg80211_scan_done(rdev, true);
Johannes Bergad002392009-08-18 19:51:57 +0200754 }
755
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300756 cfg80211_unlock_rdev(rdev);
757
758 mutex_lock(&rdev->sched_scan_mtx);
759
Luciano Coelho807f8a82011-05-11 17:09:35 +0300760 if (WARN_ON(rdev->sched_scan_req &&
761 rdev->sched_scan_req->dev == wdev->netdev)) {
762 __cfg80211_stop_sched_scan(rdev, false);
763 }
764
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300765 mutex_unlock(&rdev->sched_scan_mtx);
Johannes Bergad002392009-08-18 19:51:57 +0200766
767 mutex_lock(&rdev->devlist_mtx);
768 rdev->opencount--;
769 mutex_unlock(&rdev->devlist_mtx);
770 wake_up(&rdev->dev_wait);
771
772 dev_put(wdev->netdev);
773}
774
Johannes Berg98104fde2012-06-16 00:19:54 +0200775void cfg80211_unregister_wdev(struct wireless_dev *wdev)
776{
777 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
778
779 ASSERT_RTNL();
780
781 if (WARN_ON(wdev->netdev))
782 return;
783
784 mutex_lock(&rdev->devlist_mtx);
785 list_del_rcu(&wdev->list);
786 rdev->devlist_generation++;
787
788 switch (wdev->iftype) {
789 case NL80211_IFTYPE_P2P_DEVICE:
790 if (!wdev->p2p_started)
791 break;
Johannes Bergeeb126e2012-10-23 15:16:50 +0200792 rdev_stop_p2p_device(rdev, wdev);
Johannes Berg98104fde2012-06-16 00:19:54 +0200793 wdev->p2p_started = false;
794 rdev->opencount--;
795 break;
796 default:
797 WARN_ON_ONCE(1);
798 break;
799 }
800 mutex_unlock(&rdev->devlist_mtx);
801}
802EXPORT_SYMBOL(cfg80211_unregister_wdev);
803
Marcel Holtmann053a93d2009-10-02 05:15:28 +0000804static struct device_type wiphy_type = {
805 .name = "wlan",
806};
807
Michal Kaziordbbae262012-06-29 12:47:01 +0200808void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
809 enum nl80211_iftype iftype, int num)
810{
Johannes Bergc5a7e582012-07-04 13:28:18 +0200811 ASSERT_RTNL();
Michal Kaziordbbae262012-06-29 12:47:01 +0200812
813 rdev->num_running_ifaces += num;
814 if (iftype == NL80211_IFTYPE_MONITOR)
815 rdev->num_running_monitor_ifaces += num;
Michal Kaziordbbae262012-06-29 12:47:01 +0200816}
817
Cristian Chilipireac4f60842012-05-08 12:38:53 +0300818static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
Johannes Berg704232c2007-04-23 12:20:05 -0700819 unsigned long state,
820 void *ndev)
821{
822 struct net_device *dev = ndev;
Johannes Berg2a783c12009-07-01 21:26:45 +0200823 struct wireless_dev *wdev = dev->ieee80211_ptr;
Johannes Berg704232c2007-04-23 12:20:05 -0700824 struct cfg80211_registered_device *rdev;
Johannes Berg7527a782011-05-13 10:58:57 +0200825 int ret;
Johannes Berg704232c2007-04-23 12:20:05 -0700826
Johannes Berg2a783c12009-07-01 21:26:45 +0200827 if (!wdev)
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200828 return NOTIFY_DONE;
Johannes Berg704232c2007-04-23 12:20:05 -0700829
Johannes Berg2a783c12009-07-01 21:26:45 +0200830 rdev = wiphy_to_dev(wdev->wiphy);
Johannes Berg704232c2007-04-23 12:20:05 -0700831
Johannes Berg2a783c12009-07-01 21:26:45 +0200832 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
Johannes Berg60719ff2008-09-16 14:55:09 +0200833
Johannes Berg704232c2007-04-23 12:20:05 -0700834 switch (state) {
Marcel Holtmann053a93d2009-10-02 05:15:28 +0000835 case NETDEV_POST_INIT:
836 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
837 break;
Johannes Berg704232c2007-04-23 12:20:05 -0700838 case NETDEV_REGISTER:
Johannes Berg0ff6ce72009-08-17 12:25:37 +0200839 /*
840 * NB: cannot take rdev->mtx here because this may be
841 * called within code protected by it when interfaces
842 * are added with nl80211.
843 */
Johannes Berg667503dd2009-07-07 03:56:11 +0200844 mutex_init(&wdev->mtx);
Johannes Bergad002392009-08-18 19:51:57 +0200845 INIT_WORK(&wdev->cleanup_work, wdev_cleanup_work);
Johannes Berg667503dd2009-07-07 03:56:11 +0200846 INIT_LIST_HEAD(&wdev->event_list);
847 spin_lock_init(&wdev->event_lock);
Johannes Berg2e161f72010-08-12 15:38:38 +0200848 INIT_LIST_HEAD(&wdev->mgmt_registrations);
849 spin_lock_init(&wdev->mgmt_registrations_lock);
Jouni Malinen026331c2010-02-15 12:53:10 +0200850
Johannes Berg704232c2007-04-23 12:20:05 -0700851 mutex_lock(&rdev->devlist_mtx);
Johannes Berg89a54e42012-06-15 14:33:17 +0200852 wdev->identifier = ++rdev->wdev_id;
853 list_add_rcu(&wdev->list, &rdev->wdev_list);
Johannes Bergf5ea9122009-08-07 16:17:38 +0200854 rdev->devlist_generation++;
Johannes Berg463d0182009-07-14 00:33:35 +0200855 /* can only change netns with wiphy */
856 dev->features |= NETIF_F_NETNS_LOCAL;
857
Johannes Berg704232c2007-04-23 12:20:05 -0700858 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
859 "phy80211")) {
Joe Perchese9c02682010-11-16 19:56:49 -0800860 pr_err("failed to add phy80211 symlink to netdev!\n");
Johannes Berg704232c2007-04-23 12:20:05 -0700861 }
Johannes Berg2a783c12009-07-01 21:26:45 +0200862 wdev->netdev = dev;
Samuel Ortizb23aa672009-07-01 21:26:54 +0200863 wdev->sme_state = CFG80211_SME_IDLE;
Johannes Bergbc92afd2009-07-01 21:26:57 +0200864 mutex_unlock(&rdev->devlist_mtx);
Johannes Berg3d23e342009-09-29 23:27:28 +0200865#ifdef CONFIG_CFG80211_WEXT
Johannes Berg2a783c12009-07-01 21:26:45 +0200866 wdev->wext.default_key = -1;
867 wdev->wext.default_mgmt_key = -1;
Johannes Bergf2129352009-07-01 21:26:56 +0200868 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
Kalle Valoffb9eb32010-02-17 17:58:10 +0200869#endif
870
Johannes Berg5be83de2009-11-19 00:56:28 +0100871 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
Kalle Valoffb9eb32010-02-17 17:58:10 +0200872 wdev->ps = true;
Johannes Berg5be83de2009-11-19 00:56:28 +0100873 else
Kalle Valoffb9eb32010-02-17 17:58:10 +0200874 wdev->ps = false;
Juuso Oikarinen9043f3b2010-04-27 12:47:41 +0300875 /* allow mac80211 to determine the timeout */
876 wdev->ps_timeout = -1;
Kalle Valoffb9eb32010-02-17 17:58:10 +0200877
Stanislaw Gruszkad07d7502013-01-10 23:19:10 +0000878 netdev_set_default_ethtool_ops(dev, &cfg80211_ethtool_ops);
Johannes Bergad4bb6f2009-11-19 00:56:30 +0100879
880 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
Johannes Berg074ac8d2010-09-16 14:58:22 +0200881 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
Johannes Bergad4bb6f2009-11-19 00:56:30 +0100882 wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
883 dev->priv_flags |= IFF_DONT_BRIDGE;
Johannes Berg704232c2007-04-23 12:20:05 -0700884 break;
Johannes Berg04a773a2009-04-19 21:24:32 +0200885 case NETDEV_GOING_DOWN:
Samuel Ortizb23aa672009-07-01 21:26:54 +0200886 switch (wdev->iftype) {
887 case NL80211_IFTYPE_ADHOC:
888 cfg80211_leave_ibss(rdev, dev, true);
889 break;
Johannes Berg074ac8d2010-09-16 14:58:22 +0200890 case NL80211_IFTYPE_P2P_CLIENT:
Samuel Ortizb23aa672009-07-01 21:26:54 +0200891 case NL80211_IFTYPE_STATION:
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300892 mutex_lock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300893 __cfg80211_stop_sched_scan(rdev, false);
Luciano Coelhoc10841c2011-06-30 08:32:41 +0300894 mutex_unlock(&rdev->sched_scan_mtx);
Luciano Coelho807f8a82011-05-11 17:09:35 +0300895
Johannes Berg667503dd2009-07-07 03:56:11 +0200896 wdev_lock(wdev);
Johannes Berg3d23e342009-09-29 23:27:28 +0200897#ifdef CONFIG_CFG80211_WEXT
Johannes Bergf2129352009-07-01 21:26:56 +0200898 kfree(wdev->wext.ie);
899 wdev->wext.ie = NULL;
900 wdev->wext.ie_len = 0;
Johannes Berg0eb14642009-07-02 15:49:03 +0200901 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
Johannes Bergf2129352009-07-01 21:26:56 +0200902#endif
Johannes Berg667503dd2009-07-07 03:56:11 +0200903 __cfg80211_disconnect(rdev, dev,
904 WLAN_REASON_DEAUTH_LEAVING, true);
Johannes Berg19957bb2009-07-02 17:20:43 +0200905 cfg80211_mlme_down(rdev, dev);
Johannes Berg667503dd2009-07-07 03:56:11 +0200906 wdev_unlock(wdev);
Samuel Ortizb23aa672009-07-01 21:26:54 +0200907 break;
Johannes Berg29cbe682010-12-03 09:20:44 +0100908 case NL80211_IFTYPE_MESH_POINT:
909 cfg80211_leave_mesh(rdev, dev);
910 break;
Michal Kaziorac800142012-06-29 12:46:57 +0200911 case NL80211_IFTYPE_AP:
912 cfg80211_stop_ap(rdev, dev);
913 break;
Samuel Ortizb23aa672009-07-01 21:26:54 +0200914 default:
915 break;
916 }
Johannes Berg56d18932011-05-09 18:41:15 +0200917 wdev->beacon_interval = 0;
Johannes Berg01a0ac42009-08-20 21:36:16 +0200918 break;
919 case NETDEV_DOWN:
Michal Kaziordbbae262012-06-29 12:47:01 +0200920 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
Johannes Bergc5a7e582012-07-04 13:28:18 +0200921 dev_hold(dev);
Alban Browaeyse60d7442009-11-25 15:13:00 +0100922 queue_work(cfg80211_wq, &wdev->cleanup_work);
Johannes Berg04a773a2009-04-19 21:24:32 +0200923 break;
924 case NETDEV_UP:
Johannes Bergad002392009-08-18 19:51:57 +0200925 /*
926 * If we have a really quick DOWN/UP succession we may
927 * have this work still pending ... cancel it and see
928 * if it was pending, in which case we need to account
929 * for some of the work it would have done.
930 */
931 if (cancel_work_sync(&wdev->cleanup_work)) {
932 mutex_lock(&rdev->devlist_mtx);
933 rdev->opencount--;
934 mutex_unlock(&rdev->devlist_mtx);
935 dev_put(dev);
936 }
Johannes Berg4290cb42012-07-12 22:19:48 +0200937 cfg80211_update_iface_num(rdev, wdev->iftype, 1);
Johannes Berg667503dd2009-07-07 03:56:11 +0200938 cfg80211_lock_rdev(rdev);
Johannes Bergaee83ea2009-08-09 11:51:29 +0200939 mutex_lock(&rdev->devlist_mtx);
Johannes Berg667503dd2009-07-07 03:56:11 +0200940 wdev_lock(wdev);
Johannes Bergf2129352009-07-01 21:26:56 +0200941 switch (wdev->iftype) {
Johannes Berg29cbe682010-12-03 09:20:44 +0100942#ifdef CONFIG_CFG80211_WEXT
Johannes Bergf2129352009-07-01 21:26:56 +0200943 case NL80211_IFTYPE_ADHOC:
Johannes Bergfffd0932009-07-08 14:22:54 +0200944 cfg80211_ibss_wext_join(rdev, wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200945 break;
Johannes Bergf2129352009-07-01 21:26:56 +0200946 case NL80211_IFTYPE_STATION:
Johannes Bergfffd0932009-07-08 14:22:54 +0200947 cfg80211_mgd_wext_connect(rdev, wdev);
Johannes Berg04a773a2009-04-19 21:24:32 +0200948 break;
Johannes Berg29cbe682010-12-03 09:20:44 +0100949#endif
Javier Cardonac80d5452010-12-16 17:37:49 -0800950#ifdef CONFIG_MAC80211_MESH
Johannes Berg29cbe682010-12-03 09:20:44 +0100951 case NL80211_IFTYPE_MESH_POINT:
Javier Cardonac80d5452010-12-16 17:37:49 -0800952 {
953 /* backward compat code... */
954 struct mesh_setup setup;
955 memcpy(&setup, &default_mesh_setup,
956 sizeof(setup));
957 /* back compat only needed for mesh_id */
958 setup.mesh_id = wdev->ssid;
959 setup.mesh_id_len = wdev->mesh_id_up_len;
960 if (wdev->mesh_id_up_len)
961 __cfg80211_join_mesh(rdev, dev,
962 &setup,
963 &default_mesh_config);
964 break;
965 }
966#endif
Johannes Bergf2129352009-07-01 21:26:56 +0200967 default:
968 break;
969 }
Johannes Berg667503dd2009-07-07 03:56:11 +0200970 wdev_unlock(wdev);
Johannes Bergad002392009-08-18 19:51:57 +0200971 rdev->opencount++;
Johannes Bergaee83ea2009-08-09 11:51:29 +0200972 mutex_unlock(&rdev->devlist_mtx);
Johannes Berg667503dd2009-07-07 03:56:11 +0200973 cfg80211_unlock_rdev(rdev);
Juuso Oikarinenbf6a0572011-01-31 15:52:58 +0200974
975 /*
976 * Configure power management to the driver here so that its
977 * correctly set also after interface type changes etc.
978 */
Eliad Peller5966f2d2011-07-19 12:57:13 +0300979 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
980 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
Juuso Oikarinenbf6a0572011-01-31 15:52:58 +0200981 rdev->ops->set_power_mgmt)
Hila Gonene35e4d22012-06-27 17:19:42 +0300982 if (rdev_set_power_mgmt(rdev, dev, wdev->ps,
983 wdev->ps_timeout)) {
Juuso Oikarinenbf6a0572011-01-31 15:52:58 +0200984 /* assume this means it's off */
985 wdev->ps = false;
986 }
Johannes Berg2a783c12009-07-01 21:26:45 +0200987 break;
Johannes Berg704232c2007-04-23 12:20:05 -0700988 case NETDEV_UNREGISTER:
Johannes Berg0ff6ce72009-08-17 12:25:37 +0200989 /*
990 * NB: cannot take rdev->mtx here because this may be
991 * called within code protected by it when interfaces
992 * are removed with nl80211.
993 */
Johannes Berg704232c2007-04-23 12:20:05 -0700994 mutex_lock(&rdev->devlist_mtx);
Johannes Berge40cbdac2009-07-30 14:04:01 +0200995 /*
996 * It is possible to get NETDEV_UNREGISTER
997 * multiple times. To detect that, check
998 * that the interface is still on the list
999 * of registered interfaces, and only then
1000 * remove and clean it up.
1001 */
Johannes Berg2a783c12009-07-01 21:26:45 +02001002 if (!list_empty(&wdev->list)) {
Johannes Berg704232c2007-04-23 12:20:05 -07001003 sysfs_remove_link(&dev->dev.kobj, "phy80211");
Johannes Berg5f2aa252010-01-17 15:49:02 +01001004 list_del_rcu(&wdev->list);
Johannes Bergf5ea9122009-08-07 16:17:38 +02001005 rdev->devlist_generation++;
Johannes Berg2e161f72010-08-12 15:38:38 +02001006 cfg80211_mlme_purge_registrations(wdev);
Johannes Berg3d23e342009-09-29 23:27:28 +02001007#ifdef CONFIG_CFG80211_WEXT
Johannes Berge40cbdac2009-07-30 14:04:01 +02001008 kfree(wdev->wext.keys);
1009#endif
Johannes Berg704232c2007-04-23 12:20:05 -07001010 }
1011 mutex_unlock(&rdev->devlist_mtx);
Johannes Berg5f2aa252010-01-17 15:49:02 +01001012 /*
1013 * synchronise (so that we won't find this netdev
1014 * from other code any more) and then clear the list
1015 * head so that the above code can safely check for
1016 * !list_empty() to avoid double-cleanup.
1017 */
1018 synchronize_rcu();
1019 INIT_LIST_HEAD(&wdev->list);
Daniel Drake1f6fc432012-08-02 18:41:48 +01001020 /*
1021 * Ensure that all events have been processed and
1022 * freed.
1023 */
1024 cfg80211_process_wdev_events(wdev);
Johannes Berg704232c2007-04-23 12:20:05 -07001025 break;
Johannes Berg1f87f7d2009-06-02 13:01:41 +02001026 case NETDEV_PRE_UP:
Johannes Berg0b20633d2009-07-07 03:56:13 +02001027 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
1028 return notifier_from_errno(-EOPNOTSUPP);
Johannes Berg1f87f7d2009-06-02 13:01:41 +02001029 if (rfkill_blocked(rdev->rfkill))
1030 return notifier_from_errno(-ERFKILL);
Michal Kaziore4e32452012-06-29 12:47:08 +02001031 mutex_lock(&rdev->devlist_mtx);
Johannes Berg7527a782011-05-13 10:58:57 +02001032 ret = cfg80211_can_add_interface(rdev, wdev->iftype);
Michal Kaziore4e32452012-06-29 12:47:08 +02001033 mutex_unlock(&rdev->devlist_mtx);
Johannes Berg7527a782011-05-13 10:58:57 +02001034 if (ret)
1035 return notifier_from_errno(ret);
Johannes Berg1f87f7d2009-06-02 13:01:41 +02001036 break;
Johannes Berg704232c2007-04-23 12:20:05 -07001037 }
1038
Johannes Berg1f87f7d2009-06-02 13:01:41 +02001039 return NOTIFY_DONE;
Johannes Berg704232c2007-04-23 12:20:05 -07001040}
1041
1042static struct notifier_block cfg80211_netdev_notifier = {
1043 .notifier_call = cfg80211_netdev_notifier_call,
1044};
1045
Johannes Berg463d0182009-07-14 00:33:35 +02001046static void __net_exit cfg80211_pernet_exit(struct net *net)
1047{
1048 struct cfg80211_registered_device *rdev;
1049
1050 rtnl_lock();
1051 mutex_lock(&cfg80211_mutex);
1052 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1053 if (net_eq(wiphy_net(&rdev->wiphy), net))
1054 WARN_ON(cfg80211_switch_netns(rdev, &init_net));
1055 }
1056 mutex_unlock(&cfg80211_mutex);
1057 rtnl_unlock();
1058}
1059
1060static struct pernet_operations cfg80211_pernet_ops = {
1061 .exit = cfg80211_pernet_exit,
1062};
1063
1064static int __init cfg80211_init(void)
Johannes Berg704232c2007-04-23 12:20:05 -07001065{
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001066 int err;
1067
Johannes Berg463d0182009-07-14 00:33:35 +02001068 err = register_pernet_device(&cfg80211_pernet_ops);
1069 if (err)
1070 goto out_fail_pernet;
1071
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001072 err = wiphy_sysfs_init();
Johannes Berg704232c2007-04-23 12:20:05 -07001073 if (err)
1074 goto out_fail_sysfs;
1075
1076 err = register_netdevice_notifier(&cfg80211_netdev_notifier);
1077 if (err)
1078 goto out_fail_notifier;
1079
Johannes Berg55682962007-09-20 13:09:35 -04001080 err = nl80211_init();
1081 if (err)
1082 goto out_fail_nl80211;
1083
Johannes Berg704232c2007-04-23 12:20:05 -07001084 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
1085
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001086 err = regulatory_init();
1087 if (err)
1088 goto out_fail_reg;
1089
Alban Browaeyse60d7442009-11-25 15:13:00 +01001090 cfg80211_wq = create_singlethread_workqueue("cfg80211");
1091 if (!cfg80211_wq)
1092 goto out_fail_wq;
1093
Johannes Berg704232c2007-04-23 12:20:05 -07001094 return 0;
1095
Alban Browaeyse60d7442009-11-25 15:13:00 +01001096out_fail_wq:
1097 regulatory_exit();
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001098out_fail_reg:
1099 debugfs_remove(ieee80211_debugfs_dir);
Johannes Berg55682962007-09-20 13:09:35 -04001100out_fail_nl80211:
1101 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
Johannes Berg704232c2007-04-23 12:20:05 -07001102out_fail_notifier:
1103 wiphy_sysfs_exit();
1104out_fail_sysfs:
Johannes Berg463d0182009-07-14 00:33:35 +02001105 unregister_pernet_device(&cfg80211_pernet_ops);
1106out_fail_pernet:
Johannes Berg704232c2007-04-23 12:20:05 -07001107 return err;
1108}
Johannes Berg3a462462007-09-10 13:44:45 +02001109subsys_initcall(cfg80211_init);
Johannes Berg704232c2007-04-23 12:20:05 -07001110
Uwe Kleine-Königf884e382010-06-18 09:38:54 +02001111static void __exit cfg80211_exit(void)
Johannes Berg704232c2007-04-23 12:20:05 -07001112{
1113 debugfs_remove(ieee80211_debugfs_dir);
Johannes Berg55682962007-09-20 13:09:35 -04001114 nl80211_exit();
Johannes Berg704232c2007-04-23 12:20:05 -07001115 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1116 wiphy_sysfs_exit();
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001117 regulatory_exit();
Johannes Berg463d0182009-07-14 00:33:35 +02001118 unregister_pernet_device(&cfg80211_pernet_ops);
Alban Browaeyse60d7442009-11-25 15:13:00 +01001119 destroy_workqueue(cfg80211_wq);
Johannes Berg704232c2007-04-23 12:20:05 -07001120}
1121module_exit(cfg80211_exit);