Eric Lee / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit bf6a0579f60ae5225280c82cc52b51db1255e7fb

Authored by Juuso Oikarinen
Committed by John W. Linville
1 parent 73b30dfe4f
Exists in master and in 39 other branches 8mp-imx_5.4.70_2.3.0, 8qm-imx_5.4.70_2.3.0, emb_imx_lf-5.15.y, emb_lf-6.1.y, imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, imx_4.1.15_1.0.0_ga, pitx_8mp_lf-5.10.y, rt-smarc-imx_4.1.15_1.0.0_ga, rt_linux_5.15.71, smarc-8m-android-11.0.0_2.0.0, smarc-imx6_4.14.98_2.0.0_ga, smarc-imx6_4.9.88_2.0.0_ga, smarc-imx7_4.14.98_2.0.0_ga, smarc-imx7_4.9.11_1.0.0_ga, smarc-imx7_4.9.88_2.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-imx_4.1.15_1.0.0_ga, smarc-imx_4.9.11_1.0.0_ga, smarc-imx_4.9.51_imx8m_ga, smarc-imx_4.9.88_2.0.0_ga, smarc-m6.0.1_2.1.0-ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_1.2.0_ga, smarc_8m_00d0_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.14.78_1.0.0_ga, smarc_8m_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.19.35_1.1.0, smarc_8mm_imx_4.14.78_1.0.0_ga, smarc_8mm_imx_4.14.98_2.0.0_ga, smarc_8mm_imx_4.19.35_1.1.0, smarc_8mm_imx_5.4.24_2.1.0, smarc_8mp_lf-5.10.y, smarc_8mq_imx_5.4.24_2.1.0, smarc_8mq_lf-5.10.y, smarc_imx_lf-5.15.y

cfg80211: Fix power save state after interface type change 

Currently cfg80211 only configures the PSM state to the driver upon creation
of a new virtual interface, but not after interface type change. The mac80211
on the other hand reinitializes its sdata structure every time the interface
type is changed, losing the PSM configuration.

Hence, if the interface type is changed to, say, ad-hoc and then back to
managed, "iw wlan0 get power_save" will claim that PSM is enabled, when in
fact on mac80211 level it is not.

Fix this in cfg80211 by configuring the PSM state to the driver each time
the interface is brought up instead of just when the interface is created.

Signed-off-by: Juuso Oikarinen <juuso.oikarinen@nokia.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

Showing 1 changed file with 13 additions and 7 deletions Inline Diff

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