projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mwifiex: add P2P interface
[deliverable/linux.git] / drivers / net / wireless / mwifiex / cfg80211.c
CommitLineData
5e6e3a92
BZ		 1/*
2 * Marvell Wireless LAN device driver: CFG80211
3 *
4 * Copyright (C) 2011, Marvell International Ltd.
5 *
6 * This software file (the "File") is distributed by Marvell International
7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8 * (the "License"). You may use, redistribute and/or modify this File in
9 * accordance with the terms and conditions of the License, a copy of which
10 * is available by writing to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
13 *
14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17 * this warranty disclaimer.
18 */
19
20#include "cfg80211.h"
21#include "main.h"
22
cd8440da
AP		 23static const struct ieee80211_iface_limit mwifiex_ap_sta_limits[] = {
24 {
197f4a2e 25 .max = 2, .types = BIT(NL80211_IFTYPE_STATION),
cd8440da
AP		 26 },
27 {
28 .max = 1, .types = BIT(NL80211_IFTYPE_AP),
29 },
30};
31
32static const struct ieee80211_iface_combination mwifiex_iface_comb_ap_sta = {
33 .limits = mwifiex_ap_sta_limits,
34 .num_different_channels = 1,
35 .n_limits = ARRAY_SIZE(mwifiex_ap_sta_limits),
36 .max_interfaces = MWIFIEX_MAX_BSS_NUM,
37 .beacon_int_infra_match = true,
38};
39
cc0ba0d5
AK		 40static const struct ieee80211_regdomain mwifiex_world_regdom_custom = {
41 .n_reg_rules = 7,
42 .alpha2 = "99",
43 .reg_rules = {
44 /* Channel 1 - 11 */
45 REG_RULE(2412-10, 2462+10, 40, 3, 20, 0),
46 /* Channel 12 - 13 */
47 REG_RULE(2467-10, 2472+10, 20, 3, 20,
48 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
49 /* Channel 14 */
50 REG_RULE(2484-10, 2484+10, 20, 3, 20,
51 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS |
52 NL80211_RRF_NO_OFDM),
53 /* Channel 36 - 48 */
54 REG_RULE(5180-10, 5240+10, 40, 3, 20,
55 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
56 /* Channel 149 - 165 */
57 REG_RULE(5745-10, 5825+10, 40, 3, 20,
58 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
59 /* Channel 52 - 64 */
60 REG_RULE(5260-10, 5320+10, 40, 3, 30,
61 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS |
62 NL80211_RRF_DFS),
63 /* Channel 100 - 140 */
64 REG_RULE(5500-10, 5700+10, 40, 3, 30,
65 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS |
66 NL80211_RRF_DFS),
67 }
68};
69
5e6e3a92
BZ		 70/*
71 * This function maps the nl802.11 channel type into driver channel type.
72 *
73 * The mapping is as follows -
21c3ba34
AK		 74 * NL80211_CHAN_NO_HT -> IEEE80211_HT_PARAM_CHA_SEC_NONE
75 * NL80211_CHAN_HT20 -> IEEE80211_HT_PARAM_CHA_SEC_NONE
76 * NL80211_CHAN_HT40PLUS -> IEEE80211_HT_PARAM_CHA_SEC_ABOVE
77 * NL80211_CHAN_HT40MINUS -> IEEE80211_HT_PARAM_CHA_SEC_BELOW
78 * Others -> IEEE80211_HT_PARAM_CHA_SEC_NONE
5e6e3a92 79 */
7feb4c48 80u8 mwifiex_chan_type_to_sec_chan_offset(enum nl80211_channel_type chan_type)
5e6e3a92 81{
05910f4a 82 switch (chan_type) {
5e6e3a92
BZ		 83 case NL80211_CHAN_NO_HT:
84 case NL80211_CHAN_HT20:
21c3ba34 85 return IEEE80211_HT_PARAM_CHA_SEC_NONE;
5e6e3a92 86 case NL80211_CHAN_HT40PLUS:
21c3ba34 87 return IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
5e6e3a92 88 case NL80211_CHAN_HT40MINUS:
21c3ba34 89 return IEEE80211_HT_PARAM_CHA_SEC_BELOW;
5e6e3a92 90 default:
21c3ba34 91 return IEEE80211_HT_PARAM_CHA_SEC_NONE;
5e6e3a92 92 }
5e6e3a92
BZ		 93}
94
5e6e3a92
BZ		 95/*
96 * This function checks whether WEP is set.
97 */
98static int
99mwifiex_is_alg_wep(u32 cipher)
100{
5e6e3a92 101 switch (cipher) {
2be50b8d
YAP		 102 case WLAN_CIPHER_SUITE_WEP40:
103 case WLAN_CIPHER_SUITE_WEP104:
270e58e8 104 return 1;
5e6e3a92 105 default:
5e6e3a92
BZ		 106 break;
107 }
270e58e8
YAP		 108
109 return 0;
5e6e3a92
BZ		 110}
111
5e6e3a92
BZ		 112/*
113 * This function retrieves the private structure from kernel wiphy structure.
114 */
67fdf39e 115static void *mwifiex_cfg80211_get_adapter(struct wiphy *wiphy)
5e6e3a92
BZ		 116{
117 return (void *) (*(unsigned long *) wiphy_priv(wiphy));
118}
119
120/*
121 * CFG802.11 operation handler to delete a network key.
122 */
123static int
124mwifiex_cfg80211_del_key(struct wiphy *wiphy, struct net_device *netdev,
125 u8 key_index, bool pairwise, const u8 *mac_addr)
126{
f540f9f3 127 struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
75edd2c6
AP		 128 const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
129 const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
5e6e3a92 130
53b11231 131 if (mwifiex_set_encode(priv, NULL, NULL, 0, key_index, peer_mac, 1)) {
5e6e3a92
BZ		 132 wiphy_err(wiphy, "deleting the crypto keys\n");
133 return -EFAULT;
134 }
135
136 wiphy_dbg(wiphy, "info: crypto keys deleted\n");
137 return 0;
138}
139
e39faa73
SP		 140/*
141 * This function forms an skb for management frame.
142 */
143static int
144mwifiex_form_mgmt_frame(struct sk_buff *skb, const u8 *buf, size_t len)
145{
146 u8 addr[ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
147 u16 pkt_len;
148 u32 tx_control = 0, pkt_type = PKT_TYPE_MGMT;
149 struct timeval tv;
150
151 pkt_len = len + ETH_ALEN;
152
153 skb_reserve(skb, MWIFIEX_MIN_DATA_HEADER_LEN +
154 MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(pkt_len));
155 memcpy(skb_push(skb, sizeof(pkt_len)), &pkt_len, sizeof(pkt_len));
156
157 memcpy(skb_push(skb, sizeof(tx_control)),
158 &tx_control, sizeof(tx_control));
159
160 memcpy(skb_push(skb, sizeof(pkt_type)), &pkt_type, sizeof(pkt_type));
161
162 /* Add packet data and address4 */
163 memcpy(skb_put(skb, sizeof(struct ieee80211_hdr_3addr)), buf,
164 sizeof(struct ieee80211_hdr_3addr));
165 memcpy(skb_put(skb, ETH_ALEN), addr, ETH_ALEN);
166 memcpy(skb_put(skb, len - sizeof(struct ieee80211_hdr_3addr)),
167 buf + sizeof(struct ieee80211_hdr_3addr),
168 len - sizeof(struct ieee80211_hdr_3addr));
169
170 skb->priority = LOW_PRIO_TID;
171 do_gettimeofday(&tv);
172 skb->tstamp = timeval_to_ktime(tv);
173
174 return 0;
175}
176
177/*
178 * CFG802.11 operation handler to transmit a management frame.
179 */
180static int
181mwifiex_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
182 struct ieee80211_channel *chan, bool offchan,
183 enum nl80211_channel_type channel_type,
184 bool channel_type_valid, unsigned int wait,
185 const u8 *buf, size_t len, bool no_cck,
186 bool dont_wait_for_ack, u64 *cookie)
187{
188 struct sk_buff *skb;
189 u16 pkt_len;
190 const struct ieee80211_mgmt *mgmt;
191 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
192
193 if (!buf || !len) {
194 wiphy_err(wiphy, "invalid buffer and length\n");
195 return -EFAULT;
196 }
197
198 mgmt = (const struct ieee80211_mgmt *)buf;
199 if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_STA &&
200 ieee80211_is_probe_resp(mgmt->frame_control)) {
201 /* Since we support offload probe resp, we need to skip probe
202 * resp in AP or GO mode */
203 wiphy_dbg(wiphy,
204 "info: skip to send probe resp in AP or GO mode\n");
205 return 0;
206 }
207
208 pkt_len = len + ETH_ALEN;
209 skb = dev_alloc_skb(MWIFIEX_MIN_DATA_HEADER_LEN +
210 MWIFIEX_MGMT_FRAME_HEADER_SIZE +
211 pkt_len + sizeof(pkt_len));
212
213 if (!skb) {
214 wiphy_err(wiphy, "allocate skb failed for management frame\n");
215 return -ENOMEM;
216 }
217
218 mwifiex_form_mgmt_frame(skb, buf, len);
219 mwifiex_queue_tx_pkt(priv, skb);
220
221 *cookie = random32() | 1;
222 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true, GFP_ATOMIC);
223
224 wiphy_dbg(wiphy, "info: management frame transmitted\n");
225 return 0;
226}
227
3cec6870
SP		 228/*
229 * CFG802.11 operation handler to register a mgmt frame.
230 */
231static void
232mwifiex_cfg80211_mgmt_frame_register(struct wiphy *wiphy,
233 struct wireless_dev *wdev,
234 u16 frame_type, bool reg)
235{
236 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
237
238 if (reg)
239 priv->mgmt_frame_mask |= BIT(frame_type >> 4);
240 else
241 priv->mgmt_frame_mask &= ~BIT(frame_type >> 4);
242
243 mwifiex_send_cmd_async(priv, HostCmd_CMD_MGMT_FRAME_REG,
244 HostCmd_ACT_GEN_SET, 0, &priv->mgmt_frame_mask);
245
246 wiphy_dbg(wiphy, "info: mgmt frame registered\n");
247}
248
7feb4c48
SP		 249/*
250 * CFG802.11 operation handler to remain on channel.
251 */
252static int
253mwifiex_cfg80211_remain_on_channel(struct wiphy *wiphy,
254 struct wireless_dev *wdev,
255 struct ieee80211_channel *chan,
256 enum nl80211_channel_type channel_type,
257 unsigned int duration, u64 *cookie)
258{
259 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
260 int ret;
261
262 if (!chan || !cookie) {
263 wiphy_err(wiphy, "Invalid parameter for ROC\n");
264 return -EINVAL;
265 }
266
267 if (priv->roc_cfg.cookie) {
268 wiphy_dbg(wiphy, "info: ongoing ROC, cookie = 0x%llu\n",
269 priv->roc_cfg.cookie);
270 return -EBUSY;
271 }
272
273 ret = mwifiex_remain_on_chan_cfg(priv, HostCmd_ACT_GEN_SET, chan,
274 &channel_type, duration);
275
276 if (!ret) {
277 *cookie = random32() | 1;
278 priv->roc_cfg.cookie = *cookie;
279 priv->roc_cfg.chan = *chan;
280 priv->roc_cfg.chan_type = channel_type;
281
282 cfg80211_ready_on_channel(wdev, *cookie, chan, channel_type,
283 duration, GFP_ATOMIC);
284
285 wiphy_dbg(wiphy, "info: ROC, cookie = 0x%llx\n", *cookie);
286 }
287
288 return ret;
289}
290
291/*
292 * CFG802.11 operation handler to cancel remain on channel.
293 */
294static int
295mwifiex_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
296 struct wireless_dev *wdev, u64 cookie)
297{
298 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
299 int ret;
300
301 if (cookie != priv->roc_cfg.cookie)
302 return -ENOENT;
303
304 ret = mwifiex_remain_on_chan_cfg(priv, HostCmd_ACT_GEN_REMOVE,
305 &priv->roc_cfg.chan,
306 &priv->roc_cfg.chan_type, 0);
307
308 if (!ret) {
309 cfg80211_remain_on_channel_expired(wdev, cookie,
310 &priv->roc_cfg.chan,
311 priv->roc_cfg.chan_type,
312 GFP_ATOMIC);
313
314 memset(&priv->roc_cfg, 0, sizeof(struct mwifiex_roc_cfg));
315
316 wiphy_dbg(wiphy, "info: cancel ROC, cookie = 0x%llx\n", cookie);
317 }
318
319 return ret;
320}
321
5e6e3a92
BZ		 322/*
323 * CFG802.11 operation handler to set Tx power.
324 */
325static int
326mwifiex_cfg80211_set_tx_power(struct wiphy *wiphy,
327 enum nl80211_tx_power_setting type,
742c29fd 328 int mbm)
5e6e3a92 329{
67fdf39e
AP		 330 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
331 struct mwifiex_private *priv;
600f5d90 332 struct mwifiex_power_cfg power_cfg;
742c29fd 333 int dbm = MBM_TO_DBM(mbm);
5e6e3a92 334
600f5d90
AK		 335 if (type == NL80211_TX_POWER_FIXED) {
336 power_cfg.is_power_auto = 0;
337 power_cfg.power_level = dbm;
338 } else {
339 power_cfg.is_power_auto = 1;
340 }
341
67fdf39e
AP		 342 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
343
636c4598 344 return mwifiex_set_tx_power(priv, &power_cfg);
5e6e3a92
BZ		 345}
346
347/*
348 * CFG802.11 operation handler to set Power Save option.
349 *
350 * The timeout value, if provided, is currently ignored.
351 */
352static int
353mwifiex_cfg80211_set_power_mgmt(struct wiphy *wiphy,
354 struct net_device *dev,
355 bool enabled, int timeout)
356{
f540f9f3 357 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
600f5d90 358 u32 ps_mode;
5e6e3a92
BZ		 359
360 if (timeout)
361 wiphy_dbg(wiphy,
aea0701e 362 "info: ignore timeout value for IEEE Power Save\n");
5e6e3a92 363
600f5d90 364 ps_mode = enabled;
5e6e3a92 365
636c4598 366 return mwifiex_drv_set_power(priv, &ps_mode);
5e6e3a92
BZ		 367}
368
369/*
370 * CFG802.11 operation handler to set the default network key.
371 */
372static int
373mwifiex_cfg80211_set_default_key(struct wiphy *wiphy, struct net_device *netdev,
374 u8 key_index, bool unicast,
375 bool multicast)
376{
f540f9f3 377 struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
5e6e3a92 378
2d3d0a88 379 /* Return if WEP key not configured */
5eb02e44 380 if (!priv->sec_info.wep_enabled)
2d3d0a88
AK		 381 return 0;
382
96893538
AP		 383 if (priv->bss_type == MWIFIEX_BSS_TYPE_UAP) {
384 priv->wep_key_curr_index = key_index;
53b11231
YL		 385 } else if (mwifiex_set_encode(priv, NULL, NULL, 0, key_index,
386 NULL, 0)) {
636c4598 387 wiphy_err(wiphy, "set default Tx key index\n");
5e6e3a92 388 return -EFAULT;
636c4598 389 }
5e6e3a92
BZ		 390
391 return 0;
392}
393
394/*
395 * CFG802.11 operation handler to add a network key.
396 */
397static int
398mwifiex_cfg80211_add_key(struct wiphy *wiphy, struct net_device *netdev,
399 u8 key_index, bool pairwise, const u8 *mac_addr,
400 struct key_params *params)
401{
f540f9f3 402 struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
96893538 403 struct mwifiex_wep_key *wep_key;
75edd2c6
AP		 404 const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
405 const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
5e6e3a92 406
96893538
AP		 407 if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP &&
408 (params->cipher == WLAN_CIPHER_SUITE_WEP40 ||
409 params->cipher == WLAN_CIPHER_SUITE_WEP104)) {
410 if (params->key && params->key_len) {
411 wep_key = &priv->wep_key[key_index];
412 memset(wep_key, 0, sizeof(struct mwifiex_wep_key));
413 memcpy(wep_key->key_material, params->key,
414 params->key_len);
415 wep_key->key_index = key_index;
416 wep_key->key_length = params->key_len;
417 priv->sec_info.wep_enabled = 1;
418 }
419 return 0;
420 }
421
53b11231 422 if (mwifiex_set_encode(priv, params, params->key, params->key_len,
75edd2c6 423 key_index, peer_mac, 0)) {
636c4598 424 wiphy_err(wiphy, "crypto keys added\n");
5e6e3a92 425 return -EFAULT;
636c4598 426 }
5e6e3a92
BZ		 427
428 return 0;
429}
430
431/*
432 * This function sends domain information to the firmware.
433 *
434 * The following information are passed to the firmware -
435 * - Country codes
436 * - Sub bands (first channel, number of channels, maximum Tx power)
437 */
438static int mwifiex_send_domain_info_cmd_fw(struct wiphy *wiphy)
439{
440 u8 no_of_triplet = 0;
441 struct ieee80211_country_ie_triplet *t;
442 u8 no_of_parsed_chan = 0;
443 u8 first_chan = 0, next_chan = 0, max_pwr = 0;
444 u8 i, flag = 0;
445 enum ieee80211_band band;
446 struct ieee80211_supported_band *sband;
447 struct ieee80211_channel *ch;
67fdf39e
AP		 448 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
449 struct mwifiex_private *priv;
5e6e3a92 450 struct mwifiex_802_11d_domain_reg *domain_info = &adapter->domain_reg;
5e6e3a92
BZ		 451
452 /* Set country code */
67fdf39e
AP		 453 domain_info->country_code[0] = adapter->country_code[0];
454 domain_info->country_code[1] = adapter->country_code[1];
5e6e3a92
BZ		 455 domain_info->country_code[2] = ' ';
456
457 band = mwifiex_band_to_radio_type(adapter->config_bands);
458 if (!wiphy->bands[band]) {
459 wiphy_err(wiphy, "11D: setting domain info in FW\n");
460 return -1;
461 }
462
463 sband = wiphy->bands[band];
464
465 for (i = 0; i < sband->n_channels ; i++) {
466 ch = &sband->channels[i];
467 if (ch->flags & IEEE80211_CHAN_DISABLED)
468 continue;
469
470 if (!flag) {
471 flag = 1;
472 first_chan = (u32) ch->hw_value;
473 next_chan = first_chan;
34202e28 474 max_pwr = ch->max_reg_power;
5e6e3a92
BZ		 475 no_of_parsed_chan = 1;
476 continue;
477 }
478
479 if (ch->hw_value == next_chan + 1 &&
34202e28 480 ch->max_reg_power == max_pwr) {
5e6e3a92
BZ		 481 next_chan++;
482 no_of_parsed_chan++;
483 } else {
484 t = &domain_info->triplet[no_of_triplet];
485 t->chans.first_channel = first_chan;
486 t->chans.num_channels = no_of_parsed_chan;
487 t->chans.max_power = max_pwr;
488 no_of_triplet++;
489 first_chan = (u32) ch->hw_value;
490 next_chan = first_chan;
34202e28 491 max_pwr = ch->max_reg_power;
5e6e3a92
BZ		 492 no_of_parsed_chan = 1;
493 }
494 }
495
496 if (flag) {
497 t = &domain_info->triplet[no_of_triplet];
498 t->chans.first_channel = first_chan;
499 t->chans.num_channels = no_of_parsed_chan;
500 t->chans.max_power = max_pwr;
501 no_of_triplet++;
502 }
503
504 domain_info->no_of_triplet = no_of_triplet;
636c4598 505
67fdf39e
AP		 506 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
507
636c4598 508 if (mwifiex_send_cmd_async(priv, HostCmd_CMD_802_11D_DOMAIN_INFO,
aea0701e 509 HostCmd_ACT_GEN_SET, 0, NULL)) {
5e6e3a92 510 wiphy_err(wiphy, "11D: setting domain info in FW\n");
636c4598
YAP		 511 return -1;
512 }
5e6e3a92 513
636c4598 514 return 0;
5e6e3a92
BZ		 515}
516
517/*
518 * CFG802.11 regulatory domain callback function.
519 *
520 * This function is called when the regulatory domain is changed due to the
521 * following reasons -
522 * - Set by driver
523 * - Set by system core
524 * - Set by user
525 * - Set bt Country IE
526 */
527static int mwifiex_reg_notifier(struct wiphy *wiphy,
aea0701e 528 struct regulatory_request *request)
5e6e3a92 529{
67fdf39e 530 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
5e6e3a92 531
67fdf39e
AP		 532 wiphy_dbg(wiphy, "info: cfg80211 regulatory domain callback for %c%c\n",
533 request->alpha2[0], request->alpha2[1]);
5e6e3a92 534
67fdf39e 535 memcpy(adapter->country_code, request->alpha2, sizeof(request->alpha2));
5e6e3a92
BZ		 536
537 switch (request->initiator) {
538 case NL80211_REGDOM_SET_BY_DRIVER:
539 case NL80211_REGDOM_SET_BY_CORE:
540 case NL80211_REGDOM_SET_BY_USER:
541 break;
542 /* Todo: apply driver specific changes in channel flags based
543 on the request initiator if necessary. */
544 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
545 break;
546 }
547 mwifiex_send_domain_info_cmd_fw(wiphy);
548
549 return 0;
550}
551
5e6e3a92
BZ		 552/*
553 * This function sets the fragmentation threshold.
554 *
600f5d90 555 * The fragmentation threshold value must lie between MWIFIEX_FRAG_MIN_VALUE
5e6e3a92
BZ		 556 * and MWIFIEX_FRAG_MAX_VALUE.
557 */
558static int
559mwifiex_set_frag(struct mwifiex_private *priv, u32 frag_thr)
560{
aea0701e
YAP		 561 if (frag_thr < MWIFIEX_FRAG_MIN_VALUE ||
562 frag_thr > MWIFIEX_FRAG_MAX_VALUE)
9b930eae 563 frag_thr = MWIFIEX_FRAG_MAX_VALUE;
5e6e3a92 564
9b930eae
AP		 565 return mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,
566 HostCmd_ACT_GEN_SET, FRAG_THRESH_I,
567 &frag_thr);
5e6e3a92
BZ		 568}
569
570/*
571 * This function sets the RTS threshold.
600f5d90
AK		 572
573 * The rts value must lie between MWIFIEX_RTS_MIN_VALUE
574 * and MWIFIEX_RTS_MAX_VALUE.
5e6e3a92
BZ		 575 */
576static int
577mwifiex_set_rts(struct mwifiex_private *priv, u32 rts_thr)
578{
5e6e3a92
BZ		 579 if (rts_thr < MWIFIEX_RTS_MIN_VALUE || rts_thr > MWIFIEX_RTS_MAX_VALUE)
580 rts_thr = MWIFIEX_RTS_MAX_VALUE;
581
636c4598 582 return mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,
600f5d90
AK		 583 HostCmd_ACT_GEN_SET, RTS_THRESH_I,
584 &rts_thr);
5e6e3a92
BZ		 585}
586
587/*
588 * CFG802.11 operation handler to set wiphy parameters.
589 *
590 * This function can be used to set the RTS threshold and the
591 * Fragmentation threshold of the driver.
592 */
593static int
594mwifiex_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
595{
67fdf39e 596 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
9b930eae
AP		 597 struct mwifiex_private *priv;
598 struct mwifiex_uap_bss_param *bss_cfg;
599 int ret, bss_started, i;
600
601 for (i = 0; i < adapter->priv_num; i++) {
602 priv = adapter->priv[i];
603
604 switch (priv->bss_role) {
605 case MWIFIEX_BSS_ROLE_UAP:
606 bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param),
607 GFP_KERNEL);
608 if (!bss_cfg)
609 return -ENOMEM;
610
611 mwifiex_set_sys_config_invalid_data(bss_cfg);
612
613 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
614 bss_cfg->rts_threshold = wiphy->rts_threshold;
615 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
616 bss_cfg->frag_threshold = wiphy->frag_threshold;
617 if (changed & WIPHY_PARAM_RETRY_LONG)
618 bss_cfg->retry_limit = wiphy->retry_long;
619
620 bss_started = priv->bss_started;
621
622 ret = mwifiex_send_cmd_sync(priv,
623 HostCmd_CMD_UAP_BSS_STOP,
624 HostCmd_ACT_GEN_SET, 0,
625 NULL);
626 if (ret) {
627 wiphy_err(wiphy, "Failed to stop the BSS\n");
628 kfree(bss_cfg);
629 return ret;
630 }
631
632 ret = mwifiex_send_cmd_async(priv,
633 HostCmd_CMD_UAP_SYS_CONFIG,
634 HostCmd_ACT_GEN_SET,
e76268da 635 UAP_BSS_PARAMS_I, bss_cfg);
5e6e3a92 636
9b930eae
AP		 637 kfree(bss_cfg);
638
639 if (ret) {
640 wiphy_err(wiphy, "Failed to set bss config\n");
641 return ret;
642 }
5e6e3a92 643
9b930eae
AP		 644 if (!bss_started)
645 break;
646
647 ret = mwifiex_send_cmd_async(priv,
648 HostCmd_CMD_UAP_BSS_START,
649 HostCmd_ACT_GEN_SET, 0,
650 NULL);
651 if (ret) {
652 wiphy_err(wiphy, "Failed to start BSS\n");
653 return ret;
654 }
655
656 break;
657 case MWIFIEX_BSS_ROLE_STA:
658 if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
659 ret = mwifiex_set_rts(priv,
660 wiphy->rts_threshold);
661 if (ret)
662 return ret;
663 }
664 if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
665 ret = mwifiex_set_frag(priv,
666 wiphy->frag_threshold);
667 if (ret)
668 return ret;
669 }
670 break;
671 }
672 }
673
674 return 0;
5e6e3a92
BZ		 675}
676
677/*
678 * CFG802.11 operation handler to change interface type.
5e6e3a92
BZ		 679 */
680static int
681mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
682 struct net_device *dev,
683 enum nl80211_iftype type, u32 *flags,
684 struct vif_params *params)
685{
270e58e8 686 int ret;
5e6e3a92 687 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
5e6e3a92 688
4f02341a 689 switch (dev->ieee80211_ptr->iftype) {
5e6e3a92 690 case NL80211_IFTYPE_ADHOC:
4f02341a
AP		 691 switch (type) {
692 case NL80211_IFTYPE_STATION:
693 break;
694 case NL80211_IFTYPE_UNSPECIFIED:
695 wiphy_warn(wiphy, "%s: kept type as IBSS\n", dev->name);
696 case NL80211_IFTYPE_ADHOC: /* This shouldn't happen */
697 return 0;
698 case NL80211_IFTYPE_AP:
699 default:
700 wiphy_err(wiphy, "%s: changing to %d not supported\n",
701 dev->name, type);
702 return -EOPNOTSUPP;
703 }
5e6e3a92
BZ		 704 break;
705 case NL80211_IFTYPE_STATION:
4f02341a
AP		 706 switch (type) {
707 case NL80211_IFTYPE_ADHOC:
708 break;
709 case NL80211_IFTYPE_UNSPECIFIED:
710 wiphy_warn(wiphy, "%s: kept type as STA\n", dev->name);
711 case NL80211_IFTYPE_STATION: /* This shouldn't happen */
712 return 0;
713 case NL80211_IFTYPE_AP:
714 default:
715 wiphy_err(wiphy, "%s: changing to %d not supported\n",
716 dev->name, type);
717 return -EOPNOTSUPP;
718 }
719 break;
720 case NL80211_IFTYPE_AP:
721 switch (type) {
722 case NL80211_IFTYPE_UNSPECIFIED:
723 wiphy_warn(wiphy, "%s: kept type as AP\n", dev->name);
724 case NL80211_IFTYPE_AP: /* This shouldn't happen */
725 return 0;
726 case NL80211_IFTYPE_ADHOC:
727 case NL80211_IFTYPE_STATION:
728 default:
729 wiphy_err(wiphy, "%s: changing to %d not supported\n",
730 dev->name, type);
731 return -EOPNOTSUPP;
732 }
5e6e3a92 733 break;
5e6e3a92 734 default:
4f02341a
AP		 735 wiphy_err(wiphy, "%s: unknown iftype: %d\n",
736 dev->name, dev->ieee80211_ptr->iftype);
737 return -EOPNOTSUPP;
5e6e3a92 738 }
5e6e3a92 739
4f02341a
AP		 740 dev->ieee80211_ptr->iftype = type;
741 priv->bss_mode = type;
600f5d90 742 mwifiex_deauthenticate(priv, NULL);
eecd8250 743
f986b6d5 744 priv->sec_info.authentication_mode = NL80211_AUTHTYPE_OPEN_SYSTEM;
eecd8250 745
600f5d90
AK		 746 ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_SET_BSS_MODE,
747 HostCmd_ACT_GEN_SET, 0, NULL);
eecd8250 748
5e6e3a92
BZ		 749 return ret;
750}
751
752/*
753 * This function dumps the station information on a buffer.
754 *
755 * The following information are shown -
756 * - Total bytes transmitted
757 * - Total bytes received
758 * - Total packets transmitted
759 * - Total packets received
760 * - Signal quality level
761 * - Transmission rate
762 */
763static int
764mwifiex_dump_station_info(struct mwifiex_private *priv,
765 struct station_info *sinfo)
766{
006606c0 767 u32 rate;
5e6e3a92
BZ		 768
769 sinfo->filled = STATION_INFO_RX_BYTES | STATION_INFO_TX_BYTES |
7013d3e2
AK		 770 STATION_INFO_RX_PACKETS | STATION_INFO_TX_PACKETS |
771 STATION_INFO_TX_BITRATE |
772 STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
5e6e3a92
BZ		 773
774 /* Get signal information from the firmware */
958a4a86
AK		 775 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_RSSI_INFO,
776 HostCmd_ACT_GEN_GET, 0, NULL)) {
777 dev_err(priv->adapter->dev, "failed to get signal information\n");
778 return -EFAULT;
5e6e3a92
BZ		 779 }
780
781 if (mwifiex_drv_get_data_rate(priv, &rate)) {
782 dev_err(priv->adapter->dev, "getting data rate\n");
958a4a86 783 return -EFAULT;
5e6e3a92
BZ		 784 }
785
caf60a6c
AK		 786 /* Get DTIM period information from firmware */
787 mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,
788 HostCmd_ACT_GEN_GET, DTIM_PERIOD_I,
789 &priv->dtim_period);
790
4ec6f9c0
AK		 791 /*
792 * Bit 0 in tx_htinfo indicates that current Tx rate is 11n rate. Valid
fe020120 793 * MCS index values for us are 0 to 15.
4ec6f9c0 794 */
fe020120 795 if ((priv->tx_htinfo & BIT(0)) && (priv->tx_rate < 16)) {
4ec6f9c0
AK		 796 sinfo->txrate.mcs = priv->tx_rate;
797 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
798 /* 40MHz rate */
799 if (priv->tx_htinfo & BIT(1))
800 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
801 /* SGI enabled */
802 if (priv->tx_htinfo & BIT(2))
803 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
804 }
805
7013d3e2 806 sinfo->signal_avg = priv->bcn_rssi_avg;
5e6e3a92
BZ		 807 sinfo->rx_bytes = priv->stats.rx_bytes;
808 sinfo->tx_bytes = priv->stats.tx_bytes;
809 sinfo->rx_packets = priv->stats.rx_packets;
810 sinfo->tx_packets = priv->stats.tx_packets;
958a4a86 811 sinfo->signal = priv->bcn_rssi_avg;
4ec6f9c0 812 /* bit rate is in 500 kb/s units. Convert it to 100kb/s units */
006606c0 813 sinfo->txrate.legacy = rate * 5;
5e6e3a92 814
c4f3b972
AK		 815 if (priv->bss_mode == NL80211_IFTYPE_STATION) {
816 sinfo->filled |= STATION_INFO_BSS_PARAM;
817 sinfo->bss_param.flags = 0;
818 if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
819 WLAN_CAPABILITY_SHORT_PREAMBLE)
820 sinfo->bss_param.flags |=
821 BSS_PARAM_FLAGS_SHORT_PREAMBLE;
822 if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
823 WLAN_CAPABILITY_SHORT_SLOT_TIME)
824 sinfo->bss_param.flags |=
825 BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
caf60a6c 826 sinfo->bss_param.dtim_period = priv->dtim_period;
c4f3b972
AK		 827 sinfo->bss_param.beacon_interval =
828 priv->curr_bss_params.bss_descriptor.beacon_period;
829 }
830
958a4a86 831 return 0;
5e6e3a92
BZ		 832}
833
834/*
835 * CFG802.11 operation handler to get station information.
836 *
837 * This function only works in connected mode, and dumps the
838 * requested station information, if available.
839 */
840static int
841mwifiex_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
842 u8 *mac, struct station_info *sinfo)
843{
844 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
5e6e3a92 845
5e6e3a92
BZ		 846 if (!priv->media_connected)
847 return -ENOENT;
848 if (memcmp(mac, priv->cfg_bssid, ETH_ALEN))
849 return -ENOENT;
850
636c4598 851 return mwifiex_dump_station_info(priv, sinfo);
5e6e3a92
BZ		 852}
853
f85aae6b
AK		 854/*
855 * CFG802.11 operation handler to dump station information.
856 */
857static int
858mwifiex_cfg80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
859 int idx, u8 *mac, struct station_info *sinfo)
860{
861 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
862
863 if (!priv->media_connected || idx)
864 return -ENOENT;
865
866 memcpy(mac, priv->cfg_bssid, ETH_ALEN);
867
868 return mwifiex_dump_station_info(priv, sinfo);
869}
870
5e6e3a92 871/* Supported rates to be advertised to the cfg80211 */
5e6e3a92
BZ		 872static struct ieee80211_rate mwifiex_rates[] = {
873 {.bitrate = 10, .hw_value = 2, },
874 {.bitrate = 20, .hw_value = 4, },
875 {.bitrate = 55, .hw_value = 11, },
876 {.bitrate = 110, .hw_value = 22, },
5e6e3a92
BZ		 877 {.bitrate = 60, .hw_value = 12, },
878 {.bitrate = 90, .hw_value = 18, },
879 {.bitrate = 120, .hw_value = 24, },
880 {.bitrate = 180, .hw_value = 36, },
881 {.bitrate = 240, .hw_value = 48, },
882 {.bitrate = 360, .hw_value = 72, },
883 {.bitrate = 480, .hw_value = 96, },
884 {.bitrate = 540, .hw_value = 108, },
5e6e3a92
BZ		 885};
886
887/* Channel definitions to be advertised to cfg80211 */
5e6e3a92
BZ		 888static struct ieee80211_channel mwifiex_channels_2ghz[] = {
889 {.center_freq = 2412, .hw_value = 1, },
890 {.center_freq = 2417, .hw_value = 2, },
891 {.center_freq = 2422, .hw_value = 3, },
892 {.center_freq = 2427, .hw_value = 4, },
893 {.center_freq = 2432, .hw_value = 5, },
894 {.center_freq = 2437, .hw_value = 6, },
895 {.center_freq = 2442, .hw_value = 7, },
896 {.center_freq = 2447, .hw_value = 8, },
897 {.center_freq = 2452, .hw_value = 9, },
898 {.center_freq = 2457, .hw_value = 10, },
899 {.center_freq = 2462, .hw_value = 11, },
900 {.center_freq = 2467, .hw_value = 12, },
901 {.center_freq = 2472, .hw_value = 13, },
902 {.center_freq = 2484, .hw_value = 14, },
903};
904
905static struct ieee80211_supported_band mwifiex_band_2ghz = {
906 .channels = mwifiex_channels_2ghz,
907 .n_channels = ARRAY_SIZE(mwifiex_channels_2ghz),
908 .bitrates = mwifiex_rates,
8763848e 909 .n_bitrates = ARRAY_SIZE(mwifiex_rates),
5e6e3a92
BZ		 910};
911
912static struct ieee80211_channel mwifiex_channels_5ghz[] = {
913 {.center_freq = 5040, .hw_value = 8, },
914 {.center_freq = 5060, .hw_value = 12, },
915 {.center_freq = 5080, .hw_value = 16, },
916 {.center_freq = 5170, .hw_value = 34, },
917 {.center_freq = 5190, .hw_value = 38, },
918 {.center_freq = 5210, .hw_value = 42, },
919 {.center_freq = 5230, .hw_value = 46, },
920 {.center_freq = 5180, .hw_value = 36, },
921 {.center_freq = 5200, .hw_value = 40, },
922 {.center_freq = 5220, .hw_value = 44, },
923 {.center_freq = 5240, .hw_value = 48, },
924 {.center_freq = 5260, .hw_value = 52, },
925 {.center_freq = 5280, .hw_value = 56, },
926 {.center_freq = 5300, .hw_value = 60, },
927 {.center_freq = 5320, .hw_value = 64, },
928 {.center_freq = 5500, .hw_value = 100, },
929 {.center_freq = 5520, .hw_value = 104, },
930 {.center_freq = 5540, .hw_value = 108, },
931 {.center_freq = 5560, .hw_value = 112, },
932 {.center_freq = 5580, .hw_value = 116, },
933 {.center_freq = 5600, .hw_value = 120, },
934 {.center_freq = 5620, .hw_value = 124, },
935 {.center_freq = 5640, .hw_value = 128, },
936 {.center_freq = 5660, .hw_value = 132, },
937 {.center_freq = 5680, .hw_value = 136, },
938 {.center_freq = 5700, .hw_value = 140, },
939 {.center_freq = 5745, .hw_value = 149, },
940 {.center_freq = 5765, .hw_value = 153, },
941 {.center_freq = 5785, .hw_value = 157, },
942 {.center_freq = 5805, .hw_value = 161, },
943 {.center_freq = 5825, .hw_value = 165, },
944};
945
946static struct ieee80211_supported_band mwifiex_band_5ghz = {
947 .channels = mwifiex_channels_5ghz,
948 .n_channels = ARRAY_SIZE(mwifiex_channels_5ghz),
eb416ad3
AP		 949 .bitrates = mwifiex_rates + 4,
950 .n_bitrates = ARRAY_SIZE(mwifiex_rates) - 4,
5e6e3a92
BZ		 951};
952
953
954/* Supported crypto cipher suits to be advertised to cfg80211 */
5e6e3a92
BZ		 955static const u32 mwifiex_cipher_suites[] = {
956 WLAN_CIPHER_SUITE_WEP40,
957 WLAN_CIPHER_SUITE_WEP104,
958 WLAN_CIPHER_SUITE_TKIP,
959 WLAN_CIPHER_SUITE_CCMP,
53b11231 960 WLAN_CIPHER_SUITE_AES_CMAC,
5e6e3a92
BZ		 961};
962
83719be8
SP		 963/* Supported mgmt frame types to be advertised to cfg80211 */
964static const struct ieee80211_txrx_stypes
965mwifiex_mgmt_stypes[NUM_NL80211_IFTYPES] = {
966 [NL80211_IFTYPE_STATION] = {
967 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
968 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
969 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
970 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
971 },
972 [NL80211_IFTYPE_AP] = {
973 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
974 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
975 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
976 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
977 },
978 [NL80211_IFTYPE_P2P_CLIENT] = {
979 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
980 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
981 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
982 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
983 },
984 [NL80211_IFTYPE_P2P_GO] = {
985 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
986 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
987 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
988 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
989 },
990};
991
5d82c53a
YAP		 992/*
993 * CFG802.11 operation handler for setting bit rates.
994 *
433c3990
AK		 995 * Function configures data rates to firmware using bitrate mask
996 * provided by cfg80211.
5d82c53a
YAP		 997 */
998static int mwifiex_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
999 struct net_device *dev,
1000 const u8 *peer,
1001 const struct cfg80211_bitrate_mask *mask)
1002{
5d82c53a 1003 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
433c3990
AK		 1004 u16 bitmap_rates[MAX_BITMAP_RATES_SIZE];
1005 enum ieee80211_band band;
5d82c53a 1006
433c3990
AK		 1007 if (!priv->media_connected) {
1008 dev_err(priv->adapter->dev,
1009 "Can not set Tx data rate in disconnected state\n");
1010 return -EINVAL;
5d82c53a
YAP		 1011 }
1012
433c3990 1013 band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
5d82c53a 1014
433c3990 1015 memset(bitmap_rates, 0, sizeof(bitmap_rates));
5d82c53a 1016
433c3990
AK		 1017 /* Fill HR/DSSS rates. */
1018 if (band == IEEE80211_BAND_2GHZ)
1019 bitmap_rates[0] = mask->control[band].legacy & 0x000f;
5d82c53a 1020
433c3990
AK		 1021 /* Fill OFDM rates */
1022 if (band == IEEE80211_BAND_2GHZ)
1023 bitmap_rates[1] = (mask->control[band].legacy & 0x0ff0) >> 4;
1024 else
1025 bitmap_rates[1] = mask->control[band].legacy;
1026
1027 /* Fill MCS rates */
1028 bitmap_rates[2] = mask->control[band].mcs[0];
1029 if (priv->adapter->hw_dev_mcs_support == HT_STREAM_2X2)
1030 bitmap_rates[2] |= mask->control[band].mcs[1] << 8;
1031
1032 return mwifiex_send_cmd_sync(priv, HostCmd_CMD_TX_RATE_CFG,
1033 HostCmd_ACT_GEN_SET, 0, bitmap_rates);
5d82c53a
YAP		 1034}
1035
fa444bf8
AK		 1036/*
1037 * CFG802.11 operation handler for connection quality monitoring.
1038 *
1039 * This function subscribes/unsubscribes HIGH_RSSI and LOW_RSSI
1040 * events to FW.
1041 */
1042static int mwifiex_cfg80211_set_cqm_rssi_config(struct wiphy *wiphy,
1043 struct net_device *dev,
1044 s32 rssi_thold, u32 rssi_hyst)
1045{
1046 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1047 struct mwifiex_ds_misc_subsc_evt subsc_evt;
1048
1049 priv->cqm_rssi_thold = rssi_thold;
1050 priv->cqm_rssi_hyst = rssi_hyst;
1051
1052 memset(&subsc_evt, 0x00, sizeof(struct mwifiex_ds_misc_subsc_evt));
1053 subsc_evt.events = BITMASK_BCN_RSSI_LOW | BITMASK_BCN_RSSI_HIGH;
1054
1055 /* Subscribe/unsubscribe low and high rssi events */
1056 if (rssi_thold && rssi_hyst) {
1057 subsc_evt.action = HostCmd_ACT_BITWISE_SET;
1058 subsc_evt.bcn_l_rssi_cfg.abs_value = abs(rssi_thold);
1059 subsc_evt.bcn_h_rssi_cfg.abs_value = abs(rssi_thold);
1060 subsc_evt.bcn_l_rssi_cfg.evt_freq = 1;
1061 subsc_evt.bcn_h_rssi_cfg.evt_freq = 1;
1062 return mwifiex_send_cmd_sync(priv,
1063 HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
1064 0, 0, &subsc_evt);
1065 } else {
1066 subsc_evt.action = HostCmd_ACT_BITWISE_CLR;
1067 return mwifiex_send_cmd_sync(priv,
1068 HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
1069 0, 0, &subsc_evt);
1070 }
1071
1072 return 0;
1073}
1074
5370c836
AP		 1075/* cfg80211 operation handler for change_beacon.
1076 * Function retrieves and sets modified management IEs to FW.
1077 */
1078static int mwifiex_cfg80211_change_beacon(struct wiphy *wiphy,
1079 struct net_device *dev,
1080 struct cfg80211_beacon_data *data)
1081{
1082 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1083
1084 if (priv->bss_type != MWIFIEX_BSS_TYPE_UAP) {
1085 wiphy_err(wiphy, "%s: bss_type mismatched\n", __func__);
1086 return -EINVAL;
1087 }
1088
1089 if (!priv->bss_started) {
1090 wiphy_err(wiphy, "%s: bss not started\n", __func__);
1091 return -EINVAL;
1092 }
1093
1094 if (mwifiex_set_mgmt_ies(priv, data)) {
1095 wiphy_err(wiphy, "%s: setting mgmt ies failed\n", __func__);
1096 return -EFAULT;
1097 }
1098
1099 return 0;
1100}
1101
8a279d5b
AK		 1102static int
1103mwifiex_cfg80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
1104{
1105 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
1106 struct mwifiex_private *priv = mwifiex_get_priv(adapter,
1107 MWIFIEX_BSS_ROLE_ANY);
1108 struct mwifiex_ds_ant_cfg ant_cfg;
1109
1110 if (!tx_ant || !rx_ant)
1111 return -EOPNOTSUPP;
1112
1113 if (adapter->hw_dev_mcs_support != HT_STREAM_2X2) {
1114 /* Not a MIMO chip. User should provide specific antenna number
1115 * for Tx/Rx path or enable all antennas for diversity
1116 */
1117 if (tx_ant != rx_ant)
1118 return -EOPNOTSUPP;
1119
1120 if ((tx_ant & (tx_ant - 1)) &&
1121 (tx_ant != BIT(adapter->number_of_antenna) - 1))
1122 return -EOPNOTSUPP;
1123
1124 if ((tx_ant == BIT(adapter->number_of_antenna) - 1) &&
1125 (priv->adapter->number_of_antenna > 1)) {
1126 tx_ant = RF_ANTENNA_AUTO;
1127 rx_ant = RF_ANTENNA_AUTO;
1128 }
1129 }
1130
1131 ant_cfg.tx_ant = tx_ant;
1132 ant_cfg.rx_ant = rx_ant;
1133
1134 return mwifiex_send_cmd_sync(priv, HostCmd_CMD_RF_ANTENNA,
1135 HostCmd_ACT_GEN_SET, 0, &ant_cfg);
1136}
1137
12190c5d
AP		 1138/* cfg80211 operation handler for stop ap.
1139 * Function stops BSS running at uAP interface.
1140 */
1141static int mwifiex_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
1142{
1143 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1144
40bbc21a
AP		 1145 if (mwifiex_del_mgmt_ies(priv))
1146 wiphy_err(wiphy, "Failed to delete mgmt IEs!\n");
1147
c8258913
AP		 1148 priv->ap_11n_enabled = 0;
1149
12190c5d
AP		 1150 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_UAP_BSS_STOP,
1151 HostCmd_ACT_GEN_SET, 0, NULL)) {
1152 wiphy_err(wiphy, "Failed to stop the BSS\n");
1153 return -1;
1154 }
1155
1156 return 0;
1157}
1158
1159/* cfg80211 operation handler for start_ap.
1160 * Function sets beacon period, DTIM period, SSID and security into
1161 * AP config structure.
1162 * AP is configured with these settings and BSS is started.
1163 */
1164static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
1165 struct net_device *dev,
1166 struct cfg80211_ap_settings *params)
1167{
1168 struct mwifiex_uap_bss_param *bss_cfg;
1169 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
05910f4a 1170 u8 config_bands = 0;
12190c5d 1171
f752dcd5
AP		 1172 if (priv->bss_type != MWIFIEX_BSS_TYPE_UAP)
1173 return -1;
adb6ed0c 1174 if (mwifiex_set_mgmt_ies(priv, &params->beacon))
f31acabe 1175 return -1;
f752dcd5 1176
12190c5d
AP		 1177 bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param), GFP_KERNEL);
1178 if (!bss_cfg)
1179 return -ENOMEM;
1180
1181 mwifiex_set_sys_config_invalid_data(bss_cfg);
1182
1183 if (params->beacon_interval)
1184 bss_cfg->beacon_period = params->beacon_interval;
1185 if (params->dtim_period)
1186 bss_cfg->dtim_period = params->dtim_period;
1187
1188 if (params->ssid && params->ssid_len) {
1189 memcpy(bss_cfg->ssid.ssid, params->ssid, params->ssid_len);
1190 bss_cfg->ssid.ssid_len = params->ssid_len;
1191 }
1192
7a1c9934
AP		 1193 switch (params->hidden_ssid) {
1194 case NL80211_HIDDEN_SSID_NOT_IN_USE:
1195 bss_cfg->bcast_ssid_ctl = 1;
1196 break;
1197 case NL80211_HIDDEN_SSID_ZERO_LEN:
1198 bss_cfg->bcast_ssid_ctl = 0;
1199 break;
1200 case NL80211_HIDDEN_SSID_ZERO_CONTENTS:
1201 /* firmware doesn't support this type of hidden SSID */
1202 default:
b3190466 1203 kfree(bss_cfg);
7a1c9934
AP		 1204 return -EINVAL;
1205 }
1206
0abd79e5
AP		 1207 bss_cfg->channel =
1208 (u8)ieee80211_frequency_to_channel(params->channel->center_freq);
0abd79e5 1209
05910f4a
AK		 1210 /* Set appropriate bands */
1211 if (params->channel->band == IEEE80211_BAND_2GHZ) {
a3c2c4f6
AP		 1212 bss_cfg->band_cfg = BAND_CONFIG_BG;
1213
05910f4a
AK		 1214 if (params->channel_type == NL80211_CHAN_NO_HT)
1215 config_bands = BAND_B | BAND_G;
1216 else
1217 config_bands = BAND_B | BAND_G | BAND_GN;
1218 } else {
a3c2c4f6
AP		 1219 bss_cfg->band_cfg = BAND_CONFIG_A;
1220
05910f4a
AK		 1221 if (params->channel_type == NL80211_CHAN_NO_HT)
1222 config_bands = BAND_A;
1223 else
1224 config_bands = BAND_AN | BAND_A;
0abd79e5
AP		 1225 }
1226
05910f4a
AK		 1227 if (!((config_bands | priv->adapter->fw_bands) &
1228 ~priv->adapter->fw_bands))
1229 priv->adapter->config_bands = config_bands;
1230
a3c2c4f6 1231 mwifiex_set_uap_rates(bss_cfg, params);
05910f4a
AK		 1232 mwifiex_send_domain_info_cmd_fw(wiphy);
1233
f752dcd5
AP		 1234 if (mwifiex_set_secure_params(priv, bss_cfg, params)) {
1235 kfree(bss_cfg);
1236 wiphy_err(wiphy, "Failed to parse secuirty parameters!\n");
1237 return -1;
1238 }
1239
22281256
AP		 1240 mwifiex_set_ht_params(priv, bss_cfg, params);
1241
12190c5d
AP		 1242 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_UAP_BSS_STOP,
1243 HostCmd_ACT_GEN_SET, 0, NULL)) {
1244 wiphy_err(wiphy, "Failed to stop the BSS\n");
1245 kfree(bss_cfg);
1246 return -1;
1247 }
1248
1249 if (mwifiex_send_cmd_async(priv, HostCmd_CMD_UAP_SYS_CONFIG,
e76268da
AP		 1250 HostCmd_ACT_GEN_SET,
1251 UAP_BSS_PARAMS_I, bss_cfg)) {
12190c5d
AP		 1252 wiphy_err(wiphy, "Failed to set the SSID\n");
1253 kfree(bss_cfg);
1254 return -1;
1255 }
1256
1257 kfree(bss_cfg);
1258
1259 if (mwifiex_send_cmd_async(priv, HostCmd_CMD_UAP_BSS_START,
1260 HostCmd_ACT_GEN_SET, 0, NULL)) {
1261 wiphy_err(wiphy, "Failed to start the BSS\n");
1262 return -1;
1263 }
1264
96893538
AP		 1265 if (priv->sec_info.wep_enabled)
1266 priv->curr_pkt_filter |= HostCmd_ACT_MAC_WEP_ENABLE;
1267 else
1268 priv->curr_pkt_filter &= ~HostCmd_ACT_MAC_WEP_ENABLE;
1269
1270 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_MAC_CONTROL,
1271 HostCmd_ACT_GEN_SET, 0,
1272 &priv->curr_pkt_filter))
1273 return -1;
1274
12190c5d
AP		 1275 return 0;
1276}
1277
5e6e3a92
BZ		 1278/*
1279 * CFG802.11 operation handler for disconnection request.
1280 *
1281 * This function does not work when there is already a disconnection
1282 * procedure going on.
1283 */
1284static int
1285mwifiex_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1286 u16 reason_code)
1287{
1288 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1289
600f5d90 1290 if (mwifiex_deauthenticate(priv, NULL))
5e6e3a92
BZ		 1291 return -EFAULT;
1292
1293 wiphy_dbg(wiphy, "info: successfully disconnected from %pM:"
1294 " reason code %d\n", priv->cfg_bssid, reason_code);
1295
38c9d664 1296 memset(priv->cfg_bssid, 0, ETH_ALEN);
5e6e3a92
BZ		 1297
1298 return 0;
1299}
1300
1301/*
1302 * This function informs the CFG802.11 subsystem of a new IBSS.
1303 *
1304 * The following information are sent to the CFG802.11 subsystem
1305 * to register the new IBSS. If we do not register the new IBSS,
1306 * a kernel panic will result.
1307 * - SSID
1308 * - SSID length
1309 * - BSSID
1310 * - Channel
1311 */
1312static int mwifiex_cfg80211_inform_ibss_bss(struct mwifiex_private *priv)
1313{
5e6e3a92
BZ		 1314 struct ieee80211_channel *chan;
1315 struct mwifiex_bss_info bss_info;
aa95a48d 1316 struct cfg80211_bss *bss;
270e58e8 1317 int ie_len;
5e6e3a92 1318 u8 ie_buf[IEEE80211_MAX_SSID_LEN + sizeof(struct ieee_types_header)];
4ed5d521 1319 enum ieee80211_band band;
5e6e3a92 1320
636c4598
YAP		 1321 if (mwifiex_get_bss_info(priv, &bss_info))
1322 return -1;
5e6e3a92
BZ		 1323
1324 ie_buf[0] = WLAN_EID_SSID;
1325 ie_buf[1] = bss_info.ssid.ssid_len;
1326
1327 memcpy(&ie_buf[sizeof(struct ieee_types_header)],
aea0701e 1328 &bss_info.ssid.ssid, bss_info.ssid.ssid_len);
5e6e3a92
BZ		 1329 ie_len = ie_buf[1] + sizeof(struct ieee_types_header);
1330
4ed5d521 1331 band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
5e6e3a92
BZ		 1332 chan = __ieee80211_get_channel(priv->wdev->wiphy,
1333 ieee80211_channel_to_frequency(bss_info.bss_chan,
4ed5d521 1334 band));
5e6e3a92 1335
aa95a48d 1336 bss = cfg80211_inform_bss(priv->wdev->wiphy, chan,
aea0701e
YAP		 1337 bss_info.bssid, 0, WLAN_CAPABILITY_IBSS,
1338 0, ie_buf, ie_len, 0, GFP_KERNEL);
aa95a48d 1339 cfg80211_put_bss(bss);
5e6e3a92
BZ		 1340 memcpy(priv->cfg_bssid, bss_info.bssid, ETH_ALEN);
1341
636c4598 1342 return 0;
5e6e3a92
BZ		 1343}
1344
5e6e3a92
BZ		 1345/*
1346 * This function connects with a BSS.
1347 *
1348 * This function handles both Infra and Ad-Hoc modes. It also performs
1349 * validity checking on the provided parameters, disconnects from the
1350 * current BSS (if any), sets up the association/scan parameters,
1351 * including security settings, and performs specific SSID scan before
1352 * trying to connect.
1353 *
1354 * For Infra mode, the function returns failure if the specified SSID
1355 * is not found in scan table. However, for Ad-Hoc mode, it can create
1356 * the IBSS if it does not exist. On successful completion in either case,
7c6fa2a8 1357 * the function notifies the CFG802.11 subsystem of the new BSS connection.
5e6e3a92
BZ		 1358 */
1359static int
1360mwifiex_cfg80211_assoc(struct mwifiex_private *priv, size_t ssid_len, u8 *ssid,
1361 u8 *bssid, int mode, struct ieee80211_channel *channel,
1362 struct cfg80211_connect_params *sme, bool privacy)
1363{
b9be5f39 1364 struct cfg80211_ssid req_ssid;
270e58e8 1365 int ret, auth_type = 0;
7c6fa2a8 1366 struct cfg80211_bss *bss = NULL;
05910f4a 1367 u8 is_scanning_required = 0, config_bands = 0;
5e6e3a92 1368
b9be5f39 1369 memset(&req_ssid, 0, sizeof(struct cfg80211_ssid));
5e6e3a92
BZ		 1370
1371 req_ssid.ssid_len = ssid_len;
1372 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
1373 dev_err(priv->adapter->dev, "invalid SSID - aborting\n");
1374 return -EINVAL;
1375 }
1376
1377 memcpy(req_ssid.ssid, ssid, ssid_len);
1378 if (!req_ssid.ssid_len || req_ssid.ssid[0] < 0x20) {
1379 dev_err(priv->adapter->dev, "invalid SSID - aborting\n");
1380 return -EINVAL;
1381 }
1382
1383 /* disconnect before try to associate */
600f5d90 1384 mwifiex_deauthenticate(priv, NULL);
5e6e3a92 1385
05910f4a
AK		 1386 if (channel) {
1387 if (mode == NL80211_IFTYPE_STATION) {
1388 if (channel->band == IEEE80211_BAND_2GHZ)
1389 config_bands = BAND_B | BAND_G | BAND_GN;
1390 else
1391 config_bands = BAND_A | BAND_AN;
1392
1393 if (!((config_bands | priv->adapter->fw_bands) &
1394 ~priv->adapter->fw_bands))
1395 priv->adapter->config_bands = config_bands;
1396 }
05910f4a 1397 }
5e6e3a92 1398
6670f15b
AK		 1399 /* As this is new association, clear locally stored
1400 * keys and security related flags */
1401 priv->sec_info.wpa_enabled = false;
1402 priv->sec_info.wpa2_enabled = false;
1403 priv->wep_key_curr_index = 0;
00f157b4 1404 priv->sec_info.encryption_mode = 0;
a0f6d6ca 1405 priv->sec_info.is_authtype_auto = 0;
53b11231 1406 ret = mwifiex_set_encode(priv, NULL, NULL, 0, 0, NULL, 1);
5e6e3a92 1407
eecd8250 1408 if (mode == NL80211_IFTYPE_ADHOC) {
5e6e3a92
BZ		 1409 /* "privacy" is set only for ad-hoc mode */
1410 if (privacy) {
1411 /*
2be50b8d 1412 * Keep WLAN_CIPHER_SUITE_WEP104 for now so that
5e6e3a92
BZ		 1413 * the firmware can find a matching network from the
1414 * scan. The cfg80211 does not give us the encryption
1415 * mode at this stage so just setting it to WEP here.
1416 */
203afeca 1417 priv->sec_info.encryption_mode =
2be50b8d 1418 WLAN_CIPHER_SUITE_WEP104;
203afeca 1419 priv->sec_info.authentication_mode =
f986b6d5 1420 NL80211_AUTHTYPE_OPEN_SYSTEM;
5e6e3a92
BZ		 1421 }
1422
1423 goto done;
1424 }
1425
1426 /* Now handle infra mode. "sme" is valid for infra mode only */
a0f6d6ca 1427 if (sme->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
f986b6d5 1428 auth_type = NL80211_AUTHTYPE_OPEN_SYSTEM;
a0f6d6ca
AK		 1429 priv->sec_info.is_authtype_auto = 1;
1430 } else {
1431 auth_type = sme->auth_type;
1432 }
5e6e3a92
BZ		 1433
1434 if (sme->crypto.n_ciphers_pairwise) {
2be50b8d
YAP		 1435 priv->sec_info.encryption_mode =
1436 sme->crypto.ciphers_pairwise[0];
203afeca 1437 priv->sec_info.authentication_mode = auth_type;
5e6e3a92
BZ		 1438 }
1439
1440 if (sme->crypto.cipher_group) {
2be50b8d 1441 priv->sec_info.encryption_mode = sme->crypto.cipher_group;
203afeca 1442 priv->sec_info.authentication_mode = auth_type;
5e6e3a92
BZ		 1443 }
1444 if (sme->ie)
1445 ret = mwifiex_set_gen_ie(priv, sme->ie, sme->ie_len);
1446
1447 if (sme->key) {
e6faada5 1448 if (mwifiex_is_alg_wep(priv->sec_info.encryption_mode)) {
5e6e3a92
BZ		 1449 dev_dbg(priv->adapter->dev,
1450 "info: setting wep encryption"
1451 " with key len %d\n", sme->key_len);
6670f15b 1452 priv->wep_key_curr_index = sme->key_idx;
53b11231
YL		 1453 ret = mwifiex_set_encode(priv, NULL, sme->key,
1454 sme->key_len, sme->key_idx,
1455 NULL, 0);
5e6e3a92
BZ		 1456 }
1457 }
1458done:
7c6fa2a8
AK		 1459 /*
1460 * Scan entries are valid for some time (15 sec). So we can save one
1461 * active scan time if we just try cfg80211_get_bss first. If it fails
1462 * then request scan and cfg80211_get_bss() again for final output.
1463 */
1464 while (1) {
1465 if (is_scanning_required) {
1466 /* Do specific SSID scanning */
1467 if (mwifiex_request_scan(priv, &req_ssid)) {
1468 dev_err(priv->adapter->dev, "scan error\n");
1469 return -EFAULT;
1470 }
1471 }
5e6e3a92 1472
7c6fa2a8
AK		 1473 /* Find the BSS we want using available scan results */
1474 if (mode == NL80211_IFTYPE_ADHOC)
1475 bss = cfg80211_get_bss(priv->wdev->wiphy, channel,
1476 bssid, ssid, ssid_len,
1477 WLAN_CAPABILITY_IBSS,
1478 WLAN_CAPABILITY_IBSS);
1479 else
1480 bss = cfg80211_get_bss(priv->wdev->wiphy, channel,
1481 bssid, ssid, ssid_len,
1482 WLAN_CAPABILITY_ESS,
1483 WLAN_CAPABILITY_ESS);
1484
1485 if (!bss) {
1486 if (is_scanning_required) {
aea0701e
YAP		 1487 dev_warn(priv->adapter->dev,
1488 "assoc: requested bss not found in scan results\n");
7c6fa2a8
AK		 1489 break;
1490 }
1491 is_scanning_required = 1;
1492 } else {
aea0701e
YAP		 1493 dev_dbg(priv->adapter->dev,
1494 "info: trying to associate to '%s' bssid %pM\n",
1495 (char *) req_ssid.ssid, bss->bssid);
7c6fa2a8
AK		 1496 memcpy(&priv->cfg_bssid, bss->bssid, ETH_ALEN);
1497 break;
1498 }
5e6e3a92
BZ		 1499 }
1500
7c6fa2a8 1501 if (mwifiex_bss_start(priv, bss, &req_ssid))
5e6e3a92
BZ		 1502 return -EFAULT;
1503
eecd8250 1504 if (mode == NL80211_IFTYPE_ADHOC) {
5e6e3a92
BZ		 1505 /* Inform the BSS information to kernel, otherwise
1506 * kernel will give a panic after successful assoc */
1507 if (mwifiex_cfg80211_inform_ibss_bss(priv))
1508 return -EFAULT;
1509 }
1510
1511 return ret;
1512}
1513
1514/*
1515 * CFG802.11 operation handler for association request.
1516 *
1517 * This function does not work when the current mode is set to Ad-Hoc, or
1518 * when there is already an association procedure going on. The given BSS
1519 * information is used to associate.
1520 */
1521static int
1522mwifiex_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
1523 struct cfg80211_connect_params *sme)
1524{
1525 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1526 int ret = 0;
5e6e3a92 1527
eecd8250 1528 if (priv->bss_mode == NL80211_IFTYPE_ADHOC) {
5e6e3a92
BZ		 1529 wiphy_err(wiphy, "received infra assoc request "
1530 "when station is in ibss mode\n");
1531 goto done;
1532 }
1533
e568634a
AP		 1534 if (priv->bss_mode == NL80211_IFTYPE_AP) {
1535 wiphy_err(wiphy, "skip association request for AP interface\n");
1536 goto done;
1537 }
1538
5e6e3a92 1539 wiphy_dbg(wiphy, "info: Trying to associate to %s and bssid %pM\n",
aea0701e 1540 (char *) sme->ssid, sme->bssid);
5e6e3a92
BZ		 1541
1542 ret = mwifiex_cfg80211_assoc(priv, sme->ssid_len, sme->ssid, sme->bssid,
eecd8250 1543 priv->bss_mode, sme->channel, sme, 0);
5e6e3a92 1544done:
38c9d664
AK		 1545 if (!ret) {
1546 cfg80211_connect_result(priv->netdev, priv->cfg_bssid, NULL, 0,
1547 NULL, 0, WLAN_STATUS_SUCCESS,
1548 GFP_KERNEL);
1549 dev_dbg(priv->adapter->dev,
1550 "info: associated to bssid %pM successfully\n",
1551 priv->cfg_bssid);
1552 } else {
1553 dev_dbg(priv->adapter->dev,
1554 "info: association to bssid %pM failed\n",
1555 priv->cfg_bssid);
1556 memset(priv->cfg_bssid, 0, ETH_ALEN);
1557 }
1558
5e6e3a92
BZ		 1559 return ret;
1560}
1561
05910f4a
AK		 1562/*
1563 * This function sets following parameters for ibss network.
1564 * - channel
1565 * - start band
1566 * - 11n flag
1567 * - secondary channel offset
1568 */
1569static int mwifiex_set_ibss_params(struct mwifiex_private *priv,
1570 struct cfg80211_ibss_params *params)
1571{
1572 struct wiphy *wiphy = priv->wdev->wiphy;
1573 struct mwifiex_adapter *adapter = priv->adapter;
1574 int index = 0, i;
1575 u8 config_bands = 0;
1576
1577 if (params->channel->band == IEEE80211_BAND_2GHZ) {
1578 if (!params->basic_rates) {
1579 config_bands = BAND_B | BAND_G;
1580 } else {
1581 for (i = 0; i < mwifiex_band_2ghz.n_bitrates; i++) {
1582 /*
1583 * Rates below 6 Mbps in the table are CCK
1584 * rates; 802.11b and from 6 they are OFDM;
1585 * 802.11G
1586 */
1587 if (mwifiex_rates[i].bitrate == 60) {
1588 index = 1 << i;
1589 break;
1590 }
1591 }
1592
1593 if (params->basic_rates < index) {
1594 config_bands = BAND_B;
1595 } else {
1596 config_bands = BAND_G;
1597 if (params->basic_rates % index)
1598 config_bands |= BAND_B;
1599 }
1600 }
1601
1602 if (params->channel_type != NL80211_CHAN_NO_HT)
1603 config_bands |= BAND_GN;
1604 } else {
1605 if (params->channel_type == NL80211_CHAN_NO_HT)
1606 config_bands = BAND_A;
1607 else
1608 config_bands = BAND_AN | BAND_A;
1609 }
1610
1611 if (!((config_bands | adapter->fw_bands) & ~adapter->fw_bands)) {
1612 adapter->config_bands = config_bands;
1613 adapter->adhoc_start_band = config_bands;
1614
1615 if ((config_bands & BAND_GN) || (config_bands & BAND_AN))
1616 adapter->adhoc_11n_enabled = true;
1617 else
1618 adapter->adhoc_11n_enabled = false;
1619 }
1620
1621 adapter->sec_chan_offset =
1622 mwifiex_chan_type_to_sec_chan_offset(params->channel_type);
1623 priv->adhoc_channel =
1624 ieee80211_frequency_to_channel(params->channel->center_freq);
1625
1626 wiphy_dbg(wiphy, "info: set ibss band %d, chan %d, chan offset %d\n",
1627 config_bands, priv->adhoc_channel, adapter->sec_chan_offset);
1628
1629 return 0;
1630}
1631
5e6e3a92
BZ		 1632/*
1633 * CFG802.11 operation handler to join an IBSS.
1634 *
1635 * This function does not work in any mode other than Ad-Hoc, or if
1636 * a join operation is already in progress.
1637 */
1638static int
1639mwifiex_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
1640 struct cfg80211_ibss_params *params)
1641{
f540f9f3 1642 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
5e6e3a92 1643 int ret = 0;
5e6e3a92 1644
eecd8250 1645 if (priv->bss_mode != NL80211_IFTYPE_ADHOC) {
5e6e3a92
BZ		 1646 wiphy_err(wiphy, "request to join ibss received "
1647 "when station is not in ibss mode\n");
1648 goto done;
1649 }
1650
5e6e3a92 1651 wiphy_dbg(wiphy, "info: trying to join to %s and bssid %pM\n",
aea0701e 1652 (char *) params->ssid, params->bssid);
5e6e3a92 1653
05910f4a
AK		 1654 mwifiex_set_ibss_params(priv, params);
1655
5e6e3a92 1656 ret = mwifiex_cfg80211_assoc(priv, params->ssid_len, params->ssid,
aea0701e
YAP		 1657 params->bssid, priv->bss_mode,
1658 params->channel, NULL, params->privacy);
5e6e3a92 1659done:
38c9d664
AK		 1660 if (!ret) {
1661 cfg80211_ibss_joined(priv->netdev, priv->cfg_bssid, GFP_KERNEL);
1662 dev_dbg(priv->adapter->dev,
1663 "info: joined/created adhoc network with bssid"
1664 " %pM successfully\n", priv->cfg_bssid);
1665 } else {
1666 dev_dbg(priv->adapter->dev,
1667 "info: failed creating/joining adhoc network\n");
1668 }
1669
5e6e3a92
BZ		 1670 return ret;
1671}
1672
1673/*
1674 * CFG802.11 operation handler to leave an IBSS.
1675 *
1676 * This function does not work if a leave operation is
1677 * already in progress.
1678 */
1679static int
1680mwifiex_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1681{
f540f9f3 1682 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
5e6e3a92 1683
5e6e3a92 1684 wiphy_dbg(wiphy, "info: disconnecting from essid %pM\n",
aea0701e 1685 priv->cfg_bssid);
600f5d90 1686 if (mwifiex_deauthenticate(priv, NULL))
5e6e3a92
BZ		 1687 return -EFAULT;
1688
38c9d664 1689 memset(priv->cfg_bssid, 0, ETH_ALEN);
5e6e3a92
BZ		 1690
1691 return 0;
1692}
1693
1694/*
1695 * CFG802.11 operation handler for scan request.
1696 *
1697 * This function issues a scan request to the firmware based upon
1698 * the user specified scan configuration. On successfull completion,
1699 * it also informs the results.
1700 */
1701static int
fd014284 1702mwifiex_cfg80211_scan(struct wiphy *wiphy,
5e6e3a92
BZ		 1703 struct cfg80211_scan_request *request)
1704{
fd014284 1705 struct net_device *dev = request->wdev->netdev;
5e6e3a92 1706 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
ea021f56 1707 int i, offset;
38c9d664 1708 struct ieee80211_channel *chan;
ea021f56 1709 struct ieee_types_header *ie;
5e6e3a92
BZ		 1710
1711 wiphy_dbg(wiphy, "info: received scan request on %s\n", dev->name);
1712
de09364e
AK		 1713 if (atomic_read(&priv->wmm.tx_pkts_queued) >=
1714 MWIFIEX_MIN_TX_PENDING_TO_CANCEL_SCAN) {
1715 dev_dbg(priv->adapter->dev, "scan rejected due to traffic\n");
1716 return -EBUSY;
1717 }
1718
5e6e3a92
BZ		 1719 priv->scan_request = request;
1720
38c9d664 1721 priv->user_scan_cfg = kzalloc(sizeof(struct mwifiex_user_scan_cfg),
aea0701e 1722 GFP_KERNEL);
38c9d664
AK		 1723 if (!priv->user_scan_cfg) {
1724 dev_err(priv->adapter->dev, "failed to alloc scan_req\n");
1725 return -ENOMEM;
1726 }
be0b281e
AK		 1727
1728 priv->user_scan_cfg->num_ssids = request->n_ssids;
1729 priv->user_scan_cfg->ssid_list = request->ssids;
1730
13d7ba78 1731 if (request->ie && request->ie_len) {
ea021f56 1732 offset = 0;
13d7ba78
AP		 1733 for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
1734 if (priv->vs_ie[i].mask != MWIFIEX_VSIE_MASK_CLEAR)
1735 continue;
1736 priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_SCAN;
ea021f56
SP		 1737 ie = (struct ieee_types_header *)(request->ie + offset);
1738 memcpy(&priv->vs_ie[i].ie, ie, sizeof(*ie) + ie->len);
1739 offset += sizeof(*ie) + ie->len;
1740
1741 if (offset >= request->ie_len)
1742 break;
13d7ba78
AP		 1743 }
1744 }
1745
38c9d664
AK		 1746 for (i = 0; i < request->n_channels; i++) {
1747 chan = request->channels[i];
1748 priv->user_scan_cfg->chan_list[i].chan_number = chan->hw_value;
1749 priv->user_scan_cfg->chan_list[i].radio_type = chan->band;
1750
1751 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
1752 priv->user_scan_cfg->chan_list[i].scan_type =
aea0701e 1753 MWIFIEX_SCAN_TYPE_PASSIVE;
38c9d664
AK		 1754 else
1755 priv->user_scan_cfg->chan_list[i].scan_type =
aea0701e 1756 MWIFIEX_SCAN_TYPE_ACTIVE;
38c9d664
AK		 1757
1758 priv->user_scan_cfg->chan_list[i].scan_time = 0;
1759 }
1a1fb970 1760 if (mwifiex_scan_networks(priv, priv->user_scan_cfg))
38c9d664
AK		 1761 return -EFAULT;
1762
13d7ba78
AP		 1763 if (request->ie && request->ie_len) {
1764 for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
1765 if (priv->vs_ie[i].mask == MWIFIEX_VSIE_MASK_SCAN) {
1766 priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_CLEAR;
1767 memset(&priv->vs_ie[i].ie, 0,
1768 MWIFIEX_MAX_VSIE_LEN);
1769 }
1770 }
1771 }
5e6e3a92
BZ		 1772 return 0;
1773}
1774
1775/*
1776 * This function sets up the CFG802.11 specific HT capability fields
1777 * with default values.
1778 *
1779 * The following default values are set -
1780 * - HT Supported = True
a46b7b5c
AK		 1781 * - Maximum AMPDU length factor = IEEE80211_HT_MAX_AMPDU_64K
1782 * - Minimum AMPDU spacing = IEEE80211_HT_MPDU_DENSITY_NONE
1783 * - HT Capabilities supported by firmware
5e6e3a92
BZ		 1784 * - MCS information, Rx mask = 0xff
1785 * - MCD information, Tx parameters = IEEE80211_HT_MCS_TX_DEFINED (0x01)
1786 */
1787static void
1788mwifiex_setup_ht_caps(struct ieee80211_sta_ht_cap *ht_info,
1789 struct mwifiex_private *priv)
1790{
1791 int rx_mcs_supp;
1792 struct ieee80211_mcs_info mcs_set;
1793 u8 *mcs = (u8 *)&mcs_set;
1794 struct mwifiex_adapter *adapter = priv->adapter;
1795
1796 ht_info->ht_supported = true;
a46b7b5c
AK		 1797 ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
1798 ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
5e6e3a92
BZ		 1799
1800 memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
5e6e3a92 1801
a46b7b5c
AK		 1802 /* Fill HT capability information */
1803 if (ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
1804 ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
1805 else
1806 ht_info->cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
1807
1808 if (ISSUPP_SHORTGI20(adapter->hw_dot_11n_dev_cap))
1809 ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
1810 else
1811 ht_info->cap &= ~IEEE80211_HT_CAP_SGI_20;
1812
1813 if (ISSUPP_SHORTGI40(adapter->hw_dot_11n_dev_cap))
1814 ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
1815 else
1816 ht_info->cap &= ~IEEE80211_HT_CAP_SGI_40;
1817
1818 if (ISSUPP_RXSTBC(adapter->hw_dot_11n_dev_cap))
1819 ht_info->cap |= 1 << IEEE80211_HT_CAP_RX_STBC_SHIFT;
1820 else
1821 ht_info->cap &= ~(3 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
1822
1823 if (ISSUPP_TXSTBC(adapter->hw_dot_11n_dev_cap))
1824 ht_info->cap |= IEEE80211_HT_CAP_TX_STBC;
1825 else
1826 ht_info->cap &= ~IEEE80211_HT_CAP_TX_STBC;
1827
1828 ht_info->cap &= ~IEEE80211_HT_CAP_MAX_AMSDU;
1829 ht_info->cap |= IEEE80211_HT_CAP_SM_PS;
1830
1831 rx_mcs_supp = GET_RXMCSSUPP(adapter->hw_dev_mcs_support);
5e6e3a92
BZ		 1832 /* Set MCS for 1x1 */
1833 memset(mcs, 0xff, rx_mcs_supp);
1834 /* Clear all the other values */
1835 memset(&mcs[rx_mcs_supp], 0,
aea0701e 1836 sizeof(struct ieee80211_mcs_info) - rx_mcs_supp);
eecd8250 1837 if (priv->bss_mode == NL80211_IFTYPE_STATION ||
aea0701e 1838 ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
5e6e3a92
BZ		 1839 /* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */
1840 SETHT_MCS32(mcs_set.rx_mask);
1841
1842 memcpy((u8 *) &ht_info->mcs, mcs, sizeof(struct ieee80211_mcs_info));
1843
1844 ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
1845}
1846
93a1df48
YAP		 1847/*
1848 * create a new virtual interface with the given name
1849 */
84efbb84 1850struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
552bff0c 1851 const char *name,
84efbb84
JB		 1852 enum nl80211_iftype type,
1853 u32 *flags,
1854 struct vif_params *params)
93a1df48 1855{
67fdf39e
AP		 1856 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
1857 struct mwifiex_private *priv;
93a1df48
YAP		 1858 struct net_device *dev;
1859 void *mdev_priv;
d6bffe8b 1860 struct wireless_dev *wdev;
93a1df48 1861
93a1df48 1862 if (!adapter)
858faa57 1863 return ERR_PTR(-EFAULT);
93a1df48
YAP		 1864
1865 switch (type) {
1866 case NL80211_IFTYPE_UNSPECIFIED:
1867 case NL80211_IFTYPE_STATION:
1868 case NL80211_IFTYPE_ADHOC:
d6bffe8b 1869 priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
93a1df48 1870 if (priv->bss_mode) {
d6bffe8b
AP		 1871 wiphy_err(wiphy,
1872 "cannot create multiple sta/adhoc ifaces\n");
858faa57 1873 return ERR_PTR(-EINVAL);
93a1df48
YAP		 1874 }
1875
d6bffe8b
AP		 1876 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
1877 if (!wdev)
858faa57 1878 return ERR_PTR(-ENOMEM);
d6bffe8b
AP		 1879
1880 wdev->wiphy = wiphy;
1881 priv->wdev = wdev;
1882 wdev->iftype = NL80211_IFTYPE_STATION;
1883
93a1df48
YAP		 1884 if (type == NL80211_IFTYPE_UNSPECIFIED)
1885 priv->bss_mode = NL80211_IFTYPE_STATION;
1886 else
1887 priv->bss_mode = type;
1888
1889 priv->bss_type = MWIFIEX_BSS_TYPE_STA;
1890 priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
a458c0ae 1891 priv->bss_priority = 0;
93a1df48 1892 priv->bss_role = MWIFIEX_BSS_ROLE_STA;
93a1df48
YAP		 1893 priv->bss_num = 0;
1894
d6bffe8b
AP		 1895 break;
1896 case NL80211_IFTYPE_AP:
1897 priv = adapter->priv[MWIFIEX_BSS_TYPE_UAP];
1898
1899 if (priv->bss_mode) {
1900 wiphy_err(wiphy, "Can't create multiple AP interfaces");
858faa57 1901 return ERR_PTR(-EINVAL);
d6bffe8b
AP		 1902 }
1903
1904 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
1905 if (!wdev)
858faa57 1906 return ERR_PTR(-ENOMEM);
d6bffe8b
AP		 1907
1908 priv->wdev = wdev;
1909 wdev->wiphy = wiphy;
1910 wdev->iftype = NL80211_IFTYPE_AP;
1911
1912 priv->bss_type = MWIFIEX_BSS_TYPE_UAP;
1913 priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
a458c0ae 1914 priv->bss_priority = 0;
d6bffe8b
AP		 1915 priv->bss_role = MWIFIEX_BSS_ROLE_UAP;
1916 priv->bss_started = 0;
1917 priv->bss_num = 0;
1918 priv->bss_mode = type;
1919
197f4a2e
SP		 1920 break;
1921 case NL80211_IFTYPE_P2P_CLIENT:
1922 priv = adapter->priv[MWIFIEX_BSS_TYPE_P2P];
1923
1924 if (priv->bss_mode) {
1925 wiphy_err(wiphy, "Can't create multiple P2P ifaces");
1926 return ERR_PTR(-EINVAL);
1927 }
1928
1929 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
1930 if (!wdev)
1931 return ERR_PTR(-ENOMEM);
1932
1933 priv->wdev = wdev;
1934 wdev->wiphy = wiphy;
1935
1936 /* At start-up, wpa_supplicant tries to change the interface
1937 * to NL80211_IFTYPE_STATION if it is not managed mode.
1938 * So, we initialize it to STA mode.
1939 */
1940 wdev->iftype = NL80211_IFTYPE_STATION;
1941 priv->bss_mode = NL80211_IFTYPE_STATION;
1942
1943 /* Setting bss_type to P2P tells firmware that this interface
1944 * is receiving P2P peers found during find phase and doing
1945 * action frame handshake.
1946 */
1947 priv->bss_type = MWIFIEX_BSS_TYPE_P2P;
1948
1949 priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
1950 priv->bss_priority = MWIFIEX_BSS_ROLE_STA;
1951 priv->bss_role = MWIFIEX_BSS_ROLE_STA;
1952 priv->bss_started = 0;
1953 priv->bss_num = 0;
1954
93a1df48
YAP		 1955 break;
1956 default:
1957 wiphy_err(wiphy, "type not supported\n");
858faa57 1958 return ERR_PTR(-EINVAL);
93a1df48
YAP		 1959 }
1960
1961 dev = alloc_netdev_mq(sizeof(struct mwifiex_private *), name,
1962 ether_setup, 1);
1963 if (!dev) {
1964 wiphy_err(wiphy, "no memory available for netdevice\n");
858faa57
BZ		 1965 priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
1966 return ERR_PTR(-ENOMEM);
93a1df48
YAP		 1967 }
1968
d6bffe8b
AP		 1969 mwifiex_init_priv_params(priv, dev);
1970 priv->netdev = dev;
1971
1972 mwifiex_setup_ht_caps(&wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap, priv);
1973
1974 if (adapter->config_bands & BAND_A)
1975 mwifiex_setup_ht_caps(
1976 &wiphy->bands[IEEE80211_BAND_5GHZ]->ht_cap, priv);
1977
93a1df48
YAP		 1978 dev_net_set(dev, wiphy_net(wiphy));
1979 dev->ieee80211_ptr = priv->wdev;
1980 dev->ieee80211_ptr->iftype = priv->bss_mode;
1981 memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN);
1982 memcpy(dev->perm_addr, wiphy->perm_addr, ETH_ALEN);
1983 SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
1984
1985 dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
1986 dev->watchdog_timeo = MWIFIEX_DEFAULT_WATCHDOG_TIMEOUT;
1987 dev->hard_header_len += MWIFIEX_MIN_DATA_HEADER_LEN;
1988
1989 mdev_priv = netdev_priv(dev);
1990 *((unsigned long *) mdev_priv) = (unsigned long) priv;
1991
93a1df48
YAP		 1992 SET_NETDEV_DEV(dev, adapter->dev);
1993
1994 /* Register network device */
1995 if (register_netdevice(dev)) {
1996 wiphy_err(wiphy, "cannot register virtual network device\n");
858faa57
BZ		 1997 free_netdev(dev);
1998 priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
1999 return ERR_PTR(-EFAULT);
93a1df48
YAP		 2000 }
2001
2002 sema_init(&priv->async_sem, 1);
2003 priv->scan_pending_on_block = false;
2004
2005 dev_dbg(adapter->dev, "info: %s: Marvell 802.11 Adapter\n", dev->name);
2006
2007#ifdef CONFIG_DEBUG_FS
2008 mwifiex_dev_debugfs_init(priv);
2009#endif
84efbb84 2010 return wdev;
93a1df48
YAP		 2011}
2012EXPORT_SYMBOL_GPL(mwifiex_add_virtual_intf);
2013
2014/*
2015 * del_virtual_intf: remove the virtual interface determined by dev
2016 */
84efbb84 2017int mwifiex_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
93a1df48 2018{
84efbb84 2019 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
93a1df48
YAP		 2020
2021#ifdef CONFIG_DEBUG_FS
2022 mwifiex_dev_debugfs_remove(priv);
2023#endif
2024
2025 if (!netif_queue_stopped(priv->netdev))
2026 netif_stop_queue(priv->netdev);
2027
2028 if (netif_carrier_ok(priv->netdev))
2029 netif_carrier_off(priv->netdev);
2030
84efbb84
JB		 2031 if (wdev->netdev->reg_state == NETREG_REGISTERED)
2032 unregister_netdevice(wdev->netdev);
93a1df48 2033
84efbb84
JB		 2034 if (wdev->netdev->reg_state == NETREG_UNREGISTERED)
2035 free_netdev(wdev->netdev);
93a1df48
YAP		 2036
2037 /* Clear the priv in adapter */
2038 priv->netdev = NULL;
2039
2040 priv->media_connected = false;
2041
93a1df48
YAP		 2042 priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
2043
2044 return 0;
2045}
2046EXPORT_SYMBOL_GPL(mwifiex_del_virtual_intf);
2047
5e6e3a92
BZ		 2048/* station cfg80211 operations */
2049static struct cfg80211_ops mwifiex_cfg80211_ops = {
93a1df48
YAP		 2050 .add_virtual_intf = mwifiex_add_virtual_intf,
2051 .del_virtual_intf = mwifiex_del_virtual_intf,
5e6e3a92
BZ		 2052 .change_virtual_intf = mwifiex_cfg80211_change_virtual_intf,
2053 .scan = mwifiex_cfg80211_scan,
2054 .connect = mwifiex_cfg80211_connect,
2055 .disconnect = mwifiex_cfg80211_disconnect,
2056 .get_station = mwifiex_cfg80211_get_station,
f85aae6b 2057 .dump_station = mwifiex_cfg80211_dump_station,
5e6e3a92 2058 .set_wiphy_params = mwifiex_cfg80211_set_wiphy_params,
5e6e3a92
BZ		 2059 .join_ibss = mwifiex_cfg80211_join_ibss,
2060 .leave_ibss = mwifiex_cfg80211_leave_ibss,
2061 .add_key = mwifiex_cfg80211_add_key,
2062 .del_key = mwifiex_cfg80211_del_key,
e39faa73 2063 .mgmt_tx = mwifiex_cfg80211_mgmt_tx,
3cec6870 2064 .mgmt_frame_register = mwifiex_cfg80211_mgmt_frame_register,
7feb4c48
SP		 2065 .remain_on_channel = mwifiex_cfg80211_remain_on_channel,
2066 .cancel_remain_on_channel = mwifiex_cfg80211_cancel_remain_on_channel,
5e6e3a92
BZ		 2067 .set_default_key = mwifiex_cfg80211_set_default_key,
2068 .set_power_mgmt = mwifiex_cfg80211_set_power_mgmt,
2069 .set_tx_power = mwifiex_cfg80211_set_tx_power,
5d82c53a 2070 .set_bitrate_mask = mwifiex_cfg80211_set_bitrate_mask,
12190c5d
AP		 2071 .start_ap = mwifiex_cfg80211_start_ap,
2072 .stop_ap = mwifiex_cfg80211_stop_ap,
5370c836 2073 .change_beacon = mwifiex_cfg80211_change_beacon,
fa444bf8 2074 .set_cqm_rssi_config = mwifiex_cfg80211_set_cqm_rssi_config,
8a279d5b 2075 .set_antenna = mwifiex_cfg80211_set_antenna,
5e6e3a92
BZ		 2076};
2077
2078/*
2079 * This function registers the device with CFG802.11 subsystem.
2080 *
2081 * The function creates the wireless device/wiphy, populates it with
2082 * default parameters and handler function pointers, and finally
2083 * registers the device.
2084 */
d6bffe8b
AP		 2085
2086int mwifiex_register_cfg80211(struct mwifiex_adapter *adapter)
5e6e3a92 2087{
270e58e8
YAP		 2088 int ret;
2089 void *wdev_priv;
d6bffe8b
AP		 2090 struct wiphy *wiphy;
2091 struct mwifiex_private *priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
9e04a7c6 2092 u8 *country_code;
5e6e3a92 2093
d6bffe8b
AP		 2094 /* create a new wiphy for use with cfg80211 */
2095 wiphy = wiphy_new(&mwifiex_cfg80211_ops,
2096 sizeof(struct mwifiex_adapter *));
2097 if (!wiphy) {
2098 dev_err(adapter->dev, "%s: creating new wiphy\n", __func__);
5e6e3a92
BZ		 2099 return -ENOMEM;
2100 }
d6bffe8b
AP		 2101 wiphy->max_scan_ssids = MWIFIEX_MAX_SSID_LIST_LENGTH;
2102 wiphy->max_scan_ie_len = MWIFIEX_MAX_VSIE_LEN;
83719be8 2103 wiphy->mgmt_stypes = mwifiex_mgmt_stypes;
7feb4c48 2104 wiphy->max_remain_on_channel_duration = 5000;
d6bffe8b
AP		 2105 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2106 BIT(NL80211_IFTYPE_ADHOC) |
197f4a2e
SP		 2107 BIT(NL80211_IFTYPE_P2P_CLIENT) |
2108 BIT(NL80211_IFTYPE_P2P_GO) |
d6bffe8b
AP		 2109 BIT(NL80211_IFTYPE_AP);
2110
2111 wiphy->bands[IEEE80211_BAND_2GHZ] = &mwifiex_band_2ghz;
2112 if (adapter->config_bands & BAND_A)
2113 wiphy->bands[IEEE80211_BAND_5GHZ] = &mwifiex_band_5ghz;
2114 else
2115 wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
5e6e3a92 2116
cd8440da
AP		 2117 wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta;
2118 wiphy->n_iface_combinations = 1;
2119
5e6e3a92 2120 /* Initialize cipher suits */
d6bffe8b
AP		 2121 wiphy->cipher_suites = mwifiex_cipher_suites;
2122 wiphy->n_cipher_suites = ARRAY_SIZE(mwifiex_cipher_suites);
5e6e3a92 2123
d6bffe8b
AP		 2124 memcpy(wiphy->perm_addr, priv->curr_addr, ETH_ALEN);
2125 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2dd2bd6b 2126 wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME |
cc0ba0d5 2127 WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD |
7feb4c48
SP		 2128 WIPHY_FLAG_CUSTOM_REGULATORY |
2129 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
cc0ba0d5
AK		 2130
2131 wiphy_apply_custom_regulatory(wiphy, &mwifiex_world_regdom_custom);
2dd2bd6b
AP		 2132
2133 wiphy->probe_resp_offload = NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
e39faa73
SP		 2134 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
2135 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
5e6e3a92 2136
8a279d5b
AK		 2137 wiphy->available_antennas_tx = BIT(adapter->number_of_antenna) - 1;
2138 wiphy->available_antennas_rx = BIT(adapter->number_of_antenna) - 1;
5e6e3a92 2139
05910f4a
AK		 2140 wiphy->features = NL80211_FEATURE_HT_IBSS;
2141
b5abcf02 2142 /* Reserve space for mwifiex specific private data for BSS */
d6bffe8b 2143 wiphy->bss_priv_size = sizeof(struct mwifiex_bss_priv);
5116f3ce 2144
d6bffe8b 2145 wiphy->reg_notifier = mwifiex_reg_notifier;
5e6e3a92 2146
67fdf39e 2147 /* Set struct mwifiex_adapter pointer in wiphy_priv */
d6bffe8b 2148 wdev_priv = wiphy_priv(wiphy);
67fdf39e 2149 *(unsigned long *)wdev_priv = (unsigned long)adapter;
5e6e3a92 2150
2c208890 2151 set_wiphy_dev(wiphy, priv->adapter->dev);
a7b21165 2152
d6bffe8b 2153 ret = wiphy_register(wiphy);
5e6e3a92 2154 if (ret < 0) {
d6bffe8b
AP		 2155 dev_err(adapter->dev,
2156 "%s: wiphy_register failed: %d\n", __func__, ret);
2157 wiphy_free(wiphy);
5e6e3a92 2158 return ret;
5e6e3a92 2159 }
9e04a7c6 2160 country_code = mwifiex_11d_code_2_region(priv->adapter->region_code);
77c8a14b
BZ		 2161 if (country_code)
2162 dev_info(adapter->dev,
2163 "ignoring F/W country code %2.2s\n", country_code);
5e6e3a92 2164
d6bffe8b 2165 adapter->wiphy = wiphy;
5e6e3a92
BZ		 2166 return ret;
2167}
Linux kernel - Deliverables
This page took 0.299588 seconds and 5 git commands to generate.