blob: 8b0e874a3d65f72ce25e7881152f883de2e8409b [file] [log] [blame]
Jiri Bencf0706e822007-05-05 11:45:53 -07001/*
2 * mac80211 configuration hooks for cfg80211
3 *
Jouni Malinen026331c2010-02-15 12:53:10 +02004 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
Jiri Bencf0706e822007-05-05 11:45:53 -07005 *
6 * This file is GPLv2 as found in COPYING.
7 */
8
Johannes Berge8cbb4c2007-12-19 02:03:30 +01009#include <linux/ieee80211.h>
Jiri Bencf0706e822007-05-05 11:45:53 -070010#include <linux/nl80211.h>
11#include <linux/rtnetlink.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090012#include <linux/slab.h>
Eric W. Biederman881d9662007-09-17 11:56:21 -070013#include <net/net_namespace.h>
Johannes Berg5dfdaf52007-12-19 02:03:33 +010014#include <linux/rcupdate.h>
Jiri Bencf0706e822007-05-05 11:45:53 -070015#include <net/cfg80211.h>
16#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020017#include "driver-ops.h"
Michael Wue0eb6852007-09-18 17:29:21 -040018#include "cfg.h"
Johannes Berg2c8dccc2008-04-08 15:14:40 -040019#include "rate.h"
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +010020#include "mesh.h"
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +010021
Jiri Bencf0706e822007-05-05 11:45:53 -070022static int ieee80211_add_iface(struct wiphy *wiphy, char *name,
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +010023 enum nl80211_iftype type, u32 *flags,
24 struct vif_params *params)
Jiri Bencf0706e822007-05-05 11:45:53 -070025{
26 struct ieee80211_local *local = wiphy_priv(wiphy);
Michael Wu8cc9a732008-01-31 19:48:23 +010027 struct net_device *dev;
28 struct ieee80211_sub_if_data *sdata;
29 int err;
Jiri Bencf0706e822007-05-05 11:45:53 -070030
Johannes Berg05c914f2008-09-11 00:01:58 +020031 err = ieee80211_if_add(local, name, &dev, type, params);
32 if (err || type != NL80211_IFTYPE_MONITOR || !flags)
Michael Wu8cc9a732008-01-31 19:48:23 +010033 return err;
34
35 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
36 sdata->u.mntr_flags = *flags;
37 return 0;
Jiri Bencf0706e822007-05-05 11:45:53 -070038}
39
Johannes Berg463d0182009-07-14 00:33:35 +020040static int ieee80211_del_iface(struct wiphy *wiphy, struct net_device *dev)
Jiri Bencf0706e822007-05-05 11:45:53 -070041{
Johannes Berg463d0182009-07-14 00:33:35 +020042 ieee80211_if_remove(IEEE80211_DEV_TO_SUB_IF(dev));
Jiri Bencf0706e822007-05-05 11:45:53 -070043
Johannes Berg75636522008-07-09 14:40:35 +020044 return 0;
Jiri Bencf0706e822007-05-05 11:45:53 -070045}
46
Johannes Berge36d56b2009-06-09 21:04:43 +020047static int ieee80211_change_iface(struct wiphy *wiphy,
48 struct net_device *dev,
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +010049 enum nl80211_iftype type, u32 *flags,
50 struct vif_params *params)
Johannes Berg42613db2007-09-28 21:52:27 +020051{
Johannes Berg9607e6b2009-12-23 13:15:31 +010052 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Bergf3947e22008-07-09 14:40:36 +020053 int ret;
Johannes Berg42613db2007-09-28 21:52:27 +020054
Johannes Berg05c914f2008-09-11 00:01:58 +020055 ret = ieee80211_if_change_type(sdata, type);
Johannes Bergf3947e22008-07-09 14:40:36 +020056 if (ret)
57 return ret;
Johannes Berg42613db2007-09-28 21:52:27 +020058
Johannes Berg902acc72008-02-23 15:17:19 +010059 if (ieee80211_vif_is_mesh(&sdata->vif) && params->mesh_id_len)
Johannes Berg472dbc42008-09-11 00:01:49 +020060 ieee80211_sdata_set_mesh_id(sdata,
61 params->mesh_id_len,
62 params->mesh_id);
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +010063
Johannes Berg9bc383d2009-11-19 11:55:19 +010064 if (type == NL80211_IFTYPE_AP_VLAN &&
65 params && params->use_4addr == 0)
66 rcu_assign_pointer(sdata->u.vlan.sta, NULL);
67 else if (type == NL80211_IFTYPE_STATION &&
68 params && params->use_4addr >= 0)
69 sdata->u.mgd.use_4addr = params->use_4addr;
70
Christian Lamparter85416a42010-10-02 13:17:07 +020071 if (sdata->vif.type == NL80211_IFTYPE_MONITOR && flags) {
72 struct ieee80211_local *local = sdata->local;
73
74 if (ieee80211_sdata_running(sdata)) {
75 /*
76 * Prohibit MONITOR_FLAG_COOK_FRAMES to be
77 * changed while the interface is up.
78 * Else we would need to add a lot of cruft
79 * to update everything:
80 * cooked_mntrs, monitor and all fif_* counters
81 * reconfigure hardware
82 */
83 if ((*flags & MONITOR_FLAG_COOK_FRAMES) !=
84 (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES))
85 return -EBUSY;
86
87 ieee80211_adjust_monitor_flags(sdata, -1);
88 sdata->u.mntr_flags = *flags;
89 ieee80211_adjust_monitor_flags(sdata, 1);
90
91 ieee80211_configure_filter(local);
92 } else {
93 /*
94 * Because the interface is down, ieee80211_do_stop
95 * and ieee80211_do_open take care of "everything"
96 * mentioned in the comment above.
97 */
98 sdata->u.mntr_flags = *flags;
99 }
100 }
Felix Fietkauf7917af2010-04-27 00:26:34 +0200101
Johannes Berg42613db2007-09-28 21:52:27 +0200102 return 0;
103}
104
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100105static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
Johannes Berge31b8212010-10-05 19:39:30 +0200106 u8 key_idx, bool pairwise, const u8 *mac_addr,
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100107 struct key_params *params)
108{
Johannes Berg26a58452010-08-27 12:35:55 +0200109 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100110 struct sta_info *sta = NULL;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100111 struct ieee80211_key *key;
Johannes Berg3b967662008-04-08 17:56:52 +0200112 int err;
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100113
Johannes Berg26a58452010-08-27 12:35:55 +0200114 if (!ieee80211_sdata_running(sdata))
Johannes Bergad0e2b52010-06-01 10:19:19 +0200115 return -ENETDOWN;
116
Johannes Berg97359d12010-08-10 09:46:38 +0200117 /* reject WEP and TKIP keys if WEP failed to initialize */
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100118 switch (params->cipher) {
119 case WLAN_CIPHER_SUITE_WEP40:
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100120 case WLAN_CIPHER_SUITE_TKIP:
Johannes Berg97359d12010-08-10 09:46:38 +0200121 case WLAN_CIPHER_SUITE_WEP104:
122 if (IS_ERR(sdata->local->wep_tx_tfm))
123 return -EINVAL;
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200124 break;
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100125 default:
Johannes Berg97359d12010-08-10 09:46:38 +0200126 break;
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100127 }
128
Johannes Berg97359d12010-08-10 09:46:38 +0200129 key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
130 params->key, params->seq_len, params->seq);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100131 if (IS_ERR(key))
132 return PTR_ERR(key);
Johannes Bergdb4d1162008-02-25 16:27:45 +0100133
Johannes Berge31b8212010-10-05 19:39:30 +0200134 if (pairwise)
135 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
136
Johannes Bergad0e2b52010-06-01 10:19:19 +0200137 mutex_lock(&sdata->local->sta_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200138
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100139 if (mac_addr) {
Felix Fietkau0e5ded52010-01-08 18:10:58 +0100140 sta = sta_info_get_bss(sdata, mac_addr);
Johannes Bergdb4d1162008-02-25 16:27:45 +0100141 if (!sta) {
Jouni Malinen32162a42010-07-26 15:52:03 -0700142 ieee80211_key_free(sdata->local, key);
Johannes Berg3b967662008-04-08 17:56:52 +0200143 err = -ENOENT;
144 goto out_unlock;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100145 }
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100146 }
147
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300148 err = ieee80211_key_link(key, sdata, sta);
149 if (err)
150 ieee80211_key_free(sdata->local, key);
Johannes Bergdb4d1162008-02-25 16:27:45 +0100151
Johannes Berg3b967662008-04-08 17:56:52 +0200152 out_unlock:
Johannes Bergad0e2b52010-06-01 10:19:19 +0200153 mutex_unlock(&sdata->local->sta_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200154
155 return err;
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100156}
157
158static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
Johannes Berge31b8212010-10-05 19:39:30 +0200159 u8 key_idx, bool pairwise, const u8 *mac_addr)
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100160{
161 struct ieee80211_sub_if_data *sdata;
162 struct sta_info *sta;
163 int ret;
164
165 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
166
Johannes Bergad0e2b52010-06-01 10:19:19 +0200167 mutex_lock(&sdata->local->sta_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200168
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100169 if (mac_addr) {
Johannes Berg3b967662008-04-08 17:56:52 +0200170 ret = -ENOENT;
171
Felix Fietkau0e5ded52010-01-08 18:10:58 +0100172 sta = sta_info_get_bss(sdata, mac_addr);
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100173 if (!sta)
Johannes Berg3b967662008-04-08 17:56:52 +0200174 goto out_unlock;
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100175
Johannes Berge31b8212010-10-05 19:39:30 +0200176 if (pairwise) {
177 if (sta->ptk) {
178 ieee80211_key_free(sdata->local, sta->ptk);
179 ret = 0;
180 }
181 } else {
182 if (sta->gtk[key_idx]) {
183 ieee80211_key_free(sdata->local,
184 sta->gtk[key_idx]);
185 ret = 0;
186 }
Johannes Berg3b967662008-04-08 17:56:52 +0200187 }
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100188
Johannes Berg3b967662008-04-08 17:56:52 +0200189 goto out_unlock;
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100190 }
191
Johannes Berg3b967662008-04-08 17:56:52 +0200192 if (!sdata->keys[key_idx]) {
193 ret = -ENOENT;
194 goto out_unlock;
195 }
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100196
Jouni Malinen32162a42010-07-26 15:52:03 -0700197 ieee80211_key_free(sdata->local, sdata->keys[key_idx]);
Johannes Bergdb4d1162008-02-25 16:27:45 +0100198 WARN_ON(sdata->keys[key_idx]);
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100199
Johannes Berg3b967662008-04-08 17:56:52 +0200200 ret = 0;
201 out_unlock:
Johannes Bergad0e2b52010-06-01 10:19:19 +0200202 mutex_unlock(&sdata->local->sta_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200203
204 return ret;
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100205}
206
Johannes Berg62da92f2007-12-19 02:03:31 +0100207static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
Johannes Berge31b8212010-10-05 19:39:30 +0200208 u8 key_idx, bool pairwise, const u8 *mac_addr,
209 void *cookie,
Johannes Berg62da92f2007-12-19 02:03:31 +0100210 void (*callback)(void *cookie,
211 struct key_params *params))
212{
Johannes Berg14db74b2008-07-29 13:22:52 +0200213 struct ieee80211_sub_if_data *sdata;
Johannes Berg62da92f2007-12-19 02:03:31 +0100214 struct sta_info *sta = NULL;
215 u8 seq[6] = {0};
216 struct key_params params;
Johannes Berge31b8212010-10-05 19:39:30 +0200217 struct ieee80211_key *key = NULL;
Johannes Berg62da92f2007-12-19 02:03:31 +0100218 u32 iv32;
219 u16 iv16;
220 int err = -ENOENT;
221
Johannes Berg14db74b2008-07-29 13:22:52 +0200222 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
223
Johannes Berg3b967662008-04-08 17:56:52 +0200224 rcu_read_lock();
225
Johannes Berg62da92f2007-12-19 02:03:31 +0100226 if (mac_addr) {
Felix Fietkau0e5ded52010-01-08 18:10:58 +0100227 sta = sta_info_get_bss(sdata, mac_addr);
Johannes Berg62da92f2007-12-19 02:03:31 +0100228 if (!sta)
229 goto out;
230
Johannes Berge31b8212010-10-05 19:39:30 +0200231 if (pairwise)
232 key = sta->ptk;
233 else if (key_idx < NUM_DEFAULT_KEYS)
234 key = sta->gtk[key_idx];
Johannes Berg62da92f2007-12-19 02:03:31 +0100235 } else
236 key = sdata->keys[key_idx];
237
238 if (!key)
239 goto out;
240
241 memset(&params, 0, sizeof(params));
242
Johannes Berg97359d12010-08-10 09:46:38 +0200243 params.cipher = key->conf.cipher;
Johannes Berg62da92f2007-12-19 02:03:31 +0100244
Johannes Berg97359d12010-08-10 09:46:38 +0200245 switch (key->conf.cipher) {
246 case WLAN_CIPHER_SUITE_TKIP:
Harvey Harrisonb0f76b32008-05-14 16:26:19 -0700247 iv32 = key->u.tkip.tx.iv32;
248 iv16 = key->u.tkip.tx.iv16;
Johannes Berg62da92f2007-12-19 02:03:31 +0100249
Johannes Berg24487982009-04-23 18:52:52 +0200250 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
251 drv_get_tkip_seq(sdata->local,
252 key->conf.hw_key_idx,
253 &iv32, &iv16);
Johannes Berg62da92f2007-12-19 02:03:31 +0100254
255 seq[0] = iv16 & 0xff;
256 seq[1] = (iv16 >> 8) & 0xff;
257 seq[2] = iv32 & 0xff;
258 seq[3] = (iv32 >> 8) & 0xff;
259 seq[4] = (iv32 >> 16) & 0xff;
260 seq[5] = (iv32 >> 24) & 0xff;
261 params.seq = seq;
262 params.seq_len = 6;
263 break;
Johannes Berg97359d12010-08-10 09:46:38 +0200264 case WLAN_CIPHER_SUITE_CCMP:
Johannes Berg62da92f2007-12-19 02:03:31 +0100265 seq[0] = key->u.ccmp.tx_pn[5];
266 seq[1] = key->u.ccmp.tx_pn[4];
267 seq[2] = key->u.ccmp.tx_pn[3];
268 seq[3] = key->u.ccmp.tx_pn[2];
269 seq[4] = key->u.ccmp.tx_pn[1];
270 seq[5] = key->u.ccmp.tx_pn[0];
271 params.seq = seq;
272 params.seq_len = 6;
273 break;
Johannes Berg97359d12010-08-10 09:46:38 +0200274 case WLAN_CIPHER_SUITE_AES_CMAC:
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200275 seq[0] = key->u.aes_cmac.tx_pn[5];
276 seq[1] = key->u.aes_cmac.tx_pn[4];
277 seq[2] = key->u.aes_cmac.tx_pn[3];
278 seq[3] = key->u.aes_cmac.tx_pn[2];
279 seq[4] = key->u.aes_cmac.tx_pn[1];
280 seq[5] = key->u.aes_cmac.tx_pn[0];
281 params.seq = seq;
282 params.seq_len = 6;
283 break;
Johannes Berg62da92f2007-12-19 02:03:31 +0100284 }
285
286 params.key = key->conf.key;
287 params.key_len = key->conf.keylen;
288
289 callback(cookie, &params);
290 err = 0;
291
292 out:
Johannes Berg3b967662008-04-08 17:56:52 +0200293 rcu_read_unlock();
Johannes Berg62da92f2007-12-19 02:03:31 +0100294 return err;
295}
296
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100297static int ieee80211_config_default_key(struct wiphy *wiphy,
298 struct net_device *dev,
299 u8 key_idx)
300{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200301 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100302
Johannes Berge8cbb4c2007-12-19 02:03:30 +0100303 ieee80211_set_default_key(sdata, key_idx);
304
305 return 0;
306}
307
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200308static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
309 struct net_device *dev,
310 u8 key_idx)
311{
Johannes Berg66c52422010-07-22 13:58:51 +0200312 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200313
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200314 ieee80211_set_default_mgmt_key(sdata, key_idx);
315
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200316 return 0;
317}
318
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100319static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
320{
Johannes Bergd0709a62008-02-25 16:27:46 +0100321 struct ieee80211_sub_if_data *sdata = sta->sdata;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100322
Johannes Bergf5ea9122009-08-07 16:17:38 +0200323 sinfo->generation = sdata->local->sta_generation;
324
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100325 sinfo->filled = STATION_INFO_INACTIVE_TIME |
326 STATION_INFO_RX_BYTES |
Henning Rogge420e7fa2008-12-11 22:04:19 +0100327 STATION_INFO_TX_BYTES |
Jouni Malinen98c8a60a2009-02-17 13:24:57 +0200328 STATION_INFO_RX_PACKETS |
329 STATION_INFO_TX_PACKETS |
Henning Rogge420e7fa2008-12-11 22:04:19 +0100330 STATION_INFO_TX_BITRATE;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100331
332 sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
333 sinfo->rx_bytes = sta->rx_bytes;
334 sinfo->tx_bytes = sta->tx_bytes;
Jouni Malinen98c8a60a2009-02-17 13:24:57 +0200335 sinfo->rx_packets = sta->rx_packets;
336 sinfo->tx_packets = sta->tx_packets;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100337
John W. Linville19deffb2009-12-08 17:10:13 -0500338 if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) ||
339 (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) {
Henning Rogge420e7fa2008-12-11 22:04:19 +0100340 sinfo->filled |= STATION_INFO_SIGNAL;
341 sinfo->signal = (s8)sta->last_signal;
342 }
343
344 sinfo->txrate.flags = 0;
345 if (sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)
346 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
347 if (sta->last_tx_rate.flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
348 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
349 if (sta->last_tx_rate.flags & IEEE80211_TX_RC_SHORT_GI)
350 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
351
352 if (!(sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)) {
353 struct ieee80211_supported_band *sband;
354 sband = sta->local->hw.wiphy->bands[
355 sta->local->hw.conf.channel->band];
356 sinfo->txrate.legacy =
357 sband->bitrates[sta->last_tx_rate.idx].bitrate;
358 } else
359 sinfo->txrate.mcs = sta->last_tx_rate.idx;
360
Johannes Berg902acc72008-02-23 15:17:19 +0100361 if (ieee80211_vif_is_mesh(&sdata->vif)) {
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100362#ifdef CONFIG_MAC80211_MESH
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100363 sinfo->filled |= STATION_INFO_LLID |
364 STATION_INFO_PLID |
365 STATION_INFO_PLINK_STATE;
366
367 sinfo->llid = le16_to_cpu(sta->llid);
368 sinfo->plid = le16_to_cpu(sta->plid);
369 sinfo->plink_state = sta->plink_state;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100370#endif
Johannes Berg902acc72008-02-23 15:17:19 +0100371 }
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100372}
373
374
375static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
376 int idx, u8 *mac, struct station_info *sinfo)
377{
Johannes Berg3b53fde82009-11-16 12:00:37 +0100378 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100379 struct sta_info *sta;
Johannes Bergd0709a62008-02-25 16:27:46 +0100380 int ret = -ENOENT;
381
382 rcu_read_lock();
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100383
Johannes Berg3b53fde82009-11-16 12:00:37 +0100384 sta = sta_info_get_by_idx(sdata, idx);
Johannes Bergd0709a62008-02-25 16:27:46 +0100385 if (sta) {
386 ret = 0;
Johannes Berg17741cd2008-09-11 00:02:02 +0200387 memcpy(mac, sta->sta.addr, ETH_ALEN);
Johannes Bergd0709a62008-02-25 16:27:46 +0100388 sta_set_sinfo(sta, sinfo);
389 }
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100390
Johannes Bergd0709a62008-02-25 16:27:46 +0100391 rcu_read_unlock();
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100392
Johannes Bergd0709a62008-02-25 16:27:46 +0100393 return ret;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100394}
395
Holger Schurig12897232010-04-19 10:23:57 +0200396static int ieee80211_dump_survey(struct wiphy *wiphy, struct net_device *dev,
397 int idx, struct survey_info *survey)
398{
399 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
400
Holger Schurig12897232010-04-19 10:23:57 +0200401 return drv_get_survey(local, idx, survey);
402}
403
Johannes Berg7bbdd2d2007-12-19 02:03:37 +0100404static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
Luis Carlos Cobo2ec600d2008-02-23 15:17:06 +0100405 u8 *mac, struct station_info *sinfo)
Johannes Berg7bbdd2d2007-12-19 02:03:37 +0100406{
Johannes Bergabe60632009-11-25 17:46:18 +0100407 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Berg7bbdd2d2007-12-19 02:03:37 +0100408 struct sta_info *sta;
Johannes Bergd0709a62008-02-25 16:27:46 +0100409 int ret = -ENOENT;
Johannes Berg7bbdd2d2007-12-19 02:03:37 +0100410
Johannes Bergd0709a62008-02-25 16:27:46 +0100411 rcu_read_lock();
Johannes Berg7bbdd2d2007-12-19 02:03:37 +0100412
Felix Fietkau0e5ded52010-01-08 18:10:58 +0100413 sta = sta_info_get_bss(sdata, mac);
Johannes Bergd0709a62008-02-25 16:27:46 +0100414 if (sta) {
415 ret = 0;
416 sta_set_sinfo(sta, sinfo);
417 }
418
419 rcu_read_unlock();
420
421 return ret;
Johannes Berg7bbdd2d2007-12-19 02:03:37 +0100422}
423
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100424/*
425 * This handles both adding a beacon and setting new beacon info
426 */
427static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata,
428 struct beacon_parameters *params)
429{
430 struct beacon_data *new, *old;
431 int new_head_len, new_tail_len;
432 int size;
433 int err = -EINVAL;
434
435 old = sdata->u.ap.beacon;
436
437 /* head must not be zero-length */
438 if (params->head && !params->head_len)
439 return -EINVAL;
440
441 /*
442 * This is a kludge. beacon interval should really be part
443 * of the beacon information.
444 */
Johannes Berg57c4d7b2009-04-23 16:10:04 +0200445 if (params->interval &&
446 (sdata->vif.bss_conf.beacon_int != params->interval)) {
447 sdata->vif.bss_conf.beacon_int = params->interval;
448 ieee80211_bss_info_change_notify(sdata,
449 BSS_CHANGED_BEACON_INT);
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100450 }
451
452 /* Need to have a beacon head if we don't have one yet */
453 if (!params->head && !old)
454 return err;
455
456 /* sorry, no way to start beaconing without dtim period */
457 if (!params->dtim_period && !old)
458 return err;
459
460 /* new or old head? */
461 if (params->head)
462 new_head_len = params->head_len;
463 else
464 new_head_len = old->head_len;
465
466 /* new or old tail? */
467 if (params->tail || !old)
468 /* params->tail_len will be zero for !params->tail */
469 new_tail_len = params->tail_len;
470 else
471 new_tail_len = old->tail_len;
472
473 size = sizeof(*new) + new_head_len + new_tail_len;
474
475 new = kzalloc(size, GFP_KERNEL);
476 if (!new)
477 return -ENOMEM;
478
479 /* start filling the new info now */
480
481 /* new or old dtim period? */
482 if (params->dtim_period)
483 new->dtim_period = params->dtim_period;
484 else
485 new->dtim_period = old->dtim_period;
486
487 /*
488 * pointers go into the block we allocated,
489 * memory is | beacon_data | head | tail |
490 */
491 new->head = ((u8 *) new) + sizeof(*new);
492 new->tail = new->head + new_head_len;
493 new->head_len = new_head_len;
494 new->tail_len = new_tail_len;
495
496 /* copy in head */
497 if (params->head)
498 memcpy(new->head, params->head, new_head_len);
499 else
500 memcpy(new->head, old->head, new_head_len);
501
502 /* copy in optional tail */
503 if (params->tail)
504 memcpy(new->tail, params->tail, new_tail_len);
505 else
506 if (old)
507 memcpy(new->tail, old->tail, new_tail_len);
508
Johannes Berg19885c42010-02-05 11:45:06 +0100509 sdata->vif.bss_conf.dtim_period = new->dtim_period;
510
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100511 rcu_assign_pointer(sdata->u.ap.beacon, new);
512
513 synchronize_rcu();
514
515 kfree(old);
516
Johannes Berg2d0ddec2009-04-23 16:13:26 +0200517 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED |
518 BSS_CHANGED_BEACON);
519 return 0;
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100520}
521
522static int ieee80211_add_beacon(struct wiphy *wiphy, struct net_device *dev,
523 struct beacon_parameters *params)
524{
Johannes Berg14db74b2008-07-29 13:22:52 +0200525 struct ieee80211_sub_if_data *sdata;
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100526 struct beacon_data *old;
527
Johannes Berg14db74b2008-07-29 13:22:52 +0200528 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
529
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100530 old = sdata->u.ap.beacon;
531
532 if (old)
533 return -EALREADY;
534
535 return ieee80211_config_beacon(sdata, params);
536}
537
538static int ieee80211_set_beacon(struct wiphy *wiphy, struct net_device *dev,
539 struct beacon_parameters *params)
540{
Johannes Berg14db74b2008-07-29 13:22:52 +0200541 struct ieee80211_sub_if_data *sdata;
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100542 struct beacon_data *old;
543
Johannes Berg14db74b2008-07-29 13:22:52 +0200544 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
545
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100546 old = sdata->u.ap.beacon;
547
548 if (!old)
549 return -ENOENT;
550
551 return ieee80211_config_beacon(sdata, params);
552}
553
554static int ieee80211_del_beacon(struct wiphy *wiphy, struct net_device *dev)
555{
Johannes Berg14db74b2008-07-29 13:22:52 +0200556 struct ieee80211_sub_if_data *sdata;
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100557 struct beacon_data *old;
558
Johannes Berg14db74b2008-07-29 13:22:52 +0200559 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
560
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100561 old = sdata->u.ap.beacon;
562
563 if (!old)
564 return -ENOENT;
565
566 rcu_assign_pointer(sdata->u.ap.beacon, NULL);
567 synchronize_rcu();
568 kfree(old);
569
Johannes Berg2d0ddec2009-04-23 16:13:26 +0200570 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
571 return 0;
Johannes Berg5dfdaf52007-12-19 02:03:33 +0100572}
573
Johannes Berg4fd69312007-12-19 02:03:35 +0100574/* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
575struct iapp_layer2_update {
576 u8 da[ETH_ALEN]; /* broadcast */
577 u8 sa[ETH_ALEN]; /* STA addr */
578 __be16 len; /* 6 */
579 u8 dsap; /* 0 */
580 u8 ssap; /* 0 */
581 u8 control;
582 u8 xid_info[3];
Eric Dumazetbc105022010-06-03 03:21:52 -0700583} __packed;
Johannes Berg4fd69312007-12-19 02:03:35 +0100584
585static void ieee80211_send_layer2_update(struct sta_info *sta)
586{
587 struct iapp_layer2_update *msg;
588 struct sk_buff *skb;
589
590 /* Send Level 2 Update Frame to update forwarding tables in layer 2
591 * bridge devices */
592
593 skb = dev_alloc_skb(sizeof(*msg));
594 if (!skb)
595 return;
596 msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg));
597
598 /* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)
599 * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */
600
601 memset(msg->da, 0xff, ETH_ALEN);
Johannes Berg17741cd2008-09-11 00:02:02 +0200602 memcpy(msg->sa, sta->sta.addr, ETH_ALEN);
Johannes Berg4fd69312007-12-19 02:03:35 +0100603 msg->len = htons(6);
604 msg->dsap = 0;
605 msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */
606 msg->control = 0xaf; /* XID response lsb.1111F101.
607 * F=0 (no poll command; unsolicited frame) */
608 msg->xid_info[0] = 0x81; /* XID format identifier */
609 msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */
610 msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */
611
Johannes Bergd0709a62008-02-25 16:27:46 +0100612 skb->dev = sta->sdata->dev;
613 skb->protocol = eth_type_trans(skb, sta->sdata->dev);
Johannes Berg4fd69312007-12-19 02:03:35 +0100614 memset(skb->cb, 0, sizeof(skb->cb));
John W. Linville06ee1c22010-07-19 11:52:59 -0400615 netif_rx_ni(skb);
Johannes Berg4fd69312007-12-19 02:03:35 +0100616}
617
618static void sta_apply_parameters(struct ieee80211_local *local,
619 struct sta_info *sta,
620 struct station_parameters *params)
621{
Johannes Bergf5521b12010-09-14 22:06:53 +0200622 unsigned long flags;
Johannes Berg4fd69312007-12-19 02:03:35 +0100623 u32 rates;
624 int i, j;
Johannes Berg8318d782008-01-24 19:38:38 +0100625 struct ieee80211_supported_band *sband;
Johannes Bergd0709a62008-02-25 16:27:46 +0100626 struct ieee80211_sub_if_data *sdata = sta->sdata;
Johannes Bergeccb8e82009-05-11 21:57:56 +0300627 u32 mask, set;
Johannes Berg4fd69312007-12-19 02:03:35 +0100628
Johannes Bergae5eb022008-10-14 16:58:37 +0200629 sband = local->hw.wiphy->bands[local->oper_channel->band];
630
Johannes Bergf5521b12010-09-14 22:06:53 +0200631 spin_lock_irqsave(&sta->flaglock, flags);
Johannes Bergeccb8e82009-05-11 21:57:56 +0300632 mask = params->sta_flags_mask;
633 set = params->sta_flags_set;
Johannes Berg73651ee2008-02-25 16:27:47 +0100634
Johannes Bergeccb8e82009-05-11 21:57:56 +0300635 if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
Johannes Berg4fd69312007-12-19 02:03:35 +0100636 sta->flags &= ~WLAN_STA_AUTHORIZED;
Johannes Bergeccb8e82009-05-11 21:57:56 +0300637 if (set & BIT(NL80211_STA_FLAG_AUTHORIZED))
Johannes Berg4fd69312007-12-19 02:03:35 +0100638 sta->flags |= WLAN_STA_AUTHORIZED;
Johannes Berg4fd69312007-12-19 02:03:35 +0100639 }
640
Johannes Bergeccb8e82009-05-11 21:57:56 +0300641 if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
642 sta->flags &= ~WLAN_STA_SHORT_PREAMBLE;
643 if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
644 sta->flags |= WLAN_STA_SHORT_PREAMBLE;
645 }
646
647 if (mask & BIT(NL80211_STA_FLAG_WME)) {
648 sta->flags &= ~WLAN_STA_WME;
649 if (set & BIT(NL80211_STA_FLAG_WME))
650 sta->flags |= WLAN_STA_WME;
651 }
652
653 if (mask & BIT(NL80211_STA_FLAG_MFP)) {
654 sta->flags &= ~WLAN_STA_MFP;
655 if (set & BIT(NL80211_STA_FLAG_MFP))
656 sta->flags |= WLAN_STA_MFP;
657 }
Johannes Bergf5521b12010-09-14 22:06:53 +0200658 spin_unlock_irqrestore(&sta->flaglock, flags);
Johannes Bergeccb8e82009-05-11 21:57:56 +0300659
Johannes Berg73651ee2008-02-25 16:27:47 +0100660 /*
Johannes Berg51b50fb2009-05-24 16:42:30 +0200661 * cfg80211 validates this (1-2007) and allows setting the AID
662 * only when creating a new station entry
663 */
664 if (params->aid)
665 sta->sta.aid = params->aid;
666
667 /*
Johannes Berg73651ee2008-02-25 16:27:47 +0100668 * FIXME: updating the following information is racy when this
669 * function is called from ieee80211_change_station().
670 * However, all this information should be static so
671 * maybe we should just reject attemps to change it.
672 */
673
Johannes Berg4fd69312007-12-19 02:03:35 +0100674 if (params->listen_interval >= 0)
675 sta->listen_interval = params->listen_interval;
676
677 if (params->supported_rates) {
678 rates = 0;
Johannes Berg8318d782008-01-24 19:38:38 +0100679
Johannes Berg4fd69312007-12-19 02:03:35 +0100680 for (i = 0; i < params->supported_rates_len; i++) {
681 int rate = (params->supported_rates[i] & 0x7f) * 5;
Johannes Berg8318d782008-01-24 19:38:38 +0100682 for (j = 0; j < sband->n_bitrates; j++) {
683 if (sband->bitrates[j].bitrate == rate)
Johannes Berg4fd69312007-12-19 02:03:35 +0100684 rates |= BIT(j);
685 }
686 }
Johannes Berg323ce792008-09-11 02:45:11 +0200687 sta->sta.supp_rates[local->oper_channel->band] = rates;
Johannes Berg4fd69312007-12-19 02:03:35 +0100688 }
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100689
Johannes Bergd9fe60d2008-10-09 12:13:49 +0200690 if (params->ht_capa)
Johannes Bergae5eb022008-10-14 16:58:37 +0200691 ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
692 params->ht_capa,
Johannes Bergd9fe60d2008-10-09 12:13:49 +0200693 &sta->sta.ht_cap);
Jouni Malinen36aedc92008-08-25 11:58:58 +0300694
Johannes Berg902acc72008-02-23 15:17:19 +0100695 if (ieee80211_vif_is_mesh(&sdata->vif) && params->plink_action) {
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100696 switch (params->plink_action) {
697 case PLINK_ACTION_OPEN:
698 mesh_plink_open(sta);
699 break;
700 case PLINK_ACTION_BLOCK:
701 mesh_plink_block(sta);
702 break;
703 }
Johannes Berg902acc72008-02-23 15:17:19 +0100704 }
Johannes Berg4fd69312007-12-19 02:03:35 +0100705}
706
707static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
708 u8 *mac, struct station_parameters *params)
709{
Johannes Berg14db74b2008-07-29 13:22:52 +0200710 struct ieee80211_local *local = wiphy_priv(wiphy);
Johannes Berg4fd69312007-12-19 02:03:35 +0100711 struct sta_info *sta;
712 struct ieee80211_sub_if_data *sdata;
Johannes Berg73651ee2008-02-25 16:27:47 +0100713 int err;
Jouni Malinenb8d476c2008-12-12 17:08:31 +0200714 int layer2_update;
Johannes Berg4fd69312007-12-19 02:03:35 +0100715
Johannes Berg4fd69312007-12-19 02:03:35 +0100716 if (params->vlan) {
717 sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
718
Johannes Berg05c914f2008-09-11 00:01:58 +0200719 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
720 sdata->vif.type != NL80211_IFTYPE_AP)
Johannes Berg4fd69312007-12-19 02:03:35 +0100721 return -EINVAL;
722 } else
723 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
724
Johannes Berg47846c92009-11-25 17:46:19 +0100725 if (compare_ether_addr(mac, sdata->vif.addr) == 0)
Johannes Berg03e44972008-02-27 09:56:40 +0100726 return -EINVAL;
727
728 if (is_multicast_ether_addr(mac))
729 return -EINVAL;
730
731 sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
Johannes Berg73651ee2008-02-25 16:27:47 +0100732 if (!sta)
733 return -ENOMEM;
Johannes Berg4fd69312007-12-19 02:03:35 +0100734
735 sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC;
736
737 sta_apply_parameters(local, sta, params);
738
Johannes Berg4b7679a2008-09-18 18:14:18 +0200739 rate_control_rate_init(sta);
Johannes Berg4fd69312007-12-19 02:03:35 +0100740
Jouni Malinenb8d476c2008-12-12 17:08:31 +0200741 layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
742 sdata->vif.type == NL80211_IFTYPE_AP;
743
Johannes Berg34e89502010-02-03 13:59:58 +0100744 err = sta_info_insert_rcu(sta);
Johannes Berg73651ee2008-02-25 16:27:47 +0100745 if (err) {
Johannes Berg73651ee2008-02-25 16:27:47 +0100746 rcu_read_unlock();
747 return err;
748 }
749
Jouni Malinenb8d476c2008-12-12 17:08:31 +0200750 if (layer2_update)
Johannes Berg73651ee2008-02-25 16:27:47 +0100751 ieee80211_send_layer2_update(sta);
752
753 rcu_read_unlock();
754
Johannes Berg4fd69312007-12-19 02:03:35 +0100755 return 0;
756}
757
758static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
759 u8 *mac)
760{
Johannes Berg14db74b2008-07-29 13:22:52 +0200761 struct ieee80211_local *local = wiphy_priv(wiphy);
762 struct ieee80211_sub_if_data *sdata;
Johannes Berg4fd69312007-12-19 02:03:35 +0100763
Johannes Berg14db74b2008-07-29 13:22:52 +0200764 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
765
Johannes Berg34e89502010-02-03 13:59:58 +0100766 if (mac)
767 return sta_info_destroy_addr_bss(sdata, mac);
Johannes Berg98dd6a52008-04-10 15:36:09 +0200768
Johannes Berg34e89502010-02-03 13:59:58 +0100769 sta_info_flush(local, sdata);
Johannes Berg4fd69312007-12-19 02:03:35 +0100770 return 0;
771}
772
773static int ieee80211_change_station(struct wiphy *wiphy,
774 struct net_device *dev,
775 u8 *mac,
776 struct station_parameters *params)
777{
Johannes Bergabe60632009-11-25 17:46:18 +0100778 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Berg14db74b2008-07-29 13:22:52 +0200779 struct ieee80211_local *local = wiphy_priv(wiphy);
Johannes Berg4fd69312007-12-19 02:03:35 +0100780 struct sta_info *sta;
781 struct ieee80211_sub_if_data *vlansdata;
782
Johannes Berg98dd6a52008-04-10 15:36:09 +0200783 rcu_read_lock();
784
Felix Fietkau0e5ded52010-01-08 18:10:58 +0100785 sta = sta_info_get_bss(sdata, mac);
Johannes Berg98dd6a52008-04-10 15:36:09 +0200786 if (!sta) {
787 rcu_read_unlock();
Johannes Berg4fd69312007-12-19 02:03:35 +0100788 return -ENOENT;
Johannes Berg98dd6a52008-04-10 15:36:09 +0200789 }
Johannes Berg4fd69312007-12-19 02:03:35 +0100790
Johannes Bergd0709a62008-02-25 16:27:46 +0100791 if (params->vlan && params->vlan != sta->sdata->dev) {
Johannes Berg4fd69312007-12-19 02:03:35 +0100792 vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
793
Johannes Berg05c914f2008-09-11 00:01:58 +0200794 if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
795 vlansdata->vif.type != NL80211_IFTYPE_AP) {
Johannes Berg98dd6a52008-04-10 15:36:09 +0200796 rcu_read_unlock();
Johannes Berg4fd69312007-12-19 02:03:35 +0100797 return -EINVAL;
Johannes Berg98dd6a52008-04-10 15:36:09 +0200798 }
Johannes Berg4fd69312007-12-19 02:03:35 +0100799
Johannes Berg9bc383d2009-11-19 11:55:19 +0100800 if (params->vlan->ieee80211_ptr->use_4addr) {
Johannes Berg33054432009-11-20 10:09:14 +0100801 if (vlansdata->u.vlan.sta) {
802 rcu_read_unlock();
Felix Fietkauf14543e2009-11-10 20:10:05 +0100803 return -EBUSY;
Johannes Berg33054432009-11-20 10:09:14 +0100804 }
Felix Fietkauf14543e2009-11-10 20:10:05 +0100805
806 rcu_assign_pointer(vlansdata->u.vlan.sta, sta);
807 }
808
Johannes Berg14db74b2008-07-29 13:22:52 +0200809 sta->sdata = vlansdata;
Johannes Berg4fd69312007-12-19 02:03:35 +0100810 ieee80211_send_layer2_update(sta);
811 }
812
813 sta_apply_parameters(local, sta, params);
814
Johannes Berg98dd6a52008-04-10 15:36:09 +0200815 rcu_read_unlock();
816
Johannes Berg4fd69312007-12-19 02:03:35 +0100817 return 0;
818}
819
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100820#ifdef CONFIG_MAC80211_MESH
821static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
822 u8 *dst, u8 *next_hop)
823{
Johannes Berg14db74b2008-07-29 13:22:52 +0200824 struct ieee80211_sub_if_data *sdata;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100825 struct mesh_path *mpath;
826 struct sta_info *sta;
827 int err;
828
Johannes Berg14db74b2008-07-29 13:22:52 +0200829 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
830
Johannes Bergd0709a62008-02-25 16:27:46 +0100831 rcu_read_lock();
Johannes Bergabe60632009-11-25 17:46:18 +0100832 sta = sta_info_get(sdata, next_hop);
Johannes Bergd0709a62008-02-25 16:27:46 +0100833 if (!sta) {
834 rcu_read_unlock();
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100835 return -ENOENT;
Johannes Bergd0709a62008-02-25 16:27:46 +0100836 }
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100837
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200838 err = mesh_path_add(dst, sdata);
Johannes Bergd0709a62008-02-25 16:27:46 +0100839 if (err) {
840 rcu_read_unlock();
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100841 return err;
Johannes Bergd0709a62008-02-25 16:27:46 +0100842 }
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100843
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200844 mpath = mesh_path_lookup(dst, sdata);
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100845 if (!mpath) {
846 rcu_read_unlock();
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100847 return -ENXIO;
848 }
849 mesh_path_fix_nexthop(mpath, sta);
Johannes Bergd0709a62008-02-25 16:27:46 +0100850
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100851 rcu_read_unlock();
852 return 0;
853}
854
855static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
856 u8 *dst)
857{
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200858 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100859
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200860 if (dst)
861 return mesh_path_del(dst, sdata);
862
863 mesh_path_flush(sdata);
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100864 return 0;
865}
866
867static int ieee80211_change_mpath(struct wiphy *wiphy,
868 struct net_device *dev,
869 u8 *dst, u8 *next_hop)
870{
Johannes Berg14db74b2008-07-29 13:22:52 +0200871 struct ieee80211_sub_if_data *sdata;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100872 struct mesh_path *mpath;
873 struct sta_info *sta;
874
Johannes Berg14db74b2008-07-29 13:22:52 +0200875 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
876
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100877 rcu_read_lock();
Johannes Bergd0709a62008-02-25 16:27:46 +0100878
Johannes Bergabe60632009-11-25 17:46:18 +0100879 sta = sta_info_get(sdata, next_hop);
Johannes Bergd0709a62008-02-25 16:27:46 +0100880 if (!sta) {
881 rcu_read_unlock();
882 return -ENOENT;
883 }
884
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200885 mpath = mesh_path_lookup(dst, sdata);
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100886 if (!mpath) {
887 rcu_read_unlock();
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100888 return -ENOENT;
889 }
890
891 mesh_path_fix_nexthop(mpath, sta);
Johannes Bergd0709a62008-02-25 16:27:46 +0100892
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100893 rcu_read_unlock();
894 return 0;
895}
896
897static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
898 struct mpath_info *pinfo)
899{
900 if (mpath->next_hop)
Johannes Berg17741cd2008-09-11 00:02:02 +0200901 memcpy(next_hop, mpath->next_hop->sta.addr, ETH_ALEN);
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100902 else
903 memset(next_hop, 0, ETH_ALEN);
904
Johannes Bergf5ea9122009-08-07 16:17:38 +0200905 pinfo->generation = mesh_paths_generation;
906
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100907 pinfo->filled = MPATH_INFO_FRAME_QLEN |
Rui Paulod19b3bf2009-11-09 23:46:55 +0000908 MPATH_INFO_SN |
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100909 MPATH_INFO_METRIC |
910 MPATH_INFO_EXPTIME |
911 MPATH_INFO_DISCOVERY_TIMEOUT |
912 MPATH_INFO_DISCOVERY_RETRIES |
913 MPATH_INFO_FLAGS;
914
915 pinfo->frame_qlen = mpath->frame_queue.qlen;
Rui Paulod19b3bf2009-11-09 23:46:55 +0000916 pinfo->sn = mpath->sn;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100917 pinfo->metric = mpath->metric;
918 if (time_before(jiffies, mpath->exp_time))
919 pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);
920 pinfo->discovery_timeout =
921 jiffies_to_msecs(mpath->discovery_timeout);
922 pinfo->discovery_retries = mpath->discovery_retries;
923 pinfo->flags = 0;
924 if (mpath->flags & MESH_PATH_ACTIVE)
925 pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE;
926 if (mpath->flags & MESH_PATH_RESOLVING)
927 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
Rui Paulod19b3bf2009-11-09 23:46:55 +0000928 if (mpath->flags & MESH_PATH_SN_VALID)
929 pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100930 if (mpath->flags & MESH_PATH_FIXED)
931 pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
932 if (mpath->flags & MESH_PATH_RESOLVING)
933 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
934
935 pinfo->flags = mpath->flags;
936}
937
938static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
939 u8 *dst, u8 *next_hop, struct mpath_info *pinfo)
940
941{
Johannes Berg14db74b2008-07-29 13:22:52 +0200942 struct ieee80211_sub_if_data *sdata;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100943 struct mesh_path *mpath;
944
Johannes Berg14db74b2008-07-29 13:22:52 +0200945 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
946
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100947 rcu_read_lock();
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200948 mpath = mesh_path_lookup(dst, sdata);
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100949 if (!mpath) {
950 rcu_read_unlock();
951 return -ENOENT;
952 }
953 memcpy(dst, mpath->dst, ETH_ALEN);
954 mpath_set_pinfo(mpath, next_hop, pinfo);
955 rcu_read_unlock();
956 return 0;
957}
958
959static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
960 int idx, u8 *dst, u8 *next_hop,
961 struct mpath_info *pinfo)
962{
Johannes Berg14db74b2008-07-29 13:22:52 +0200963 struct ieee80211_sub_if_data *sdata;
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100964 struct mesh_path *mpath;
965
Johannes Berg14db74b2008-07-29 13:22:52 +0200966 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
967
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100968 rcu_read_lock();
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200969 mpath = mesh_path_lookup_by_idx(idx, sdata);
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +0100970 if (!mpath) {
971 rcu_read_unlock();
972 return -ENOENT;
973 }
974 memcpy(dst, mpath->dst, ETH_ALEN);
975 mpath_set_pinfo(mpath, next_hop, pinfo);
976 rcu_read_unlock();
977 return 0;
978}
colin@cozybit.com93da9cc2008-10-21 12:03:48 -0700979
980static int ieee80211_get_mesh_params(struct wiphy *wiphy,
981 struct net_device *dev,
982 struct mesh_config *conf)
983{
984 struct ieee80211_sub_if_data *sdata;
985 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
986
colin@cozybit.com93da9cc2008-10-21 12:03:48 -0700987 memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config));
988 return 0;
989}
990
991static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
992{
993 return (mask >> (parm-1)) & 0x1;
994}
995
996static int ieee80211_set_mesh_params(struct wiphy *wiphy,
997 struct net_device *dev,
998 const struct mesh_config *nconf, u32 mask)
999{
1000 struct mesh_config *conf;
1001 struct ieee80211_sub_if_data *sdata;
Rui Paulo63c57232009-11-09 23:46:57 +00001002 struct ieee80211_if_mesh *ifmsh;
1003
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07001004 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Rui Paulo63c57232009-11-09 23:46:57 +00001005 ifmsh = &sdata->u.mesh;
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07001006
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07001007 /* Set the config options which we are interested in setting */
1008 conf = &(sdata->u.mesh.mshcfg);
1009 if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask))
1010 conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout;
1011 if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask))
1012 conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout;
1013 if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask))
1014 conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout;
1015 if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask))
1016 conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks;
1017 if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask))
1018 conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;
1019 if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))
1020 conf->dot11MeshTTL = nconf->dot11MeshTTL;
1021 if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask))
1022 conf->auto_open_plinks = nconf->auto_open_plinks;
1023 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))
1024 conf->dot11MeshHWMPmaxPREQretries =
1025 nconf->dot11MeshHWMPmaxPREQretries;
1026 if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask))
1027 conf->path_refresh_time = nconf->path_refresh_time;
1028 if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask))
1029 conf->min_discovery_timeout = nconf->min_discovery_timeout;
1030 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask))
1031 conf->dot11MeshHWMPactivePathTimeout =
1032 nconf->dot11MeshHWMPactivePathTimeout;
1033 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))
1034 conf->dot11MeshHWMPpreqMinInterval =
1035 nconf->dot11MeshHWMPpreqMinInterval;
1036 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
1037 mask))
1038 conf->dot11MeshHWMPnetDiameterTraversalTime =
1039 nconf->dot11MeshHWMPnetDiameterTraversalTime;
Rui Paulo63c57232009-11-09 23:46:57 +00001040 if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) {
1041 conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode;
1042 ieee80211_mesh_root_setup(ifmsh);
1043 }
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07001044 return 0;
1045}
1046
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +01001047#endif
1048
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001049static int ieee80211_change_bss(struct wiphy *wiphy,
1050 struct net_device *dev,
1051 struct bss_parameters *params)
1052{
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001053 struct ieee80211_sub_if_data *sdata;
1054 u32 changed = 0;
1055
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001056 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1057
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001058 if (params->use_cts_prot >= 0) {
Johannes Bergbda39332008-10-11 01:51:51 +02001059 sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001060 changed |= BSS_CHANGED_ERP_CTS_PROT;
1061 }
1062 if (params->use_short_preamble >= 0) {
Johannes Bergbda39332008-10-11 01:51:51 +02001063 sdata->vif.bss_conf.use_short_preamble =
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001064 params->use_short_preamble;
1065 changed |= BSS_CHANGED_ERP_PREAMBLE;
1066 }
Felix Fietkau43d35342010-01-15 03:00:48 +01001067
1068 if (!sdata->vif.bss_conf.use_short_slot &&
1069 sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ) {
1070 sdata->vif.bss_conf.use_short_slot = true;
1071 changed |= BSS_CHANGED_ERP_SLOT;
1072 }
1073
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001074 if (params->use_short_slot_time >= 0) {
Johannes Bergbda39332008-10-11 01:51:51 +02001075 sdata->vif.bss_conf.use_short_slot =
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001076 params->use_short_slot_time;
1077 changed |= BSS_CHANGED_ERP_SLOT;
1078 }
1079
Jouni Malinen90c97a02008-10-30 16:59:22 +02001080 if (params->basic_rates) {
1081 int i, j;
1082 u32 rates = 0;
1083 struct ieee80211_local *local = wiphy_priv(wiphy);
1084 struct ieee80211_supported_band *sband =
1085 wiphy->bands[local->oper_channel->band];
1086
1087 for (i = 0; i < params->basic_rates_len; i++) {
1088 int rate = (params->basic_rates[i] & 0x7f) * 5;
1089 for (j = 0; j < sband->n_bitrates; j++) {
1090 if (sband->bitrates[j].bitrate == rate)
1091 rates |= BIT(j);
1092 }
1093 }
1094 sdata->vif.bss_conf.basic_rates = rates;
1095 changed |= BSS_CHANGED_BASIC_RATES;
1096 }
1097
Felix Fietkau7b7b5e52010-04-27 01:23:36 +02001098 if (params->ap_isolate >= 0) {
1099 if (params->ap_isolate)
1100 sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
1101 else
1102 sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
1103 }
1104
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001105 ieee80211_bss_info_change_notify(sdata, changed);
1106
1107 return 0;
1108}
1109
Jouni Malinen31888482008-10-30 16:59:24 +02001110static int ieee80211_set_txq_params(struct wiphy *wiphy,
1111 struct ieee80211_txq_params *params)
1112{
1113 struct ieee80211_local *local = wiphy_priv(wiphy);
1114 struct ieee80211_tx_queue_params p;
1115
1116 if (!local->ops->conf_tx)
1117 return -EOPNOTSUPP;
1118
1119 memset(&p, 0, sizeof(p));
1120 p.aifs = params->aifs;
1121 p.cw_max = params->cwmax;
1122 p.cw_min = params->cwmin;
1123 p.txop = params->txop;
Kalle Valoab133152010-01-12 10:42:31 +02001124
1125 /*
1126 * Setting tx queue params disables u-apsd because it's only
1127 * called in master mode.
1128 */
1129 p.uapsd = false;
1130
Johannes Berg24487982009-04-23 18:52:52 +02001131 if (drv_conf_tx(local, params->queue, &p)) {
Joe Perches0fb9a9e2010-08-20 16:25:38 -07001132 wiphy_debug(local->hw.wiphy,
1133 "failed to set TX queue parameters for queue %d\n",
1134 params->queue);
Jouni Malinen31888482008-10-30 16:59:24 +02001135 return -EINVAL;
1136 }
1137
1138 return 0;
1139}
1140
Jouni Malinen72bdcf32008-11-26 16:15:24 +02001141static int ieee80211_set_channel(struct wiphy *wiphy,
Johannes Bergf444de02010-05-05 15:25:02 +02001142 struct net_device *netdev,
Jouni Malinen72bdcf32008-11-26 16:15:24 +02001143 struct ieee80211_channel *chan,
Sujith094d05d2008-12-12 11:57:43 +05301144 enum nl80211_channel_type channel_type)
Jouni Malinen72bdcf32008-11-26 16:15:24 +02001145{
1146 struct ieee80211_local *local = wiphy_priv(wiphy);
Johannes Berg0aaffa92010-05-05 15:28:27 +02001147 struct ieee80211_sub_if_data *sdata = NULL;
1148
1149 if (netdev)
1150 sdata = IEEE80211_DEV_TO_SUB_IF(netdev);
Jouni Malinen72bdcf32008-11-26 16:15:24 +02001151
Johannes Bergf444de02010-05-05 15:25:02 +02001152 switch (ieee80211_get_channel_mode(local, NULL)) {
1153 case CHAN_MODE_HOPPING:
1154 return -EBUSY;
1155 case CHAN_MODE_FIXED:
Johannes Berg0aaffa92010-05-05 15:28:27 +02001156 if (local->oper_channel != chan)
1157 return -EBUSY;
1158 if (!sdata && local->_oper_channel_type == channel_type)
Johannes Bergf444de02010-05-05 15:25:02 +02001159 return 0;
Johannes Berg0aaffa92010-05-05 15:28:27 +02001160 break;
Johannes Bergf444de02010-05-05 15:25:02 +02001161 case CHAN_MODE_UNDEFINED:
1162 break;
1163 }
Jouni Malinen72bdcf32008-11-26 16:15:24 +02001164
1165 local->oper_channel = chan;
Jouni Malinen72bdcf32008-11-26 16:15:24 +02001166
Johannes Berg0aaffa92010-05-05 15:28:27 +02001167 if (!ieee80211_set_channel_type(local, sdata, channel_type))
1168 return -EBUSY;
1169
1170 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
1171 if (sdata && sdata->vif.type != NL80211_IFTYPE_MONITOR)
1172 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT);
1173
1174 return 0;
Jouni Malinen72bdcf32008-11-26 16:15:24 +02001175}
1176
Bob Copeland665af4f2009-01-19 11:20:53 -05001177#ifdef CONFIG_PM
1178static int ieee80211_suspend(struct wiphy *wiphy)
1179{
1180 return __ieee80211_suspend(wiphy_priv(wiphy));
1181}
1182
1183static int ieee80211_resume(struct wiphy *wiphy)
1184{
1185 return __ieee80211_resume(wiphy_priv(wiphy));
1186}
1187#else
1188#define ieee80211_suspend NULL
1189#define ieee80211_resume NULL
1190#endif
1191
Johannes Berg2a519312009-02-10 21:25:55 +01001192static int ieee80211_scan(struct wiphy *wiphy,
1193 struct net_device *dev,
1194 struct cfg80211_scan_request *req)
1195{
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001196 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
Johannes Berg2a519312009-02-10 21:25:55 +01001197
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001198 switch (ieee80211_vif_type_p2p(&sdata->vif)) {
1199 case NL80211_IFTYPE_STATION:
1200 case NL80211_IFTYPE_ADHOC:
1201 case NL80211_IFTYPE_MESH_POINT:
1202 case NL80211_IFTYPE_P2P_CLIENT:
1203 break;
1204 case NL80211_IFTYPE_P2P_GO:
1205 if (sdata->local->ops->hw_scan)
1206 break;
1207 /* FIXME: implement NoA while scanning in software */
Johannes Berg2a519312009-02-10 21:25:55 +01001208 return -EOPNOTSUPP;
Johannes Berg2ca27bc2010-09-16 14:58:23 +02001209 case NL80211_IFTYPE_AP:
1210 if (sdata->u.ap.beacon)
1211 return -EOPNOTSUPP;
1212 break;
1213 default:
1214 return -EOPNOTSUPP;
1215 }
Johannes Berg2a519312009-02-10 21:25:55 +01001216
1217 return ieee80211_request_scan(sdata, req);
1218}
1219
Jouni Malinen636a5d32009-03-19 13:39:22 +02001220static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
1221 struct cfg80211_auth_request *req)
1222{
Johannes Berg77fdaa12009-07-07 03:45:17 +02001223 return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req);
Jouni Malinen636a5d32009-03-19 13:39:22 +02001224}
1225
1226static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
1227 struct cfg80211_assoc_request *req)
1228{
Johannes Bergf444de02010-05-05 15:25:02 +02001229 struct ieee80211_local *local = wiphy_priv(wiphy);
1230 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1231
1232 switch (ieee80211_get_channel_mode(local, sdata)) {
1233 case CHAN_MODE_HOPPING:
1234 return -EBUSY;
1235 case CHAN_MODE_FIXED:
1236 if (local->oper_channel == req->bss->channel)
1237 break;
1238 return -EBUSY;
1239 case CHAN_MODE_UNDEFINED:
1240 break;
1241 }
1242
Johannes Berg77fdaa12009-07-07 03:45:17 +02001243 return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
Jouni Malinen636a5d32009-03-19 13:39:22 +02001244}
1245
1246static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
Johannes Berg667503d2009-07-07 03:56:11 +02001247 struct cfg80211_deauth_request *req,
1248 void *cookie)
Jouni Malinen636a5d32009-03-19 13:39:22 +02001249{
Johannes Berg667503d2009-07-07 03:56:11 +02001250 return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev),
1251 req, cookie);
Jouni Malinen636a5d32009-03-19 13:39:22 +02001252}
1253
1254static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
Johannes Berg667503d2009-07-07 03:56:11 +02001255 struct cfg80211_disassoc_request *req,
1256 void *cookie)
Jouni Malinen636a5d32009-03-19 13:39:22 +02001257{
Johannes Berg667503d2009-07-07 03:56:11 +02001258 return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev),
1259 req, cookie);
Jouni Malinen636a5d32009-03-19 13:39:22 +02001260}
1261
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001262static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
1263 struct cfg80211_ibss_params *params)
1264{
Johannes Bergf444de02010-05-05 15:25:02 +02001265 struct ieee80211_local *local = wiphy_priv(wiphy);
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001266 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1267
Johannes Bergf444de02010-05-05 15:25:02 +02001268 switch (ieee80211_get_channel_mode(local, sdata)) {
1269 case CHAN_MODE_HOPPING:
1270 return -EBUSY;
1271 case CHAN_MODE_FIXED:
1272 if (!params->channel_fixed)
1273 return -EBUSY;
1274 if (local->oper_channel == params->channel)
1275 break;
1276 return -EBUSY;
1277 case CHAN_MODE_UNDEFINED:
1278 break;
1279 }
1280
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001281 return ieee80211_ibss_join(sdata, params);
1282}
1283
1284static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1285{
1286 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1287
1288 return ieee80211_ibss_leave(sdata);
1289}
1290
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +02001291static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1292{
1293 struct ieee80211_local *local = wiphy_priv(wiphy);
Johannes Berg24487982009-04-23 18:52:52 +02001294 int err;
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +02001295
Lukáš Turek310bc672009-12-21 22:50:48 +01001296 if (changed & WIPHY_PARAM_COVERAGE_CLASS) {
1297 err = drv_set_coverage_class(local, wiphy->coverage_class);
1298
1299 if (err)
1300 return err;
1301 }
1302
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +02001303 if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
Johannes Berg24487982009-04-23 18:52:52 +02001304 err = drv_set_rts_threshold(local, wiphy->rts_threshold);
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +02001305
Johannes Berg24487982009-04-23 18:52:52 +02001306 if (err)
1307 return err;
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +02001308 }
1309
1310 if (changed & WIPHY_PARAM_RETRY_SHORT)
1311 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
1312 if (changed & WIPHY_PARAM_RETRY_LONG)
1313 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
1314 if (changed &
1315 (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
1316 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);
1317
1318 return 0;
1319}
1320
Johannes Berg7643a2c2009-06-02 13:01:39 +02001321static int ieee80211_set_tx_power(struct wiphy *wiphy,
Juuso Oikarinenfa61cf72010-06-23 12:12:37 +03001322 enum nl80211_tx_power_setting type, int mbm)
Johannes Berg7643a2c2009-06-02 13:01:39 +02001323{
1324 struct ieee80211_local *local = wiphy_priv(wiphy);
1325 struct ieee80211_channel *chan = local->hw.conf.channel;
1326 u32 changes = 0;
Johannes Berg7643a2c2009-06-02 13:01:39 +02001327
1328 switch (type) {
Juuso Oikarinenfa61cf72010-06-23 12:12:37 +03001329 case NL80211_TX_POWER_AUTOMATIC:
Johannes Berg7643a2c2009-06-02 13:01:39 +02001330 local->user_power_level = -1;
1331 break;
Juuso Oikarinenfa61cf72010-06-23 12:12:37 +03001332 case NL80211_TX_POWER_LIMITED:
1333 if (mbm < 0 || (mbm % 100))
1334 return -EOPNOTSUPP;
1335 local->user_power_level = MBM_TO_DBM(mbm);
Johannes Berg7643a2c2009-06-02 13:01:39 +02001336 break;
Juuso Oikarinenfa61cf72010-06-23 12:12:37 +03001337 case NL80211_TX_POWER_FIXED:
1338 if (mbm < 0 || (mbm % 100))
1339 return -EOPNOTSUPP;
Johannes Berg7643a2c2009-06-02 13:01:39 +02001340 /* TODO: move to cfg80211 when it knows the channel */
Juuso Oikarinenfa61cf72010-06-23 12:12:37 +03001341 if (MBM_TO_DBM(mbm) > chan->max_power)
Johannes Berg7643a2c2009-06-02 13:01:39 +02001342 return -EINVAL;
Juuso Oikarinenfa61cf72010-06-23 12:12:37 +03001343 local->user_power_level = MBM_TO_DBM(mbm);
Johannes Berg7643a2c2009-06-02 13:01:39 +02001344 break;
Johannes Berg7643a2c2009-06-02 13:01:39 +02001345 }
1346
1347 ieee80211_hw_config(local, changes);
1348
1349 return 0;
1350}
1351
1352static int ieee80211_get_tx_power(struct wiphy *wiphy, int *dbm)
1353{
1354 struct ieee80211_local *local = wiphy_priv(wiphy);
1355
1356 *dbm = local->hw.conf.power_level;
1357
Johannes Berg7643a2c2009-06-02 13:01:39 +02001358 return 0;
1359}
1360
Johannes Bergab737a42009-07-01 21:26:58 +02001361static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev,
1362 u8 *addr)
1363{
1364 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1365
1366 memcpy(&sdata->u.wds.remote_addr, addr, ETH_ALEN);
1367
1368 return 0;
1369}
1370
Johannes Berg1f87f7d2009-06-02 13:01:41 +02001371static void ieee80211_rfkill_poll(struct wiphy *wiphy)
1372{
1373 struct ieee80211_local *local = wiphy_priv(wiphy);
1374
1375 drv_rfkill_poll(local);
1376}
1377
Johannes Bergaff89a92009-07-01 21:26:51 +02001378#ifdef CONFIG_NL80211_TESTMODE
Johannes Berg99783e22009-07-07 03:54:43 +02001379static int ieee80211_testmode_cmd(struct wiphy *wiphy, void *data, int len)
Johannes Bergaff89a92009-07-01 21:26:51 +02001380{
1381 struct ieee80211_local *local = wiphy_priv(wiphy);
1382
1383 if (!local->ops->testmode_cmd)
1384 return -EOPNOTSUPP;
1385
1386 return local->ops->testmode_cmd(&local->hw, data, len);
1387}
1388#endif
1389
Johannes Berg0f782312009-12-01 13:37:02 +01001390int __ieee80211_request_smps(struct ieee80211_sub_if_data *sdata,
1391 enum ieee80211_smps_mode smps_mode)
1392{
1393 const u8 *ap;
1394 enum ieee80211_smps_mode old_req;
1395 int err;
1396
1397 old_req = sdata->u.mgd.req_smps;
1398 sdata->u.mgd.req_smps = smps_mode;
1399
1400 if (old_req == smps_mode &&
1401 smps_mode != IEEE80211_SMPS_AUTOMATIC)
1402 return 0;
1403
1404 /*
1405 * If not associated, or current association is not an HT
1406 * association, there's no need to send an action frame.
1407 */
1408 if (!sdata->u.mgd.associated ||
Johannes Berg0aaffa92010-05-05 15:28:27 +02001409 sdata->vif.bss_conf.channel_type == NL80211_CHAN_NO_HT) {
Johannes Berg0f782312009-12-01 13:37:02 +01001410 mutex_lock(&sdata->local->iflist_mtx);
Johannes Berg025e6be2010-10-05 10:41:47 +02001411 ieee80211_recalc_smps(sdata->local);
Johannes Berg0f782312009-12-01 13:37:02 +01001412 mutex_unlock(&sdata->local->iflist_mtx);
1413 return 0;
1414 }
1415
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001416 ap = sdata->u.mgd.associated->bssid;
Johannes Berg0f782312009-12-01 13:37:02 +01001417
1418 if (smps_mode == IEEE80211_SMPS_AUTOMATIC) {
1419 if (sdata->u.mgd.powersave)
1420 smps_mode = IEEE80211_SMPS_DYNAMIC;
1421 else
1422 smps_mode = IEEE80211_SMPS_OFF;
1423 }
1424
1425 /* send SM PS frame to AP */
1426 err = ieee80211_send_smps_action(sdata, smps_mode,
1427 ap, ap);
1428 if (err)
1429 sdata->u.mgd.req_smps = old_req;
1430
1431 return err;
1432}
1433
Johannes Bergbc92afd2009-07-01 21:26:57 +02001434static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1435 bool enabled, int timeout)
1436{
1437 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1438 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
Johannes Bergbc92afd2009-07-01 21:26:57 +02001439
Benoit Papillaulte5de30c2010-01-15 12:21:37 +01001440 if (sdata->vif.type != NL80211_IFTYPE_STATION)
1441 return -EOPNOTSUPP;
1442
Johannes Bergbc92afd2009-07-01 21:26:57 +02001443 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
1444 return -EOPNOTSUPP;
1445
1446 if (enabled == sdata->u.mgd.powersave &&
Juuso Oikarinenff616382010-06-09 09:51:52 +03001447 timeout == local->dynamic_ps_forced_timeout)
Johannes Bergbc92afd2009-07-01 21:26:57 +02001448 return 0;
1449
1450 sdata->u.mgd.powersave = enabled;
Juuso Oikarinenff616382010-06-09 09:51:52 +03001451 local->dynamic_ps_forced_timeout = timeout;
Johannes Bergbc92afd2009-07-01 21:26:57 +02001452
Johannes Berg0f782312009-12-01 13:37:02 +01001453 /* no change, but if automatic follow powersave */
1454 mutex_lock(&sdata->u.mgd.mtx);
1455 __ieee80211_request_smps(sdata, sdata->u.mgd.req_smps);
1456 mutex_unlock(&sdata->u.mgd.mtx);
1457
Johannes Bergbc92afd2009-07-01 21:26:57 +02001458 if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)
1459 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
1460
1461 ieee80211_recalc_ps(local, -1);
1462
1463 return 0;
1464}
1465
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02001466static int ieee80211_set_cqm_rssi_config(struct wiphy *wiphy,
1467 struct net_device *dev,
1468 s32 rssi_thold, u32 rssi_hyst)
1469{
1470 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1471 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1472 struct ieee80211_vif *vif = &sdata->vif;
1473 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1474
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02001475 if (rssi_thold == bss_conf->cqm_rssi_thold &&
1476 rssi_hyst == bss_conf->cqm_rssi_hyst)
1477 return 0;
1478
1479 bss_conf->cqm_rssi_thold = rssi_thold;
1480 bss_conf->cqm_rssi_hyst = rssi_hyst;
1481
Jouni Malinen17e4ec12010-03-29 23:28:30 -07001482 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_CQM_RSSI)) {
1483 if (sdata->vif.type != NL80211_IFTYPE_STATION)
1484 return -EOPNOTSUPP;
1485 return 0;
1486 }
1487
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02001488 /* tell the driver upon association, unless already associated */
1489 if (sdata->u.mgd.associated)
1490 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);
1491
1492 return 0;
1493}
1494
Johannes Berg99303802009-07-01 21:26:59 +02001495static int ieee80211_set_bitrate_mask(struct wiphy *wiphy,
1496 struct net_device *dev,
1497 const u8 *addr,
1498 const struct cfg80211_bitrate_mask *mask)
1499{
1500 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1501 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
Johannes Berg2c7e6bc2009-12-04 09:26:38 +01001502 int i;
Johannes Berg99303802009-07-01 21:26:59 +02001503
Johannes Berg2c7e6bc2009-12-04 09:26:38 +01001504 /*
1505 * This _could_ be supported by providing a hook for
1506 * drivers for this function, but at this point it
1507 * doesn't seem worth bothering.
1508 */
1509 if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL)
1510 return -EOPNOTSUPP;
1511
Johannes Berg99303802009-07-01 21:26:59 +02001512
Jouni Malinen37eb0b12010-01-06 13:09:08 +02001513 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
1514 sdata->rc_rateidx_mask[i] = mask->control[i].legacy;
Johannes Berg99303802009-07-01 21:26:59 +02001515
Jouni Malinen37eb0b12010-01-06 13:09:08 +02001516 return 0;
Johannes Berg99303802009-07-01 21:26:59 +02001517}
1518
Johannes Bergb8bc4b02009-12-23 13:15:42 +01001519static int ieee80211_remain_on_channel(struct wiphy *wiphy,
1520 struct net_device *dev,
1521 struct ieee80211_channel *chan,
1522 enum nl80211_channel_type channel_type,
1523 unsigned int duration,
1524 u64 *cookie)
1525{
1526 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1527
1528 return ieee80211_wk_remain_on_channel(sdata, chan, channel_type,
1529 duration, cookie);
1530}
1531
1532static int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
1533 struct net_device *dev,
1534 u64 cookie)
1535{
1536 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1537
1538 return ieee80211_wk_cancel_remain_on_channel(sdata, cookie);
1539}
1540
Johannes Berg2e161f72010-08-12 15:38:38 +02001541static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct net_device *dev,
1542 struct ieee80211_channel *chan,
1543 enum nl80211_channel_type channel_type,
1544 bool channel_type_valid,
1545 const u8 *buf, size_t len, u64 *cookie)
Jouni Malinen026331c2010-02-15 12:53:10 +02001546{
Johannes Berg9d38d852010-06-09 17:20:33 +02001547 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1548 struct ieee80211_local *local = sdata->local;
1549 struct sk_buff *skb;
1550 struct sta_info *sta;
1551 const struct ieee80211_mgmt *mgmt = (void *)buf;
1552 u32 flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
1553 IEEE80211_TX_CTL_REQ_TX_STATUS;
1554
1555 /* Check that we are on the requested channel for transmission */
1556 if (chan != local->tmp_channel &&
1557 chan != local->oper_channel)
1558 return -EBUSY;
1559 if (channel_type_valid &&
1560 (channel_type != local->tmp_channel_type &&
1561 channel_type != local->_oper_channel_type))
1562 return -EBUSY;
1563
1564 switch (sdata->vif.type) {
1565 case NL80211_IFTYPE_ADHOC:
Johannes Berg663fcaf2010-09-30 21:06:09 +02001566 case NL80211_IFTYPE_AP:
1567 case NL80211_IFTYPE_AP_VLAN:
1568 case NL80211_IFTYPE_P2P_GO:
1569 if (!ieee80211_is_action(mgmt->frame_control) ||
1570 mgmt->u.action.category == WLAN_CATEGORY_PUBLIC)
Johannes Berg9d38d852010-06-09 17:20:33 +02001571 break;
1572 rcu_read_lock();
1573 sta = sta_info_get(sdata, mgmt->da);
1574 rcu_read_unlock();
1575 if (!sta)
1576 return -ENOLINK;
1577 break;
1578 case NL80211_IFTYPE_STATION:
Johannes Berg663fcaf2010-09-30 21:06:09 +02001579 case NL80211_IFTYPE_P2P_CLIENT:
Johannes Berg9d38d852010-06-09 17:20:33 +02001580 break;
1581 default:
1582 return -EOPNOTSUPP;
1583 }
1584
1585 skb = dev_alloc_skb(local->hw.extra_tx_headroom + len);
1586 if (!skb)
1587 return -ENOMEM;
1588 skb_reserve(skb, local->hw.extra_tx_headroom);
1589
1590 memcpy(skb_put(skb, len), buf, len);
1591
1592 IEEE80211_SKB_CB(skb)->flags = flags;
1593
1594 skb->dev = sdata->dev;
1595 ieee80211_tx_skb(sdata, skb);
1596
1597 *cookie = (unsigned long) skb;
1598 return 0;
Jouni Malinen026331c2010-02-15 12:53:10 +02001599}
1600
Jiri Bencf0706e822007-05-05 11:45:53 -07001601struct cfg80211_ops mac80211_config_ops = {
1602 .add_virtual_intf = ieee80211_add_iface,
1603 .del_virtual_intf = ieee80211_del_iface,
Johannes Berg42613db2007-09-28 21:52:27 +02001604 .change_virtual_intf = ieee80211_change_iface,
Johannes Berge8cbb4c2007-12-19 02:03:30 +01001605 .add_key = ieee80211_add_key,
1606 .del_key = ieee80211_del_key,
Johannes Berg62da92f2007-12-19 02:03:31 +01001607 .get_key = ieee80211_get_key,
Johannes Berge8cbb4c2007-12-19 02:03:30 +01001608 .set_default_key = ieee80211_config_default_key,
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +02001609 .set_default_mgmt_key = ieee80211_config_default_mgmt_key,
Johannes Berg5dfdaf52007-12-19 02:03:33 +01001610 .add_beacon = ieee80211_add_beacon,
1611 .set_beacon = ieee80211_set_beacon,
1612 .del_beacon = ieee80211_del_beacon,
Johannes Berg4fd69312007-12-19 02:03:35 +01001613 .add_station = ieee80211_add_station,
1614 .del_station = ieee80211_del_station,
1615 .change_station = ieee80211_change_station,
Johannes Berg7bbdd2d2007-12-19 02:03:37 +01001616 .get_station = ieee80211_get_station,
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +01001617 .dump_station = ieee80211_dump_station,
Holger Schurig12897232010-04-19 10:23:57 +02001618 .dump_survey = ieee80211_dump_survey,
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +01001619#ifdef CONFIG_MAC80211_MESH
1620 .add_mpath = ieee80211_add_mpath,
1621 .del_mpath = ieee80211_del_mpath,
1622 .change_mpath = ieee80211_change_mpath,
1623 .get_mpath = ieee80211_get_mpath,
1624 .dump_mpath = ieee80211_dump_mpath,
colin@cozybit.com93da9cc2008-10-21 12:03:48 -07001625 .set_mesh_params = ieee80211_set_mesh_params,
1626 .get_mesh_params = ieee80211_get_mesh_params,
Luis Carlos Coboc5dd9c22008-02-23 15:17:17 +01001627#endif
Jouni Malinen9f1ba902008-08-07 20:07:01 +03001628 .change_bss = ieee80211_change_bss,
Jouni Malinen31888482008-10-30 16:59:24 +02001629 .set_txq_params = ieee80211_set_txq_params,
Jouni Malinen72bdcf32008-11-26 16:15:24 +02001630 .set_channel = ieee80211_set_channel,
Bob Copeland665af4f2009-01-19 11:20:53 -05001631 .suspend = ieee80211_suspend,
1632 .resume = ieee80211_resume,
Johannes Berg2a519312009-02-10 21:25:55 +01001633 .scan = ieee80211_scan,
Jouni Malinen636a5d32009-03-19 13:39:22 +02001634 .auth = ieee80211_auth,
1635 .assoc = ieee80211_assoc,
1636 .deauth = ieee80211_deauth,
1637 .disassoc = ieee80211_disassoc,
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001638 .join_ibss = ieee80211_join_ibss,
1639 .leave_ibss = ieee80211_leave_ibss,
Jouni Malinenb9a5f8ca2009-04-20 18:39:05 +02001640 .set_wiphy_params = ieee80211_set_wiphy_params,
Johannes Berg7643a2c2009-06-02 13:01:39 +02001641 .set_tx_power = ieee80211_set_tx_power,
1642 .get_tx_power = ieee80211_get_tx_power,
Johannes Bergab737a42009-07-01 21:26:58 +02001643 .set_wds_peer = ieee80211_set_wds_peer,
Johannes Berg1f87f7d2009-06-02 13:01:41 +02001644 .rfkill_poll = ieee80211_rfkill_poll,
Johannes Bergaff89a92009-07-01 21:26:51 +02001645 CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd)
Johannes Bergbc92afd2009-07-01 21:26:57 +02001646 .set_power_mgmt = ieee80211_set_power_mgmt,
Johannes Berg99303802009-07-01 21:26:59 +02001647 .set_bitrate_mask = ieee80211_set_bitrate_mask,
Johannes Bergb8bc4b02009-12-23 13:15:42 +01001648 .remain_on_channel = ieee80211_remain_on_channel,
1649 .cancel_remain_on_channel = ieee80211_cancel_remain_on_channel,
Johannes Berg2e161f72010-08-12 15:38:38 +02001650 .mgmt_tx = ieee80211_mgmt_tx,
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02001651 .set_cqm_rssi_config = ieee80211_set_cqm_rssi_config,
Jiri Bencf0706e822007-05-05 11:45:53 -07001652};