This source file includes following definitions.
- check_vif_up
- nl80211_band_to_fwil
- chandef_to_chanspec
- channel_to_chanspec
- brcmf_parse_tlvs
- brcmf_tlv_has_ie
- brcmf_find_wpaie
- brcmf_find_wpsie
- brcmf_vif_change_validate
- brcmf_vif_add_validate
- convert_key_from_CPU
- send_key_to_dongle
- brcmf_cfg80211_update_proto_addr_mode
- brcmf_get_first_free_bsscfgidx
- brcmf_cfg80211_request_ap_if
- brcmf_ap_add_vif
- brcmf_is_apmode
- brcmf_is_ibssmode
- brcmf_cfg80211_add_iface
- brcmf_scan_config_mpc
- brcmf_set_mpc
- brcmf_notify_escan_complete
- brcmf_cfg80211_del_ap_iface
- brcmf_cfg80211_del_iface
- brcmf_cfg80211_change_iface
- brcmf_escan_prep
- brcmf_run_escan
- brcmf_do_escan
- brcmf_cfg80211_scan
- brcmf_set_rts
- brcmf_set_frag
- brcmf_set_retry
- brcmf_cfg80211_set_wiphy_params
- brcmf_init_prof
- brcmf_map_fw_linkdown_reason
- brcmf_set_pmk
- brcmf_link_down
- brcmf_cfg80211_join_ibss
- brcmf_cfg80211_leave_ibss
- brcmf_set_wpa_version
- brcmf_set_auth_type
- brcmf_set_wsec_mode
- brcmf_set_key_mgmt
- brcmf_set_sharedkey
- brcmf_war_auth_type
- brcmf_set_join_pref
- brcmf_cfg80211_connect
- brcmf_cfg80211_disconnect
- brcmf_cfg80211_set_tx_power
- brcmf_cfg80211_get_tx_power
- brcmf_cfg80211_config_default_key
- brcmf_cfg80211_del_key
- brcmf_cfg80211_add_key
- brcmf_cfg80211_get_key
- brcmf_cfg80211_config_default_mgmt_key
- brcmf_cfg80211_reconfigure_wep
- brcmf_convert_sta_flags
- brcmf_fill_bss_param
- brcmf_cfg80211_get_station_ibss
- brcmf_cfg80211_get_station
- brcmf_cfg80211_dump_station
- brcmf_cfg80211_set_power_mgmt
- brcmf_inform_single_bss
- next_bss_le
- brcmf_inform_bss
- brcmf_inform_ibss
- brcmf_update_bss_info
- brcmf_abort_scanning
- brcmf_cfg80211_escan_timeout_worker
- brcmf_escan_timeout
- brcmf_compare_update_same_bss
- brcmf_cfg80211_escan_handler
- brcmf_init_escan
- brcmf_alloc_internal_escan_request
- brcmf_internal_escan_add_info
- brcmf_start_internal_escan
- brcmf_get_netinfo_array
- brcmf_notify_sched_scan_results
- brcmf_cfg80211_sched_scan_start
- brcmf_cfg80211_sched_scan_stop
- brcmf_delay
- brcmf_config_wowl_pattern
- brcmf_wowl_nd_results
- brcmf_report_wowl_wakeind
- brcmf_report_wowl_wakeind
- brcmf_cfg80211_resume
- brcmf_configure_wowl
- brcmf_cfg80211_suspend
- brcmf_update_pmklist
- brcmf_cfg80211_set_pmksa
- brcmf_cfg80211_del_pmksa
- brcmf_cfg80211_flush_pmksa
- brcmf_configure_opensecurity
- brcmf_valid_wpa_oui
- brcmf_configure_wpaie
- brcmf_parse_vndr_ies
- brcmf_vndr_ie
- brcmf_vif_set_mgmt_ie
- brcmf_vif_clear_mgmt_ies
- brcmf_config_ap_mgmt_ie
- brcmf_cfg80211_start_ap
- brcmf_cfg80211_stop_ap
- brcmf_cfg80211_change_beacon
- brcmf_cfg80211_del_station
- brcmf_cfg80211_change_station
- brcmf_cfg80211_mgmt_frame_register
- brcmf_cfg80211_mgmt_tx
- brcmf_cfg80211_cancel_remain_on_channel
- brcmf_cfg80211_get_channel
- brcmf_cfg80211_crit_proto_start
- brcmf_cfg80211_crit_proto_stop
- brcmf_notify_tdls_peer_event
- brcmf_convert_nl80211_tdls_oper
- brcmf_cfg80211_tdls_oper
- brcmf_cfg80211_update_conn_params
- brcmf_cfg80211_set_rekey_data
- brcmf_cfg80211_set_pmk
- brcmf_cfg80211_del_pmk
- brcmf_cfg80211_get_ops
- brcmf_alloc_vif
- brcmf_free_vif
- brcmf_cfg80211_free_netdev
- brcmf_is_linkup
- brcmf_is_linkdown
- brcmf_is_nonetwork
- brcmf_clear_assoc_ies
- brcmf_get_assoc_ies
- brcmf_bss_roaming_done
- brcmf_bss_connect_done
- brcmf_notify_connect_status_ap
- brcmf_notify_connect_status
- brcmf_notify_roaming_status
- brcmf_notify_mic_status
- brcmf_notify_vif_event
- brcmf_init_conf
- brcmf_register_event_handlers
- brcmf_deinit_priv_mem
- brcmf_init_priv_mem
- wl_init_priv
- wl_deinit_priv
- init_vif_event
- brcmf_dongle_roam
- brcmf_dongle_scantime
- brcmf_update_bw40_channel_flag
- brcmf_construct_chaninfo
- brcmf_enable_bw40_2g
- brcmf_get_bwcap
- brcmf_update_ht_cap
- brcmf_get_mcs_map
- brcmf_update_vht_cap
- brcmf_setup_wiphybands
- brcmf_setup_ifmodes
- brcmf_wiphy_wowl_params
- brcmf_setup_wiphy
- brcmf_config_dongle
- __brcmf_cfg80211_up
- __brcmf_cfg80211_down
- brcmf_cfg80211_up
- brcmf_cfg80211_down
- brcmf_cfg80211_get_iftype
- brcmf_get_vif_state_any
- vif_event_equals
- brcmf_cfg80211_arm_vif_event
- brcmf_cfg80211_vif_event_armed
- brcmf_cfg80211_wait_vif_event
- brcmf_translate_country_code
- brcmf_cfg80211_reg_notifier
- brcmf_free_wiphy
- brcmf_cfg80211_attach
- brcmf_cfg80211_detach
1
2
3
4
5
6
7
8 #include <linux/kernel.h>
9 #include <linux/etherdevice.h>
10 #include <linux/module.h>
11 #include <linux/vmalloc.h>
12 #include <net/cfg80211.h>
13 #include <net/netlink.h>
14
15 #include <brcmu_utils.h>
16 #include <defs.h>
17 #include <brcmu_wifi.h>
18 #include "core.h"
19 #include "debug.h"
20 #include "tracepoint.h"
21 #include "fwil_types.h"
22 #include "p2p.h"
23 #include "btcoex.h"
24 #include "pno.h"
25 #include "cfg80211.h"
26 #include "feature.h"
27 #include "fwil.h"
28 #include "proto.h"
29 #include "vendor.h"
30 #include "bus.h"
31 #include "common.h"
32
33 #define BRCMF_SCAN_IE_LEN_MAX 2048
34
35 #define WPA_OUI "\x00\x50\xF2"
36 #define WPA_OUI_TYPE 1
37 #define RSN_OUI "\x00\x0F\xAC"
38 #define WME_OUI_TYPE 2
39 #define WPS_OUI_TYPE 4
40
41 #define VS_IE_FIXED_HDR_LEN 6
42 #define WPA_IE_VERSION_LEN 2
43 #define WPA_IE_MIN_OUI_LEN 4
44 #define WPA_IE_SUITE_COUNT_LEN 2
45
46 #define WPA_CIPHER_NONE 0
47 #define WPA_CIPHER_WEP_40 1
48 #define WPA_CIPHER_TKIP 2
49 #define WPA_CIPHER_AES_CCM 4
50 #define WPA_CIPHER_WEP_104 5
51
52 #define RSN_AKM_NONE 0
53 #define RSN_AKM_UNSPECIFIED 1
54 #define RSN_AKM_PSK 2
55 #define RSN_AKM_SHA256_1X 5
56 #define RSN_AKM_SHA256_PSK 6
57 #define RSN_CAP_LEN 2
58 #define RSN_CAP_PTK_REPLAY_CNTR_MASK (BIT(2) | BIT(3))
59 #define RSN_CAP_MFPR_MASK BIT(6)
60 #define RSN_CAP_MFPC_MASK BIT(7)
61 #define RSN_PMKID_COUNT_LEN 2
62
63 #define VNDR_IE_CMD_LEN 4
64
65
66 #define VNDR_IE_COUNT_OFFSET 4
67 #define VNDR_IE_PKTFLAG_OFFSET 8
68 #define VNDR_IE_VSIE_OFFSET 12
69 #define VNDR_IE_HDR_SIZE 12
70 #define VNDR_IE_PARSE_LIMIT 5
71
72 #define DOT11_MGMT_HDR_LEN 24
73 #define DOT11_BCN_PRB_FIXED_LEN 12
74
75 #define BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS 320
76 #define BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS 400
77 #define BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS 20
78
79 #define BRCMF_SCAN_CHANNEL_TIME 40
80 #define BRCMF_SCAN_UNASSOC_TIME 40
81 #define BRCMF_SCAN_PASSIVE_TIME 120
82
83 #define BRCMF_ND_INFO_TIMEOUT msecs_to_jiffies(2000)
84
85 #define BRCMF_ASSOC_PARAMS_FIXED_SIZE \
86 (sizeof(struct brcmf_assoc_params_le) - sizeof(u16))
87
88 static bool check_vif_up(struct brcmf_cfg80211_vif *vif)
89 {
90 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state)) {
91 brcmf_dbg(INFO, "device is not ready : status (%lu)\n",
92 vif->sme_state);
93 return false;
94 }
95 return true;
96 }
97
98 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
99 #define RATETAB_ENT(_rateid, _flags) \
100 { \
101 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
102 .hw_value = (_rateid), \
103 .flags = (_flags), \
104 }
105
106 static struct ieee80211_rate __wl_rates[] = {
107 RATETAB_ENT(BRCM_RATE_1M, 0),
108 RATETAB_ENT(BRCM_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
109 RATETAB_ENT(BRCM_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
110 RATETAB_ENT(BRCM_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
111 RATETAB_ENT(BRCM_RATE_6M, 0),
112 RATETAB_ENT(BRCM_RATE_9M, 0),
113 RATETAB_ENT(BRCM_RATE_12M, 0),
114 RATETAB_ENT(BRCM_RATE_18M, 0),
115 RATETAB_ENT(BRCM_RATE_24M, 0),
116 RATETAB_ENT(BRCM_RATE_36M, 0),
117 RATETAB_ENT(BRCM_RATE_48M, 0),
118 RATETAB_ENT(BRCM_RATE_54M, 0),
119 };
120
121 #define wl_g_rates (__wl_rates + 0)
122 #define wl_g_rates_size ARRAY_SIZE(__wl_rates)
123 #define wl_a_rates (__wl_rates + 4)
124 #define wl_a_rates_size (wl_g_rates_size - 4)
125
126 #define CHAN2G(_channel, _freq) { \
127 .band = NL80211_BAND_2GHZ, \
128 .center_freq = (_freq), \
129 .hw_value = (_channel), \
130 .max_antenna_gain = 0, \
131 .max_power = 30, \
132 }
133
134 #define CHAN5G(_channel) { \
135 .band = NL80211_BAND_5GHZ, \
136 .center_freq = 5000 + (5 * (_channel)), \
137 .hw_value = (_channel), \
138 .max_antenna_gain = 0, \
139 .max_power = 30, \
140 }
141
142 static struct ieee80211_channel __wl_2ghz_channels[] = {
143 CHAN2G(1, 2412), CHAN2G(2, 2417), CHAN2G(3, 2422), CHAN2G(4, 2427),
144 CHAN2G(5, 2432), CHAN2G(6, 2437), CHAN2G(7, 2442), CHAN2G(8, 2447),
145 CHAN2G(9, 2452), CHAN2G(10, 2457), CHAN2G(11, 2462), CHAN2G(12, 2467),
146 CHAN2G(13, 2472), CHAN2G(14, 2484)
147 };
148
149 static struct ieee80211_channel __wl_5ghz_channels[] = {
150 CHAN5G(34), CHAN5G(36), CHAN5G(38), CHAN5G(40), CHAN5G(42),
151 CHAN5G(44), CHAN5G(46), CHAN5G(48), CHAN5G(52), CHAN5G(56),
152 CHAN5G(60), CHAN5G(64), CHAN5G(100), CHAN5G(104), CHAN5G(108),
153 CHAN5G(112), CHAN5G(116), CHAN5G(120), CHAN5G(124), CHAN5G(128),
154 CHAN5G(132), CHAN5G(136), CHAN5G(140), CHAN5G(144), CHAN5G(149),
155 CHAN5G(153), CHAN5G(157), CHAN5G(161), CHAN5G(165)
156 };
157
158
159
160
161 static const struct ieee80211_supported_band __wl_band_2ghz = {
162 .band = NL80211_BAND_2GHZ,
163 .bitrates = wl_g_rates,
164 .n_bitrates = wl_g_rates_size,
165 };
166
167 static const struct ieee80211_supported_band __wl_band_5ghz = {
168 .band = NL80211_BAND_5GHZ,
169 .bitrates = wl_a_rates,
170 .n_bitrates = wl_a_rates_size,
171 };
172
173
174
175
176
177
178
179
180 static const struct ieee80211_regdomain brcmf_regdom = {
181 .n_reg_rules = 4,
182 .alpha2 = "99",
183 .reg_rules = {
184
185 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
186
187
188
189
190 REG_RULE(2484-10, 2484+10, 20, 6, 20, 0),
191
192 REG_RULE(5150-10, 5350+10, 160, 6, 20, 0),
193
194 REG_RULE(5470-10, 5850+10, 160, 6, 20, 0), }
195 };
196
197
198
199
200
201
202
203 static const u32 brcmf_cipher_suites[] = {
204 WLAN_CIPHER_SUITE_WEP40,
205 WLAN_CIPHER_SUITE_WEP104,
206 WLAN_CIPHER_SUITE_TKIP,
207 WLAN_CIPHER_SUITE_CCMP,
208
209 WLAN_CIPHER_SUITE_AES_CMAC
210 };
211
212
213 struct brcmf_vs_tlv {
214 u8 id;
215 u8 len;
216 u8 oui[3];
217 u8 oui_type;
218 };
219
220 struct parsed_vndr_ie_info {
221 u8 *ie_ptr;
222 u32 ie_len;
223 struct brcmf_vs_tlv vndrie;
224 };
225
226 struct parsed_vndr_ies {
227 u32 count;
228 struct parsed_vndr_ie_info ie_info[VNDR_IE_PARSE_LIMIT];
229 };
230
231 static u8 nl80211_band_to_fwil(enum nl80211_band band)
232 {
233 switch (band) {
234 case NL80211_BAND_2GHZ:
235 return WLC_BAND_2G;
236 case NL80211_BAND_5GHZ:
237 return WLC_BAND_5G;
238 default:
239 WARN_ON(1);
240 break;
241 }
242 return 0;
243 }
244
245 static u16 chandef_to_chanspec(struct brcmu_d11inf *d11inf,
246 struct cfg80211_chan_def *ch)
247 {
248 struct brcmu_chan ch_inf;
249 s32 primary_offset;
250
251 brcmf_dbg(TRACE, "chandef: control %d center %d width %d\n",
252 ch->chan->center_freq, ch->center_freq1, ch->width);
253 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq1);
254 primary_offset = ch->chan->center_freq - ch->center_freq1;
255 switch (ch->width) {
256 case NL80211_CHAN_WIDTH_20:
257 case NL80211_CHAN_WIDTH_20_NOHT:
258 ch_inf.bw = BRCMU_CHAN_BW_20;
259 WARN_ON(primary_offset != 0);
260 break;
261 case NL80211_CHAN_WIDTH_40:
262 ch_inf.bw = BRCMU_CHAN_BW_40;
263 if (primary_offset > 0)
264 ch_inf.sb = BRCMU_CHAN_SB_U;
265 else
266 ch_inf.sb = BRCMU_CHAN_SB_L;
267 break;
268 case NL80211_CHAN_WIDTH_80:
269 ch_inf.bw = BRCMU_CHAN_BW_80;
270 if (primary_offset == -30)
271 ch_inf.sb = BRCMU_CHAN_SB_LL;
272 else if (primary_offset == -10)
273 ch_inf.sb = BRCMU_CHAN_SB_LU;
274 else if (primary_offset == 10)
275 ch_inf.sb = BRCMU_CHAN_SB_UL;
276 else
277 ch_inf.sb = BRCMU_CHAN_SB_UU;
278 break;
279 case NL80211_CHAN_WIDTH_160:
280 ch_inf.bw = BRCMU_CHAN_BW_160;
281 if (primary_offset == -70)
282 ch_inf.sb = BRCMU_CHAN_SB_LLL;
283 else if (primary_offset == -50)
284 ch_inf.sb = BRCMU_CHAN_SB_LLU;
285 else if (primary_offset == -30)
286 ch_inf.sb = BRCMU_CHAN_SB_LUL;
287 else if (primary_offset == -10)
288 ch_inf.sb = BRCMU_CHAN_SB_LUU;
289 else if (primary_offset == 10)
290 ch_inf.sb = BRCMU_CHAN_SB_ULL;
291 else if (primary_offset == 30)
292 ch_inf.sb = BRCMU_CHAN_SB_ULU;
293 else if (primary_offset == 50)
294 ch_inf.sb = BRCMU_CHAN_SB_UUL;
295 else
296 ch_inf.sb = BRCMU_CHAN_SB_UUU;
297 break;
298 case NL80211_CHAN_WIDTH_80P80:
299 case NL80211_CHAN_WIDTH_5:
300 case NL80211_CHAN_WIDTH_10:
301 default:
302 WARN_ON_ONCE(1);
303 }
304 switch (ch->chan->band) {
305 case NL80211_BAND_2GHZ:
306 ch_inf.band = BRCMU_CHAN_BAND_2G;
307 break;
308 case NL80211_BAND_5GHZ:
309 ch_inf.band = BRCMU_CHAN_BAND_5G;
310 break;
311 case NL80211_BAND_60GHZ:
312 default:
313 WARN_ON_ONCE(1);
314 }
315 d11inf->encchspec(&ch_inf);
316
317 brcmf_dbg(TRACE, "chanspec: 0x%x\n", ch_inf.chspec);
318 return ch_inf.chspec;
319 }
320
321 u16 channel_to_chanspec(struct brcmu_d11inf *d11inf,
322 struct ieee80211_channel *ch)
323 {
324 struct brcmu_chan ch_inf;
325
326 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq);
327 ch_inf.bw = BRCMU_CHAN_BW_20;
328 d11inf->encchspec(&ch_inf);
329
330 return ch_inf.chspec;
331 }
332
333
334
335
336
337 static const struct brcmf_tlv *
338 brcmf_parse_tlvs(const void *buf, int buflen, uint key)
339 {
340 const struct brcmf_tlv *elt = buf;
341 int totlen = buflen;
342
343
344 while (totlen >= TLV_HDR_LEN) {
345 int len = elt->len;
346
347
348 if ((elt->id == key) && (totlen >= (len + TLV_HDR_LEN)))
349 return elt;
350
351 elt = (struct brcmf_tlv *)((u8 *)elt + (len + TLV_HDR_LEN));
352 totlen -= (len + TLV_HDR_LEN);
353 }
354
355 return NULL;
356 }
357
358
359
360
361 static bool
362 brcmf_tlv_has_ie(const u8 *ie, const u8 **tlvs, u32 *tlvs_len,
363 const u8 *oui, u32 oui_len, u8 type)
364 {
365
366 if (ie[TLV_LEN_OFF] >= oui_len + 1 &&
367 !memcmp(&ie[TLV_BODY_OFF], oui, oui_len) &&
368 type == ie[TLV_BODY_OFF + oui_len]) {
369 return true;
370 }
371
372 if (tlvs == NULL)
373 return false;
374
375 ie += ie[TLV_LEN_OFF] + TLV_HDR_LEN;
376
377 *tlvs_len -= (int)(ie - *tlvs);
378
379 *tlvs = ie;
380
381 return false;
382 }
383
384 static struct brcmf_vs_tlv *
385 brcmf_find_wpaie(const u8 *parse, u32 len)
386 {
387 const struct brcmf_tlv *ie;
388
389 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
390 if (brcmf_tlv_has_ie((const u8 *)ie, &parse, &len,
391 WPA_OUI, TLV_OUI_LEN, WPA_OUI_TYPE))
392 return (struct brcmf_vs_tlv *)ie;
393 }
394 return NULL;
395 }
396
397 static struct brcmf_vs_tlv *
398 brcmf_find_wpsie(const u8 *parse, u32 len)
399 {
400 const struct brcmf_tlv *ie;
401
402 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
403 if (brcmf_tlv_has_ie((u8 *)ie, &parse, &len,
404 WPA_OUI, TLV_OUI_LEN, WPS_OUI_TYPE))
405 return (struct brcmf_vs_tlv *)ie;
406 }
407 return NULL;
408 }
409
410 static int brcmf_vif_change_validate(struct brcmf_cfg80211_info *cfg,
411 struct brcmf_cfg80211_vif *vif,
412 enum nl80211_iftype new_type)
413 {
414 struct brcmf_cfg80211_vif *pos;
415 bool check_combos = false;
416 int ret = 0;
417 struct iface_combination_params params = {
418 .num_different_channels = 1,
419 };
420
421 list_for_each_entry(pos, &cfg->vif_list, list)
422 if (pos == vif) {
423 params.iftype_num[new_type]++;
424 } else {
425
426 check_combos = true;
427 params.iftype_num[pos->wdev.iftype]++;
428 }
429
430 if (check_combos)
431 ret = cfg80211_check_combinations(cfg->wiphy, ¶ms);
432
433 return ret;
434 }
435
436 static int brcmf_vif_add_validate(struct brcmf_cfg80211_info *cfg,
437 enum nl80211_iftype new_type)
438 {
439 struct brcmf_cfg80211_vif *pos;
440 struct iface_combination_params params = {
441 .num_different_channels = 1,
442 };
443
444 list_for_each_entry(pos, &cfg->vif_list, list)
445 params.iftype_num[pos->wdev.iftype]++;
446
447 params.iftype_num[new_type]++;
448 return cfg80211_check_combinations(cfg->wiphy, ¶ms);
449 }
450
451 static void convert_key_from_CPU(struct brcmf_wsec_key *key,
452 struct brcmf_wsec_key_le *key_le)
453 {
454 key_le->index = cpu_to_le32(key->index);
455 key_le->len = cpu_to_le32(key->len);
456 key_le->algo = cpu_to_le32(key->algo);
457 key_le->flags = cpu_to_le32(key->flags);
458 key_le->rxiv.hi = cpu_to_le32(key->rxiv.hi);
459 key_le->rxiv.lo = cpu_to_le16(key->rxiv.lo);
460 key_le->iv_initialized = cpu_to_le32(key->iv_initialized);
461 memcpy(key_le->data, key->data, sizeof(key->data));
462 memcpy(key_le->ea, key->ea, sizeof(key->ea));
463 }
464
465 static int
466 send_key_to_dongle(struct brcmf_if *ifp, struct brcmf_wsec_key *key)
467 {
468 struct brcmf_pub *drvr = ifp->drvr;
469 int err;
470 struct brcmf_wsec_key_le key_le;
471
472 convert_key_from_CPU(key, &key_le);
473
474 brcmf_netdev_wait_pend8021x(ifp);
475
476 err = brcmf_fil_bsscfg_data_set(ifp, "wsec_key", &key_le,
477 sizeof(key_le));
478
479 if (err)
480 bphy_err(drvr, "wsec_key error (%d)\n", err);
481 return err;
482 }
483
484 static void
485 brcmf_cfg80211_update_proto_addr_mode(struct wireless_dev *wdev)
486 {
487 struct brcmf_cfg80211_vif *vif;
488 struct brcmf_if *ifp;
489
490 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
491 ifp = vif->ifp;
492
493 if ((wdev->iftype == NL80211_IFTYPE_ADHOC) ||
494 (wdev->iftype == NL80211_IFTYPE_AP) ||
495 (wdev->iftype == NL80211_IFTYPE_P2P_GO))
496 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx,
497 ADDR_DIRECT);
498 else
499 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx,
500 ADDR_INDIRECT);
501 }
502
503 static int brcmf_get_first_free_bsscfgidx(struct brcmf_pub *drvr)
504 {
505 int bsscfgidx;
506
507 for (bsscfgidx = 0; bsscfgidx < BRCMF_MAX_IFS; bsscfgidx++) {
508
509 if (bsscfgidx == 1)
510 continue;
511 if (!drvr->iflist[bsscfgidx])
512 return bsscfgidx;
513 }
514
515 return -ENOMEM;
516 }
517
518 static int brcmf_cfg80211_request_ap_if(struct brcmf_if *ifp)
519 {
520 struct brcmf_pub *drvr = ifp->drvr;
521 struct brcmf_mbss_ssid_le mbss_ssid_le;
522 int bsscfgidx;
523 int err;
524
525 memset(&mbss_ssid_le, 0, sizeof(mbss_ssid_le));
526 bsscfgidx = brcmf_get_first_free_bsscfgidx(ifp->drvr);
527 if (bsscfgidx < 0)
528 return bsscfgidx;
529
530 mbss_ssid_le.bsscfgidx = cpu_to_le32(bsscfgidx);
531 mbss_ssid_le.SSID_len = cpu_to_le32(5);
532 sprintf(mbss_ssid_le.SSID, "ssid%d" , bsscfgidx);
533
534 err = brcmf_fil_bsscfg_data_set(ifp, "bsscfg:ssid", &mbss_ssid_le,
535 sizeof(mbss_ssid_le));
536 if (err < 0)
537 bphy_err(drvr, "setting ssid failed %d\n", err);
538
539 return err;
540 }
541
542
543
544
545
546
547
548
549 static
550 struct wireless_dev *brcmf_ap_add_vif(struct wiphy *wiphy, const char *name,
551 struct vif_params *params)
552 {
553 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
554 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
555 struct brcmf_pub *drvr = cfg->pub;
556 struct brcmf_cfg80211_vif *vif;
557 int err;
558
559 if (brcmf_cfg80211_vif_event_armed(cfg))
560 return ERR_PTR(-EBUSY);
561
562 brcmf_dbg(INFO, "Adding vif \"%s\"\n", name);
563
564 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_AP);
565 if (IS_ERR(vif))
566 return (struct wireless_dev *)vif;
567
568 brcmf_cfg80211_arm_vif_event(cfg, vif);
569
570 err = brcmf_cfg80211_request_ap_if(ifp);
571 if (err) {
572 brcmf_cfg80211_arm_vif_event(cfg, NULL);
573 goto fail;
574 }
575
576
577 err = brcmf_cfg80211_wait_vif_event(cfg, BRCMF_E_IF_ADD,
578 BRCMF_VIF_EVENT_TIMEOUT);
579 brcmf_cfg80211_arm_vif_event(cfg, NULL);
580 if (!err) {
581 bphy_err(drvr, "timeout occurred\n");
582 err = -EIO;
583 goto fail;
584 }
585
586
587 ifp = vif->ifp;
588 if (!ifp) {
589 bphy_err(drvr, "no if pointer provided\n");
590 err = -ENOENT;
591 goto fail;
592 }
593
594 strncpy(ifp->ndev->name, name, sizeof(ifp->ndev->name) - 1);
595 err = brcmf_net_attach(ifp, true);
596 if (err) {
597 bphy_err(drvr, "Registering netdevice failed\n");
598 free_netdev(ifp->ndev);
599 goto fail;
600 }
601
602 return &ifp->vif->wdev;
603
604 fail:
605 brcmf_free_vif(vif);
606 return ERR_PTR(err);
607 }
608
609 static bool brcmf_is_apmode(struct brcmf_cfg80211_vif *vif)
610 {
611 enum nl80211_iftype iftype;
612
613 iftype = vif->wdev.iftype;
614 return iftype == NL80211_IFTYPE_AP || iftype == NL80211_IFTYPE_P2P_GO;
615 }
616
617 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_vif *vif)
618 {
619 return vif->wdev.iftype == NL80211_IFTYPE_ADHOC;
620 }
621
622 static struct wireless_dev *brcmf_cfg80211_add_iface(struct wiphy *wiphy,
623 const char *name,
624 unsigned char name_assign_type,
625 enum nl80211_iftype type,
626 struct vif_params *params)
627 {
628 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
629 struct brcmf_pub *drvr = cfg->pub;
630 struct wireless_dev *wdev;
631 int err;
632
633 brcmf_dbg(TRACE, "enter: %s type %d\n", name, type);
634 err = brcmf_vif_add_validate(wiphy_to_cfg(wiphy), type);
635 if (err) {
636 bphy_err(drvr, "iface validation failed: err=%d\n", err);
637 return ERR_PTR(err);
638 }
639 switch (type) {
640 case NL80211_IFTYPE_ADHOC:
641 case NL80211_IFTYPE_STATION:
642 case NL80211_IFTYPE_AP_VLAN:
643 case NL80211_IFTYPE_WDS:
644 case NL80211_IFTYPE_MONITOR:
645 case NL80211_IFTYPE_MESH_POINT:
646 return ERR_PTR(-EOPNOTSUPP);
647 case NL80211_IFTYPE_AP:
648 wdev = brcmf_ap_add_vif(wiphy, name, params);
649 break;
650 case NL80211_IFTYPE_P2P_CLIENT:
651 case NL80211_IFTYPE_P2P_GO:
652 case NL80211_IFTYPE_P2P_DEVICE:
653 wdev = brcmf_p2p_add_vif(wiphy, name, name_assign_type, type, params);
654 break;
655 case NL80211_IFTYPE_UNSPECIFIED:
656 default:
657 return ERR_PTR(-EINVAL);
658 }
659
660 if (IS_ERR(wdev))
661 bphy_err(drvr, "add iface %s type %d failed: err=%d\n", name,
662 type, (int)PTR_ERR(wdev));
663 else
664 brcmf_cfg80211_update_proto_addr_mode(wdev);
665
666 return wdev;
667 }
668
669 static void brcmf_scan_config_mpc(struct brcmf_if *ifp, int mpc)
670 {
671 if (brcmf_feat_is_quirk_enabled(ifp, BRCMF_FEAT_QUIRK_NEED_MPC))
672 brcmf_set_mpc(ifp, mpc);
673 }
674
675 void brcmf_set_mpc(struct brcmf_if *ifp, int mpc)
676 {
677 struct brcmf_pub *drvr = ifp->drvr;
678 s32 err = 0;
679
680 if (check_vif_up(ifp->vif)) {
681 err = brcmf_fil_iovar_int_set(ifp, "mpc", mpc);
682 if (err) {
683 bphy_err(drvr, "fail to set mpc\n");
684 return;
685 }
686 brcmf_dbg(INFO, "MPC : %d\n", mpc);
687 }
688 }
689
690 s32 brcmf_notify_escan_complete(struct brcmf_cfg80211_info *cfg,
691 struct brcmf_if *ifp, bool aborted,
692 bool fw_abort)
693 {
694 struct brcmf_pub *drvr = cfg->pub;
695 struct brcmf_scan_params_le params_le;
696 struct cfg80211_scan_request *scan_request;
697 u64 reqid;
698 u32 bucket;
699 s32 err = 0;
700
701 brcmf_dbg(SCAN, "Enter\n");
702
703
704
705 scan_request = cfg->scan_request;
706 cfg->scan_request = NULL;
707
708 if (timer_pending(&cfg->escan_timeout))
709 del_timer_sync(&cfg->escan_timeout);
710
711 if (fw_abort) {
712
713 brcmf_dbg(SCAN, "ABORT scan in firmware\n");
714 memset(¶ms_le, 0, sizeof(params_le));
715 eth_broadcast_addr(params_le.bssid);
716 params_le.bss_type = DOT11_BSSTYPE_ANY;
717 params_le.scan_type = 0;
718 params_le.channel_num = cpu_to_le32(1);
719 params_le.nprobes = cpu_to_le32(1);
720 params_le.active_time = cpu_to_le32(-1);
721 params_le.passive_time = cpu_to_le32(-1);
722 params_le.home_time = cpu_to_le32(-1);
723
724 params_le.channel_list[0] = cpu_to_le16(-1);
725
726 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN,
727 ¶ms_le, sizeof(params_le));
728 if (err)
729 bphy_err(drvr, "Scan abort failed\n");
730 }
731
732 brcmf_scan_config_mpc(ifp, 1);
733
734
735
736
737
738 if (cfg->int_escan_map) {
739 brcmf_dbg(SCAN, "scheduled scan completed (%x)\n",
740 cfg->int_escan_map);
741 while (cfg->int_escan_map) {
742 bucket = __ffs(cfg->int_escan_map);
743 cfg->int_escan_map &= ~BIT(bucket);
744 reqid = brcmf_pno_find_reqid_by_bucket(cfg->pno,
745 bucket);
746 if (!aborted) {
747 brcmf_dbg(SCAN, "report results: reqid=%llu\n",
748 reqid);
749 cfg80211_sched_scan_results(cfg_to_wiphy(cfg),
750 reqid);
751 }
752 }
753 } else if (scan_request) {
754 struct cfg80211_scan_info info = {
755 .aborted = aborted,
756 };
757
758 brcmf_dbg(SCAN, "ESCAN Completed scan: %s\n",
759 aborted ? "Aborted" : "Done");
760 cfg80211_scan_done(scan_request, &info);
761 }
762 if (!test_and_clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
763 brcmf_dbg(SCAN, "Scan complete, probably P2P scan\n");
764
765 return err;
766 }
767
768 static int brcmf_cfg80211_del_ap_iface(struct wiphy *wiphy,
769 struct wireless_dev *wdev)
770 {
771 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
772 struct net_device *ndev = wdev->netdev;
773 struct brcmf_if *ifp = netdev_priv(ndev);
774 struct brcmf_pub *drvr = cfg->pub;
775 int ret;
776 int err;
777
778 brcmf_cfg80211_arm_vif_event(cfg, ifp->vif);
779
780 err = brcmf_fil_bsscfg_data_set(ifp, "interface_remove", NULL, 0);
781 if (err) {
782 bphy_err(drvr, "interface_remove failed %d\n", err);
783 goto err_unarm;
784 }
785
786
787 ret = brcmf_cfg80211_wait_vif_event(cfg, BRCMF_E_IF_DEL,
788 BRCMF_VIF_EVENT_TIMEOUT);
789 if (!ret) {
790 bphy_err(drvr, "timeout occurred\n");
791 err = -EIO;
792 goto err_unarm;
793 }
794
795 brcmf_remove_interface(ifp, true);
796
797 err_unarm:
798 brcmf_cfg80211_arm_vif_event(cfg, NULL);
799 return err;
800 }
801
802 static
803 int brcmf_cfg80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev)
804 {
805 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
806 struct net_device *ndev = wdev->netdev;
807
808 if (ndev && ndev == cfg_to_ndev(cfg))
809 return -ENOTSUPP;
810
811
812 if (brcmf_cfg80211_vif_event_armed(cfg))
813 return -EBUSY;
814
815 if (ndev) {
816 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status) &&
817 cfg->escan_info.ifp == netdev_priv(ndev))
818 brcmf_notify_escan_complete(cfg, netdev_priv(ndev),
819 true, true);
820
821 brcmf_fil_iovar_int_set(netdev_priv(ndev), "mpc", 1);
822 }
823
824 switch (wdev->iftype) {
825 case NL80211_IFTYPE_ADHOC:
826 case NL80211_IFTYPE_STATION:
827 case NL80211_IFTYPE_AP_VLAN:
828 case NL80211_IFTYPE_WDS:
829 case NL80211_IFTYPE_MONITOR:
830 case NL80211_IFTYPE_MESH_POINT:
831 return -EOPNOTSUPP;
832 case NL80211_IFTYPE_AP:
833 return brcmf_cfg80211_del_ap_iface(wiphy, wdev);
834 case NL80211_IFTYPE_P2P_CLIENT:
835 case NL80211_IFTYPE_P2P_GO:
836 case NL80211_IFTYPE_P2P_DEVICE:
837 return brcmf_p2p_del_vif(wiphy, wdev);
838 case NL80211_IFTYPE_UNSPECIFIED:
839 default:
840 return -EINVAL;
841 }
842 return -EOPNOTSUPP;
843 }
844
845 static s32
846 brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
847 enum nl80211_iftype type,
848 struct vif_params *params)
849 {
850 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
851 struct brcmf_if *ifp = netdev_priv(ndev);
852 struct brcmf_cfg80211_vif *vif = ifp->vif;
853 struct brcmf_pub *drvr = cfg->pub;
854 s32 infra = 0;
855 s32 ap = 0;
856 s32 err = 0;
857
858 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, type=%d\n", ifp->bsscfgidx,
859 type);
860
861
862
863
864
865
866
867
868
869 if ((type == NL80211_IFTYPE_STATION) &&
870 ((vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) ||
871 (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) ||
872 (vif->wdev.iftype == NL80211_IFTYPE_P2P_DEVICE))) {
873 brcmf_dbg(TRACE, "Ignoring cmd for p2p if\n");
874
875
876
877
878
879
880
881
882
883
884
885
886 if (cfg->p2p.p2pdev_dynamically)
887 return -EOPNOTSUPP;
888 else
889 return 0;
890 }
891 err = brcmf_vif_change_validate(wiphy_to_cfg(wiphy), vif, type);
892 if (err) {
893 bphy_err(drvr, "iface validation failed: err=%d\n", err);
894 return err;
895 }
896 switch (type) {
897 case NL80211_IFTYPE_MONITOR:
898 case NL80211_IFTYPE_WDS:
899 bphy_err(drvr, "type (%d) : currently we do not support this type\n",
900 type);
901 return -EOPNOTSUPP;
902 case NL80211_IFTYPE_ADHOC:
903 infra = 0;
904 break;
905 case NL80211_IFTYPE_STATION:
906 infra = 1;
907 break;
908 case NL80211_IFTYPE_AP:
909 case NL80211_IFTYPE_P2P_GO:
910 ap = 1;
911 break;
912 default:
913 err = -EINVAL;
914 goto done;
915 }
916
917 if (ap) {
918 if (type == NL80211_IFTYPE_P2P_GO) {
919 brcmf_dbg(INFO, "IF Type = P2P GO\n");
920 err = brcmf_p2p_ifchange(cfg, BRCMF_FIL_P2P_IF_GO);
921 }
922 if (!err) {
923 brcmf_dbg(INFO, "IF Type = AP\n");
924 }
925 } else {
926 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, infra);
927 if (err) {
928 bphy_err(drvr, "WLC_SET_INFRA error (%d)\n", err);
929 err = -EAGAIN;
930 goto done;
931 }
932 brcmf_dbg(INFO, "IF Type = %s\n", brcmf_is_ibssmode(vif) ?
933 "Adhoc" : "Infra");
934 }
935 ndev->ieee80211_ptr->iftype = type;
936
937 brcmf_cfg80211_update_proto_addr_mode(&vif->wdev);
938
939 done:
940 brcmf_dbg(TRACE, "Exit\n");
941
942 return err;
943 }
944
945 static void brcmf_escan_prep(struct brcmf_cfg80211_info *cfg,
946 struct brcmf_scan_params_le *params_le,
947 struct cfg80211_scan_request *request)
948 {
949 u32 n_ssids;
950 u32 n_channels;
951 s32 i;
952 s32 offset;
953 u16 chanspec;
954 char *ptr;
955 struct brcmf_ssid_le ssid_le;
956
957 eth_broadcast_addr(params_le->bssid);
958 params_le->bss_type = DOT11_BSSTYPE_ANY;
959 params_le->scan_type = BRCMF_SCANTYPE_ACTIVE;
960 params_le->channel_num = 0;
961 params_le->nprobes = cpu_to_le32(-1);
962 params_le->active_time = cpu_to_le32(-1);
963 params_le->passive_time = cpu_to_le32(-1);
964 params_le->home_time = cpu_to_le32(-1);
965 memset(¶ms_le->ssid_le, 0, sizeof(params_le->ssid_le));
966
967 n_ssids = request->n_ssids;
968 n_channels = request->n_channels;
969
970
971 brcmf_dbg(SCAN, "### List of channelspecs to scan ### %d\n",
972 n_channels);
973 if (n_channels > 0) {
974 for (i = 0; i < n_channels; i++) {
975 chanspec = channel_to_chanspec(&cfg->d11inf,
976 request->channels[i]);
977 brcmf_dbg(SCAN, "Chan : %d, Channel spec: %x\n",
978 request->channels[i]->hw_value, chanspec);
979 params_le->channel_list[i] = cpu_to_le16(chanspec);
980 }
981 } else {
982 brcmf_dbg(SCAN, "Scanning all channels\n");
983 }
984
985 brcmf_dbg(SCAN, "### List of SSIDs to scan ### %d\n", n_ssids);
986 if (n_ssids > 0) {
987 offset = offsetof(struct brcmf_scan_params_le, channel_list) +
988 n_channels * sizeof(u16);
989 offset = roundup(offset, sizeof(u32));
990 ptr = (char *)params_le + offset;
991 for (i = 0; i < n_ssids; i++) {
992 memset(&ssid_le, 0, sizeof(ssid_le));
993 ssid_le.SSID_len =
994 cpu_to_le32(request->ssids[i].ssid_len);
995 memcpy(ssid_le.SSID, request->ssids[i].ssid,
996 request->ssids[i].ssid_len);
997 if (!ssid_le.SSID_len)
998 brcmf_dbg(SCAN, "%d: Broadcast scan\n", i);
999 else
1000 brcmf_dbg(SCAN, "%d: scan for %.32s size=%d\n",
1001 i, ssid_le.SSID, ssid_le.SSID_len);
1002 memcpy(ptr, &ssid_le, sizeof(ssid_le));
1003 ptr += sizeof(ssid_le);
1004 }
1005 } else {
1006 brcmf_dbg(SCAN, "Performing passive scan\n");
1007 params_le->scan_type = BRCMF_SCANTYPE_PASSIVE;
1008 }
1009
1010 params_le->channel_num =
1011 cpu_to_le32((n_ssids << BRCMF_SCAN_PARAMS_NSSID_SHIFT) |
1012 (n_channels & BRCMF_SCAN_PARAMS_COUNT_MASK));
1013 }
1014
1015 static s32
1016 brcmf_run_escan(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp,
1017 struct cfg80211_scan_request *request)
1018 {
1019 struct brcmf_pub *drvr = cfg->pub;
1020 s32 params_size = BRCMF_SCAN_PARAMS_FIXED_SIZE +
1021 offsetof(struct brcmf_escan_params_le, params_le);
1022 struct brcmf_escan_params_le *params;
1023 s32 err = 0;
1024
1025 brcmf_dbg(SCAN, "E-SCAN START\n");
1026
1027 if (request != NULL) {
1028
1029 params_size += sizeof(u32) * ((request->n_channels + 1) / 2);
1030
1031
1032 params_size += sizeof(struct brcmf_ssid_le) * request->n_ssids;
1033 }
1034
1035 params = kzalloc(params_size, GFP_KERNEL);
1036 if (!params) {
1037 err = -ENOMEM;
1038 goto exit;
1039 }
1040 BUG_ON(params_size + sizeof("escan") >= BRCMF_DCMD_MEDLEN);
1041 brcmf_escan_prep(cfg, ¶ms->params_le, request);
1042 params->version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION);
1043 params->action = cpu_to_le16(WL_ESCAN_ACTION_START);
1044 params->sync_id = cpu_to_le16(0x1234);
1045
1046 err = brcmf_fil_iovar_data_set(ifp, "escan", params, params_size);
1047 if (err) {
1048 if (err == -EBUSY)
1049 brcmf_dbg(INFO, "system busy : escan canceled\n");
1050 else
1051 bphy_err(drvr, "error (%d)\n", err);
1052 }
1053
1054 kfree(params);
1055 exit:
1056 return err;
1057 }
1058
1059 static s32
1060 brcmf_do_escan(struct brcmf_if *ifp, struct cfg80211_scan_request *request)
1061 {
1062 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
1063 s32 err;
1064 struct brcmf_scan_results *results;
1065 struct escan_info *escan = &cfg->escan_info;
1066
1067 brcmf_dbg(SCAN, "Enter\n");
1068 escan->ifp = ifp;
1069 escan->wiphy = cfg->wiphy;
1070 escan->escan_state = WL_ESCAN_STATE_SCANNING;
1071
1072 brcmf_scan_config_mpc(ifp, 0);
1073 results = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
1074 results->version = 0;
1075 results->count = 0;
1076 results->buflen = WL_ESCAN_RESULTS_FIXED_SIZE;
1077
1078 err = escan->run(cfg, ifp, request);
1079 if (err)
1080 brcmf_scan_config_mpc(ifp, 1);
1081 return err;
1082 }
1083
1084 static s32
1085 brcmf_cfg80211_scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
1086 {
1087 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1088 struct brcmf_pub *drvr = cfg->pub;
1089 struct brcmf_cfg80211_vif *vif;
1090 s32 err = 0;
1091
1092 brcmf_dbg(TRACE, "Enter\n");
1093 vif = container_of(request->wdev, struct brcmf_cfg80211_vif, wdev);
1094 if (!check_vif_up(vif))
1095 return -EIO;
1096
1097 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
1098 bphy_err(drvr, "Scanning already: status (%lu)\n",
1099 cfg->scan_status);
1100 return -EAGAIN;
1101 }
1102 if (test_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status)) {
1103 bphy_err(drvr, "Scanning being aborted: status (%lu)\n",
1104 cfg->scan_status);
1105 return -EAGAIN;
1106 }
1107 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
1108 bphy_err(drvr, "Scanning suppressed: status (%lu)\n",
1109 cfg->scan_status);
1110 return -EAGAIN;
1111 }
1112 if (test_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state)) {
1113 bphy_err(drvr, "Connecting: status (%lu)\n", vif->sme_state);
1114 return -EAGAIN;
1115 }
1116
1117
1118 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
1119 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
1120
1121 brcmf_dbg(SCAN, "START ESCAN\n");
1122
1123 cfg->scan_request = request;
1124 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
1125
1126 cfg->escan_info.run = brcmf_run_escan;
1127 err = brcmf_p2p_scan_prep(wiphy, request, vif);
1128 if (err)
1129 goto scan_out;
1130
1131 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_PRBREQ_FLAG,
1132 request->ie, request->ie_len);
1133 if (err)
1134 goto scan_out;
1135
1136 err = brcmf_do_escan(vif->ifp, request);
1137 if (err)
1138 goto scan_out;
1139
1140
1141 mod_timer(&cfg->escan_timeout,
1142 jiffies + msecs_to_jiffies(BRCMF_ESCAN_TIMER_INTERVAL_MS));
1143
1144 return 0;
1145
1146 scan_out:
1147 bphy_err(drvr, "scan error (%d)\n", err);
1148 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
1149 cfg->scan_request = NULL;
1150 return err;
1151 }
1152
1153 static s32 brcmf_set_rts(struct net_device *ndev, u32 rts_threshold)
1154 {
1155 struct brcmf_if *ifp = netdev_priv(ndev);
1156 struct brcmf_pub *drvr = ifp->drvr;
1157 s32 err = 0;
1158
1159 err = brcmf_fil_iovar_int_set(ifp, "rtsthresh", rts_threshold);
1160 if (err)
1161 bphy_err(drvr, "Error (%d)\n", err);
1162
1163 return err;
1164 }
1165
1166 static s32 brcmf_set_frag(struct net_device *ndev, u32 frag_threshold)
1167 {
1168 struct brcmf_if *ifp = netdev_priv(ndev);
1169 struct brcmf_pub *drvr = ifp->drvr;
1170 s32 err = 0;
1171
1172 err = brcmf_fil_iovar_int_set(ifp, "fragthresh",
1173 frag_threshold);
1174 if (err)
1175 bphy_err(drvr, "Error (%d)\n", err);
1176
1177 return err;
1178 }
1179
1180 static s32 brcmf_set_retry(struct net_device *ndev, u32 retry, bool l)
1181 {
1182 struct brcmf_if *ifp = netdev_priv(ndev);
1183 struct brcmf_pub *drvr = ifp->drvr;
1184 s32 err = 0;
1185 u32 cmd = (l ? BRCMF_C_SET_LRL : BRCMF_C_SET_SRL);
1186
1187 err = brcmf_fil_cmd_int_set(ifp, cmd, retry);
1188 if (err) {
1189 bphy_err(drvr, "cmd (%d) , error (%d)\n", cmd, err);
1190 return err;
1191 }
1192 return err;
1193 }
1194
1195 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1196 {
1197 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1198 struct net_device *ndev = cfg_to_ndev(cfg);
1199 struct brcmf_if *ifp = netdev_priv(ndev);
1200 s32 err = 0;
1201
1202 brcmf_dbg(TRACE, "Enter\n");
1203 if (!check_vif_up(ifp->vif))
1204 return -EIO;
1205
1206 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
1207 (cfg->conf->rts_threshold != wiphy->rts_threshold)) {
1208 cfg->conf->rts_threshold = wiphy->rts_threshold;
1209 err = brcmf_set_rts(ndev, cfg->conf->rts_threshold);
1210 if (!err)
1211 goto done;
1212 }
1213 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
1214 (cfg->conf->frag_threshold != wiphy->frag_threshold)) {
1215 cfg->conf->frag_threshold = wiphy->frag_threshold;
1216 err = brcmf_set_frag(ndev, cfg->conf->frag_threshold);
1217 if (!err)
1218 goto done;
1219 }
1220 if (changed & WIPHY_PARAM_RETRY_LONG
1221 && (cfg->conf->retry_long != wiphy->retry_long)) {
1222 cfg->conf->retry_long = wiphy->retry_long;
1223 err = brcmf_set_retry(ndev, cfg->conf->retry_long, true);
1224 if (!err)
1225 goto done;
1226 }
1227 if (changed & WIPHY_PARAM_RETRY_SHORT
1228 && (cfg->conf->retry_short != wiphy->retry_short)) {
1229 cfg->conf->retry_short = wiphy->retry_short;
1230 err = brcmf_set_retry(ndev, cfg->conf->retry_short, false);
1231 if (!err)
1232 goto done;
1233 }
1234
1235 done:
1236 brcmf_dbg(TRACE, "Exit\n");
1237 return err;
1238 }
1239
1240 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
1241 {
1242 memset(prof, 0, sizeof(*prof));
1243 }
1244
1245 static u16 brcmf_map_fw_linkdown_reason(const struct brcmf_event_msg *e)
1246 {
1247 u16 reason;
1248
1249 switch (e->event_code) {
1250 case BRCMF_E_DEAUTH:
1251 case BRCMF_E_DEAUTH_IND:
1252 case BRCMF_E_DISASSOC_IND:
1253 reason = e->reason;
1254 break;
1255 case BRCMF_E_LINK:
1256 default:
1257 reason = 0;
1258 break;
1259 }
1260 return reason;
1261 }
1262
1263 static int brcmf_set_pmk(struct brcmf_if *ifp, const u8 *pmk_data, u16 pmk_len)
1264 {
1265 struct brcmf_pub *drvr = ifp->drvr;
1266 struct brcmf_wsec_pmk_le pmk;
1267 int i, err;
1268
1269
1270 pmk.key_len = cpu_to_le16(pmk_len << 1);
1271 pmk.flags = cpu_to_le16(BRCMF_WSEC_PASSPHRASE);
1272 for (i = 0; i < pmk_len; i++)
1273 snprintf(&pmk.key[2 * i], 3, "%02x", pmk_data[i]);
1274
1275
1276 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_WSEC_PMK,
1277 &pmk, sizeof(pmk));
1278 if (err < 0)
1279 bphy_err(drvr, "failed to change PSK in firmware (len=%u)\n",
1280 pmk_len);
1281
1282 return err;
1283 }
1284
1285 static void brcmf_link_down(struct brcmf_cfg80211_vif *vif, u16 reason)
1286 {
1287 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(vif->wdev.wiphy);
1288 struct brcmf_pub *drvr = cfg->pub;
1289 bool bus_up = drvr->bus_if->state == BRCMF_BUS_UP;
1290 s32 err = 0;
1291
1292 brcmf_dbg(TRACE, "Enter\n");
1293
1294 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTED, &vif->sme_state)) {
1295 if (bus_up) {
1296 brcmf_dbg(INFO, "Call WLC_DISASSOC to stop excess roaming\n");
1297 err = brcmf_fil_cmd_data_set(vif->ifp,
1298 BRCMF_C_DISASSOC, NULL, 0);
1299 if (err)
1300 bphy_err(drvr, "WLC_DISASSOC failed (%d)\n",
1301 err);
1302 }
1303
1304 if ((vif->wdev.iftype == NL80211_IFTYPE_STATION) ||
1305 (vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT))
1306 cfg80211_disconnected(vif->wdev.netdev, reason, NULL, 0,
1307 true, GFP_KERNEL);
1308 }
1309 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state);
1310 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
1311 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
1312 if (vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_NONE) {
1313 if (bus_up)
1314 brcmf_set_pmk(vif->ifp, NULL, 0);
1315 vif->profile.use_fwsup = BRCMF_PROFILE_FWSUP_NONE;
1316 }
1317 brcmf_dbg(TRACE, "Exit\n");
1318 }
1319
1320 static s32
1321 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
1322 struct cfg80211_ibss_params *params)
1323 {
1324 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1325 struct brcmf_if *ifp = netdev_priv(ndev);
1326 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1327 struct brcmf_pub *drvr = cfg->pub;
1328 struct brcmf_join_params join_params;
1329 size_t join_params_size = 0;
1330 s32 err = 0;
1331 s32 wsec = 0;
1332 s32 bcnprd;
1333 u16 chanspec;
1334 u32 ssid_len;
1335
1336 brcmf_dbg(TRACE, "Enter\n");
1337 if (!check_vif_up(ifp->vif))
1338 return -EIO;
1339
1340 if (params->ssid)
1341 brcmf_dbg(CONN, "SSID: %s\n", params->ssid);
1342 else {
1343 brcmf_dbg(CONN, "SSID: NULL, Not supported\n");
1344 return -EOPNOTSUPP;
1345 }
1346
1347 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1348
1349 if (params->bssid)
1350 brcmf_dbg(CONN, "BSSID: %pM\n", params->bssid);
1351 else
1352 brcmf_dbg(CONN, "No BSSID specified\n");
1353
1354 if (params->chandef.chan)
1355 brcmf_dbg(CONN, "channel: %d\n",
1356 params->chandef.chan->center_freq);
1357 else
1358 brcmf_dbg(CONN, "no channel specified\n");
1359
1360 if (params->channel_fixed)
1361 brcmf_dbg(CONN, "fixed channel required\n");
1362 else
1363 brcmf_dbg(CONN, "no fixed channel required\n");
1364
1365 if (params->ie && params->ie_len)
1366 brcmf_dbg(CONN, "ie len: %d\n", params->ie_len);
1367 else
1368 brcmf_dbg(CONN, "no ie specified\n");
1369
1370 if (params->beacon_interval)
1371 brcmf_dbg(CONN, "beacon interval: %d\n",
1372 params->beacon_interval);
1373 else
1374 brcmf_dbg(CONN, "no beacon interval specified\n");
1375
1376 if (params->basic_rates)
1377 brcmf_dbg(CONN, "basic rates: %08X\n", params->basic_rates);
1378 else
1379 brcmf_dbg(CONN, "no basic rates specified\n");
1380
1381 if (params->privacy)
1382 brcmf_dbg(CONN, "privacy required\n");
1383 else
1384 brcmf_dbg(CONN, "no privacy required\n");
1385
1386
1387 if (params->privacy)
1388 wsec |= WEP_ENABLED;
1389
1390 err = brcmf_fil_iovar_int_set(ifp, "wsec", wsec);
1391 if (err) {
1392 bphy_err(drvr, "wsec failed (%d)\n", err);
1393 goto done;
1394 }
1395
1396
1397 if (params->beacon_interval)
1398 bcnprd = params->beacon_interval;
1399 else
1400 bcnprd = 100;
1401
1402 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD, bcnprd);
1403 if (err) {
1404 bphy_err(drvr, "WLC_SET_BCNPRD failed (%d)\n", err);
1405 goto done;
1406 }
1407
1408
1409 memset(&join_params, 0, sizeof(struct brcmf_join_params));
1410
1411
1412 ssid_len = min_t(u32, params->ssid_len, IEEE80211_MAX_SSID_LEN);
1413 memcpy(join_params.ssid_le.SSID, params->ssid, ssid_len);
1414 join_params.ssid_le.SSID_len = cpu_to_le32(ssid_len);
1415 join_params_size = sizeof(join_params.ssid_le);
1416
1417
1418 if (params->bssid) {
1419 memcpy(join_params.params_le.bssid, params->bssid, ETH_ALEN);
1420 join_params_size += BRCMF_ASSOC_PARAMS_FIXED_SIZE;
1421 memcpy(profile->bssid, params->bssid, ETH_ALEN);
1422 } else {
1423 eth_broadcast_addr(join_params.params_le.bssid);
1424 eth_zero_addr(profile->bssid);
1425 }
1426
1427
1428 if (params->chandef.chan) {
1429 u32 target_channel;
1430
1431 cfg->channel =
1432 ieee80211_frequency_to_channel(
1433 params->chandef.chan->center_freq);
1434 if (params->channel_fixed) {
1435
1436 chanspec = chandef_to_chanspec(&cfg->d11inf,
1437 ¶ms->chandef);
1438 join_params.params_le.chanspec_list[0] =
1439 cpu_to_le16(chanspec);
1440 join_params.params_le.chanspec_num = cpu_to_le32(1);
1441 join_params_size += sizeof(join_params.params_le);
1442 }
1443
1444
1445 target_channel = cfg->channel;
1446 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_CHANNEL,
1447 target_channel);
1448 if (err) {
1449 bphy_err(drvr, "WLC_SET_CHANNEL failed (%d)\n", err);
1450 goto done;
1451 }
1452 } else
1453 cfg->channel = 0;
1454
1455 cfg->ibss_starter = false;
1456
1457
1458 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
1459 &join_params, join_params_size);
1460 if (err) {
1461 bphy_err(drvr, "WLC_SET_SSID failed (%d)\n", err);
1462 goto done;
1463 }
1464
1465 done:
1466 if (err)
1467 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1468 brcmf_dbg(TRACE, "Exit\n");
1469 return err;
1470 }
1471
1472 static s32
1473 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
1474 {
1475 struct brcmf_if *ifp = netdev_priv(ndev);
1476
1477 brcmf_dbg(TRACE, "Enter\n");
1478 if (!check_vif_up(ifp->vif)) {
1479
1480
1481
1482
1483 return 0;
1484 }
1485
1486 brcmf_link_down(ifp->vif, WLAN_REASON_DEAUTH_LEAVING);
1487 brcmf_net_setcarrier(ifp, false);
1488
1489 brcmf_dbg(TRACE, "Exit\n");
1490
1491 return 0;
1492 }
1493
1494 static s32 brcmf_set_wpa_version(struct net_device *ndev,
1495 struct cfg80211_connect_params *sme)
1496 {
1497 struct brcmf_if *ifp = netdev_priv(ndev);
1498 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1499 struct brcmf_pub *drvr = ifp->drvr;
1500 struct brcmf_cfg80211_security *sec;
1501 s32 val = 0;
1502 s32 err = 0;
1503
1504 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1505 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1506 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1507 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1508 else
1509 val = WPA_AUTH_DISABLED;
1510 brcmf_dbg(CONN, "setting wpa_auth to 0x%0x\n", val);
1511 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", val);
1512 if (err) {
1513 bphy_err(drvr, "set wpa_auth failed (%d)\n", err);
1514 return err;
1515 }
1516 sec = &profile->sec;
1517 sec->wpa_versions = sme->crypto.wpa_versions;
1518 return err;
1519 }
1520
1521 static s32 brcmf_set_auth_type(struct net_device *ndev,
1522 struct cfg80211_connect_params *sme)
1523 {
1524 struct brcmf_if *ifp = netdev_priv(ndev);
1525 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1526 struct brcmf_pub *drvr = ifp->drvr;
1527 struct brcmf_cfg80211_security *sec;
1528 s32 val = 0;
1529 s32 err = 0;
1530
1531 switch (sme->auth_type) {
1532 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1533 val = 0;
1534 brcmf_dbg(CONN, "open system\n");
1535 break;
1536 case NL80211_AUTHTYPE_SHARED_KEY:
1537 val = 1;
1538 brcmf_dbg(CONN, "shared key\n");
1539 break;
1540 default:
1541 val = 2;
1542 brcmf_dbg(CONN, "automatic, auth type (%d)\n", sme->auth_type);
1543 break;
1544 }
1545
1546 err = brcmf_fil_bsscfg_int_set(ifp, "auth", val);
1547 if (err) {
1548 bphy_err(drvr, "set auth failed (%d)\n", err);
1549 return err;
1550 }
1551 sec = &profile->sec;
1552 sec->auth_type = sme->auth_type;
1553 return err;
1554 }
1555
1556 static s32
1557 brcmf_set_wsec_mode(struct net_device *ndev,
1558 struct cfg80211_connect_params *sme)
1559 {
1560 struct brcmf_if *ifp = netdev_priv(ndev);
1561 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1562 struct brcmf_pub *drvr = ifp->drvr;
1563 struct brcmf_cfg80211_security *sec;
1564 s32 pval = 0;
1565 s32 gval = 0;
1566 s32 wsec;
1567 s32 err = 0;
1568
1569 if (sme->crypto.n_ciphers_pairwise) {
1570 switch (sme->crypto.ciphers_pairwise[0]) {
1571 case WLAN_CIPHER_SUITE_WEP40:
1572 case WLAN_CIPHER_SUITE_WEP104:
1573 pval = WEP_ENABLED;
1574 break;
1575 case WLAN_CIPHER_SUITE_TKIP:
1576 pval = TKIP_ENABLED;
1577 break;
1578 case WLAN_CIPHER_SUITE_CCMP:
1579 pval = AES_ENABLED;
1580 break;
1581 case WLAN_CIPHER_SUITE_AES_CMAC:
1582 pval = AES_ENABLED;
1583 break;
1584 default:
1585 bphy_err(drvr, "invalid cipher pairwise (%d)\n",
1586 sme->crypto.ciphers_pairwise[0]);
1587 return -EINVAL;
1588 }
1589 }
1590 if (sme->crypto.cipher_group) {
1591 switch (sme->crypto.cipher_group) {
1592 case WLAN_CIPHER_SUITE_WEP40:
1593 case WLAN_CIPHER_SUITE_WEP104:
1594 gval = WEP_ENABLED;
1595 break;
1596 case WLAN_CIPHER_SUITE_TKIP:
1597 gval = TKIP_ENABLED;
1598 break;
1599 case WLAN_CIPHER_SUITE_CCMP:
1600 gval = AES_ENABLED;
1601 break;
1602 case WLAN_CIPHER_SUITE_AES_CMAC:
1603 gval = AES_ENABLED;
1604 break;
1605 default:
1606 bphy_err(drvr, "invalid cipher group (%d)\n",
1607 sme->crypto.cipher_group);
1608 return -EINVAL;
1609 }
1610 }
1611
1612 brcmf_dbg(CONN, "pval (%d) gval (%d)\n", pval, gval);
1613
1614
1615 if (brcmf_find_wpsie(sme->ie, sme->ie_len) && !pval && !gval &&
1616 sme->privacy)
1617 pval = AES_ENABLED;
1618
1619 wsec = pval | gval;
1620 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
1621 if (err) {
1622 bphy_err(drvr, "error (%d)\n", err);
1623 return err;
1624 }
1625
1626 sec = &profile->sec;
1627 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1628 sec->cipher_group = sme->crypto.cipher_group;
1629
1630 return err;
1631 }
1632
1633 static s32
1634 brcmf_set_key_mgmt(struct net_device *ndev, struct cfg80211_connect_params *sme)
1635 {
1636 struct brcmf_if *ifp = netdev_priv(ndev);
1637 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1638 struct brcmf_pub *drvr = ifp->drvr;
1639 s32 val;
1640 s32 err;
1641 const struct brcmf_tlv *rsn_ie;
1642 const u8 *ie;
1643 u32 ie_len;
1644 u32 offset;
1645 u16 rsn_cap;
1646 u32 mfp;
1647 u16 count;
1648
1649 profile->use_fwsup = BRCMF_PROFILE_FWSUP_NONE;
1650
1651 if (!sme->crypto.n_akm_suites)
1652 return 0;
1653
1654 err = brcmf_fil_bsscfg_int_get(netdev_priv(ndev), "wpa_auth", &val);
1655 if (err) {
1656 bphy_err(drvr, "could not get wpa_auth (%d)\n", err);
1657 return err;
1658 }
1659 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1660 switch (sme->crypto.akm_suites[0]) {
1661 case WLAN_AKM_SUITE_8021X:
1662 val = WPA_AUTH_UNSPECIFIED;
1663 if (sme->want_1x)
1664 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X;
1665 break;
1666 case WLAN_AKM_SUITE_PSK:
1667 val = WPA_AUTH_PSK;
1668 break;
1669 default:
1670 bphy_err(drvr, "invalid cipher group (%d)\n",
1671 sme->crypto.cipher_group);
1672 return -EINVAL;
1673 }
1674 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1675 switch (sme->crypto.akm_suites[0]) {
1676 case WLAN_AKM_SUITE_8021X:
1677 val = WPA2_AUTH_UNSPECIFIED;
1678 if (sme->want_1x)
1679 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X;
1680 break;
1681 case WLAN_AKM_SUITE_8021X_SHA256:
1682 val = WPA2_AUTH_1X_SHA256;
1683 if (sme->want_1x)
1684 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X;
1685 break;
1686 case WLAN_AKM_SUITE_PSK_SHA256:
1687 val = WPA2_AUTH_PSK_SHA256;
1688 break;
1689 case WLAN_AKM_SUITE_PSK:
1690 val = WPA2_AUTH_PSK;
1691 break;
1692 case WLAN_AKM_SUITE_FT_8021X:
1693 val = WPA2_AUTH_UNSPECIFIED | WPA2_AUTH_FT;
1694 if (sme->want_1x)
1695 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X;
1696 break;
1697 case WLAN_AKM_SUITE_FT_PSK:
1698 val = WPA2_AUTH_PSK | WPA2_AUTH_FT;
1699 break;
1700 default:
1701 bphy_err(drvr, "invalid cipher group (%d)\n",
1702 sme->crypto.cipher_group);
1703 return -EINVAL;
1704 }
1705 }
1706
1707 if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_1X)
1708 brcmf_dbg(INFO, "using 1X offload\n");
1709
1710 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP))
1711 goto skip_mfp_config;
1712
1713
1714
1715 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie, sme->ie_len,
1716 WLAN_EID_RSN);
1717 if (!rsn_ie)
1718 goto skip_mfp_config;
1719 ie = (const u8 *)rsn_ie;
1720 ie_len = rsn_ie->len + TLV_HDR_LEN;
1721
1722 offset = TLV_HDR_LEN + WPA_IE_VERSION_LEN + WPA_IE_MIN_OUI_LEN;
1723 if (offset + WPA_IE_SUITE_COUNT_LEN >= ie_len)
1724 goto skip_mfp_config;
1725
1726 count = ie[offset] + (ie[offset + 1] << 8);
1727 offset += WPA_IE_SUITE_COUNT_LEN + (count * WPA_IE_MIN_OUI_LEN);
1728 if (offset + WPA_IE_SUITE_COUNT_LEN >= ie_len)
1729 goto skip_mfp_config;
1730
1731 count = ie[offset] + (ie[offset + 1] << 8);
1732 offset += WPA_IE_SUITE_COUNT_LEN + (count * WPA_IE_MIN_OUI_LEN);
1733 if (offset + WPA_IE_SUITE_COUNT_LEN > ie_len)
1734 goto skip_mfp_config;
1735
1736 mfp = BRCMF_MFP_NONE;
1737 rsn_cap = ie[offset] + (ie[offset + 1] << 8);
1738 if (rsn_cap & RSN_CAP_MFPR_MASK)
1739 mfp = BRCMF_MFP_REQUIRED;
1740 else if (rsn_cap & RSN_CAP_MFPC_MASK)
1741 mfp = BRCMF_MFP_CAPABLE;
1742 brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "mfp", mfp);
1743
1744 skip_mfp_config:
1745 brcmf_dbg(CONN, "setting wpa_auth to %d\n", val);
1746 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "wpa_auth", val);
1747 if (err) {
1748 bphy_err(drvr, "could not set wpa_auth (%d)\n", err);
1749 return err;
1750 }
1751
1752 return err;
1753 }
1754
1755 static s32
1756 brcmf_set_sharedkey(struct net_device *ndev,
1757 struct cfg80211_connect_params *sme)
1758 {
1759 struct brcmf_if *ifp = netdev_priv(ndev);
1760 struct brcmf_pub *drvr = ifp->drvr;
1761 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1762 struct brcmf_cfg80211_security *sec;
1763 struct brcmf_wsec_key key;
1764 s32 val;
1765 s32 err = 0;
1766
1767 brcmf_dbg(CONN, "key len (%d)\n", sme->key_len);
1768
1769 if (sme->key_len == 0)
1770 return 0;
1771
1772 sec = &profile->sec;
1773 brcmf_dbg(CONN, "wpa_versions 0x%x cipher_pairwise 0x%x\n",
1774 sec->wpa_versions, sec->cipher_pairwise);
1775
1776 if (sec->wpa_versions & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2))
1777 return 0;
1778
1779 if (!(sec->cipher_pairwise &
1780 (WLAN_CIPHER_SUITE_WEP40 | WLAN_CIPHER_SUITE_WEP104)))
1781 return 0;
1782
1783 memset(&key, 0, sizeof(key));
1784 key.len = (u32) sme->key_len;
1785 key.index = (u32) sme->key_idx;
1786 if (key.len > sizeof(key.data)) {
1787 bphy_err(drvr, "Too long key length (%u)\n", key.len);
1788 return -EINVAL;
1789 }
1790 memcpy(key.data, sme->key, key.len);
1791 key.flags = BRCMF_PRIMARY_KEY;
1792 switch (sec->cipher_pairwise) {
1793 case WLAN_CIPHER_SUITE_WEP40:
1794 key.algo = CRYPTO_ALGO_WEP1;
1795 break;
1796 case WLAN_CIPHER_SUITE_WEP104:
1797 key.algo = CRYPTO_ALGO_WEP128;
1798 break;
1799 default:
1800 bphy_err(drvr, "Invalid algorithm (%d)\n",
1801 sme->crypto.ciphers_pairwise[0]);
1802 return -EINVAL;
1803 }
1804
1805 brcmf_dbg(CONN, "key length (%d) key index (%d) algo (%d)\n",
1806 key.len, key.index, key.algo);
1807 brcmf_dbg(CONN, "key \"%s\"\n", key.data);
1808 err = send_key_to_dongle(ifp, &key);
1809 if (err)
1810 return err;
1811
1812 if (sec->auth_type == NL80211_AUTHTYPE_SHARED_KEY) {
1813 brcmf_dbg(CONN, "set auth_type to shared key\n");
1814 val = WL_AUTH_SHARED_KEY;
1815 err = brcmf_fil_bsscfg_int_set(ifp, "auth", val);
1816 if (err)
1817 bphy_err(drvr, "set auth failed (%d)\n", err);
1818 }
1819 return err;
1820 }
1821
1822 static
1823 enum nl80211_auth_type brcmf_war_auth_type(struct brcmf_if *ifp,
1824 enum nl80211_auth_type type)
1825 {
1826 if (type == NL80211_AUTHTYPE_AUTOMATIC &&
1827 brcmf_feat_is_quirk_enabled(ifp, BRCMF_FEAT_QUIRK_AUTO_AUTH)) {
1828 brcmf_dbg(CONN, "WAR: use OPEN instead of AUTO\n");
1829 type = NL80211_AUTHTYPE_OPEN_SYSTEM;
1830 }
1831 return type;
1832 }
1833
1834 static void brcmf_set_join_pref(struct brcmf_if *ifp,
1835 struct cfg80211_bss_selection *bss_select)
1836 {
1837 struct brcmf_pub *drvr = ifp->drvr;
1838 struct brcmf_join_pref_params join_pref_params[2];
1839 enum nl80211_band band;
1840 int err, i = 0;
1841
1842 join_pref_params[i].len = 2;
1843 join_pref_params[i].rssi_gain = 0;
1844
1845 if (bss_select->behaviour != NL80211_BSS_SELECT_ATTR_BAND_PREF)
1846 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_ASSOC_PREFER, WLC_BAND_AUTO);
1847
1848 switch (bss_select->behaviour) {
1849 case __NL80211_BSS_SELECT_ATTR_INVALID:
1850 brcmf_c_set_joinpref_default(ifp);
1851 return;
1852 case NL80211_BSS_SELECT_ATTR_BAND_PREF:
1853 join_pref_params[i].type = BRCMF_JOIN_PREF_BAND;
1854 band = bss_select->param.band_pref;
1855 join_pref_params[i].band = nl80211_band_to_fwil(band);
1856 i++;
1857 break;
1858 case NL80211_BSS_SELECT_ATTR_RSSI_ADJUST:
1859 join_pref_params[i].type = BRCMF_JOIN_PREF_RSSI_DELTA;
1860 band = bss_select->param.adjust.band;
1861 join_pref_params[i].band = nl80211_band_to_fwil(band);
1862 join_pref_params[i].rssi_gain = bss_select->param.adjust.delta;
1863 i++;
1864 break;
1865 case NL80211_BSS_SELECT_ATTR_RSSI:
1866 default:
1867 break;
1868 }
1869 join_pref_params[i].type = BRCMF_JOIN_PREF_RSSI;
1870 join_pref_params[i].len = 2;
1871 join_pref_params[i].rssi_gain = 0;
1872 join_pref_params[i].band = 0;
1873 err = brcmf_fil_iovar_data_set(ifp, "join_pref", join_pref_params,
1874 sizeof(join_pref_params));
1875 if (err)
1876 bphy_err(drvr, "Set join_pref error (%d)\n", err);
1877 }
1878
1879 static s32
1880 brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *ndev,
1881 struct cfg80211_connect_params *sme)
1882 {
1883 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1884 struct brcmf_if *ifp = netdev_priv(ndev);
1885 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1886 struct ieee80211_channel *chan = sme->channel;
1887 struct brcmf_pub *drvr = ifp->drvr;
1888 struct brcmf_join_params join_params;
1889 size_t join_params_size;
1890 const struct brcmf_tlv *rsn_ie;
1891 const struct brcmf_vs_tlv *wpa_ie;
1892 const void *ie;
1893 u32 ie_len;
1894 struct brcmf_ext_join_params_le *ext_join_params;
1895 u16 chanspec;
1896 s32 err = 0;
1897 u32 ssid_len;
1898
1899 brcmf_dbg(TRACE, "Enter\n");
1900 if (!check_vif_up(ifp->vif))
1901 return -EIO;
1902
1903 if (!sme->ssid) {
1904 bphy_err(drvr, "Invalid ssid\n");
1905 return -EOPNOTSUPP;
1906 }
1907
1908 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif) {
1909
1910 ie = NULL;
1911 ie_len = 0;
1912
1913 wpa_ie = brcmf_find_wpaie((u8 *)sme->ie, sme->ie_len);
1914 if (wpa_ie) {
1915 ie = wpa_ie;
1916 ie_len = wpa_ie->len + TLV_HDR_LEN;
1917 } else {
1918
1919 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie,
1920 sme->ie_len,
1921 WLAN_EID_RSN);
1922 if (rsn_ie) {
1923 ie = rsn_ie;
1924 ie_len = rsn_ie->len + TLV_HDR_LEN;
1925 }
1926 }
1927 brcmf_fil_iovar_data_set(ifp, "wpaie", ie, ie_len);
1928 }
1929
1930 err = brcmf_vif_set_mgmt_ie(ifp->vif, BRCMF_VNDR_IE_ASSOCREQ_FLAG,
1931 sme->ie, sme->ie_len);
1932 if (err)
1933 bphy_err(drvr, "Set Assoc REQ IE Failed\n");
1934 else
1935 brcmf_dbg(TRACE, "Applied Vndr IEs for Assoc request\n");
1936
1937 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1938
1939 if (chan) {
1940 cfg->channel =
1941 ieee80211_frequency_to_channel(chan->center_freq);
1942 chanspec = channel_to_chanspec(&cfg->d11inf, chan);
1943 brcmf_dbg(CONN, "channel=%d, center_req=%d, chanspec=0x%04x\n",
1944 cfg->channel, chan->center_freq, chanspec);
1945 } else {
1946 cfg->channel = 0;
1947 chanspec = 0;
1948 }
1949
1950 brcmf_dbg(INFO, "ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1951
1952 err = brcmf_set_wpa_version(ndev, sme);
1953 if (err) {
1954 bphy_err(drvr, "wl_set_wpa_version failed (%d)\n", err);
1955 goto done;
1956 }
1957
1958 sme->auth_type = brcmf_war_auth_type(ifp, sme->auth_type);
1959 err = brcmf_set_auth_type(ndev, sme);
1960 if (err) {
1961 bphy_err(drvr, "wl_set_auth_type failed (%d)\n", err);
1962 goto done;
1963 }
1964
1965 err = brcmf_set_wsec_mode(ndev, sme);
1966 if (err) {
1967 bphy_err(drvr, "wl_set_set_cipher failed (%d)\n", err);
1968 goto done;
1969 }
1970
1971 err = brcmf_set_key_mgmt(ndev, sme);
1972 if (err) {
1973 bphy_err(drvr, "wl_set_key_mgmt failed (%d)\n", err);
1974 goto done;
1975 }
1976
1977 err = brcmf_set_sharedkey(ndev, sme);
1978 if (err) {
1979 bphy_err(drvr, "brcmf_set_sharedkey failed (%d)\n", err);
1980 goto done;
1981 }
1982
1983 if (sme->crypto.psk) {
1984 if (WARN_ON(profile->use_fwsup != BRCMF_PROFILE_FWSUP_NONE)) {
1985 err = -EINVAL;
1986 goto done;
1987 }
1988 brcmf_dbg(INFO, "using PSK offload\n");
1989 profile->use_fwsup = BRCMF_PROFILE_FWSUP_PSK;
1990 }
1991
1992 if (profile->use_fwsup != BRCMF_PROFILE_FWSUP_NONE) {
1993
1994 err = brcmf_fil_iovar_int_set(ifp, "sup_wpa", 1);
1995 if (err < 0) {
1996 bphy_err(drvr, "failed to enable fw supplicant\n");
1997 goto done;
1998 }
1999 }
2000
2001 if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_PSK) {
2002 err = brcmf_set_pmk(ifp, sme->crypto.psk,
2003 BRCMF_WSEC_MAX_PSK_LEN);
2004 if (err)
2005 goto done;
2006 }
2007
2008
2009
2010
2011 join_params_size = offsetof(struct brcmf_ext_join_params_le, assoc_le) +
2012 offsetof(struct brcmf_assoc_params_le, chanspec_list);
2013 if (cfg->channel)
2014 join_params_size += sizeof(u16);
2015 ext_join_params = kzalloc(join_params_size, GFP_KERNEL);
2016 if (ext_join_params == NULL) {
2017 err = -ENOMEM;
2018 goto done;
2019 }
2020 ssid_len = min_t(u32, sme->ssid_len, IEEE80211_MAX_SSID_LEN);
2021 ext_join_params->ssid_le.SSID_len = cpu_to_le32(ssid_len);
2022 memcpy(&ext_join_params->ssid_le.SSID, sme->ssid, ssid_len);
2023 if (ssid_len < IEEE80211_MAX_SSID_LEN)
2024 brcmf_dbg(CONN, "SSID \"%s\", len (%d)\n",
2025 ext_join_params->ssid_le.SSID, ssid_len);
2026
2027
2028 ext_join_params->scan_le.scan_type = -1;
2029 ext_join_params->scan_le.home_time = cpu_to_le32(-1);
2030
2031 if (sme->bssid)
2032 memcpy(&ext_join_params->assoc_le.bssid, sme->bssid, ETH_ALEN);
2033 else
2034 eth_broadcast_addr(ext_join_params->assoc_le.bssid);
2035
2036 if (cfg->channel) {
2037 ext_join_params->assoc_le.chanspec_num = cpu_to_le32(1);
2038
2039 ext_join_params->assoc_le.chanspec_list[0] =
2040 cpu_to_le16(chanspec);
2041
2042
2043
2044
2045 ext_join_params->scan_le.active_time =
2046 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS);
2047 ext_join_params->scan_le.passive_time =
2048 cpu_to_le32(BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS);
2049
2050
2051
2052
2053 ext_join_params->scan_le.nprobes =
2054 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS /
2055 BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS);
2056 } else {
2057 ext_join_params->scan_le.active_time = cpu_to_le32(-1);
2058 ext_join_params->scan_le.passive_time = cpu_to_le32(-1);
2059 ext_join_params->scan_le.nprobes = cpu_to_le32(-1);
2060 }
2061
2062 brcmf_set_join_pref(ifp, &sme->bss_select);
2063
2064 err = brcmf_fil_bsscfg_data_set(ifp, "join", ext_join_params,
2065 join_params_size);
2066 kfree(ext_join_params);
2067 if (!err)
2068
2069 goto done;
2070
2071
2072 memset(&join_params, 0, sizeof(join_params));
2073 join_params_size = sizeof(join_params.ssid_le);
2074
2075 memcpy(&join_params.ssid_le.SSID, sme->ssid, ssid_len);
2076 join_params.ssid_le.SSID_len = cpu_to_le32(ssid_len);
2077
2078 if (sme->bssid)
2079 memcpy(join_params.params_le.bssid, sme->bssid, ETH_ALEN);
2080 else
2081 eth_broadcast_addr(join_params.params_le.bssid);
2082
2083 if (cfg->channel) {
2084 join_params.params_le.chanspec_list[0] = cpu_to_le16(chanspec);
2085 join_params.params_le.chanspec_num = cpu_to_le32(1);
2086 join_params_size += sizeof(join_params.params_le);
2087 }
2088 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
2089 &join_params, join_params_size);
2090 if (err)
2091 bphy_err(drvr, "BRCMF_C_SET_SSID failed (%d)\n", err);
2092
2093 done:
2094 if (err)
2095 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
2096 brcmf_dbg(TRACE, "Exit\n");
2097 return err;
2098 }
2099
2100 static s32
2101 brcmf_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *ndev,
2102 u16 reason_code)
2103 {
2104 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2105 struct brcmf_if *ifp = netdev_priv(ndev);
2106 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2107 struct brcmf_pub *drvr = cfg->pub;
2108 struct brcmf_scb_val_le scbval;
2109 s32 err = 0;
2110
2111 brcmf_dbg(TRACE, "Enter. Reason code = %d\n", reason_code);
2112 if (!check_vif_up(ifp->vif))
2113 return -EIO;
2114
2115 clear_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
2116 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
2117 cfg80211_disconnected(ndev, reason_code, NULL, 0, true, GFP_KERNEL);
2118
2119 memcpy(&scbval.ea, &profile->bssid, ETH_ALEN);
2120 scbval.val = cpu_to_le32(reason_code);
2121 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_DISASSOC,
2122 &scbval, sizeof(scbval));
2123 if (err)
2124 bphy_err(drvr, "error (%d)\n", err);
2125
2126 brcmf_dbg(TRACE, "Exit\n");
2127 return err;
2128 }
2129
2130 static s32
2131 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
2132 enum nl80211_tx_power_setting type, s32 mbm)
2133 {
2134 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2135 struct net_device *ndev = cfg_to_ndev(cfg);
2136 struct brcmf_if *ifp = netdev_priv(ndev);
2137 struct brcmf_pub *drvr = cfg->pub;
2138 s32 err;
2139 s32 disable;
2140 u32 qdbm = 127;
2141
2142 brcmf_dbg(TRACE, "Enter %d %d\n", type, mbm);
2143 if (!check_vif_up(ifp->vif))
2144 return -EIO;
2145
2146 switch (type) {
2147 case NL80211_TX_POWER_AUTOMATIC:
2148 break;
2149 case NL80211_TX_POWER_LIMITED:
2150 case NL80211_TX_POWER_FIXED:
2151 if (mbm < 0) {
2152 bphy_err(drvr, "TX_POWER_FIXED - dbm is negative\n");
2153 err = -EINVAL;
2154 goto done;
2155 }
2156 qdbm = MBM_TO_DBM(4 * mbm);
2157 if (qdbm > 127)
2158 qdbm = 127;
2159 qdbm |= WL_TXPWR_OVERRIDE;
2160 break;
2161 default:
2162 bphy_err(drvr, "Unsupported type %d\n", type);
2163 err = -EINVAL;
2164 goto done;
2165 }
2166
2167 disable = WL_RADIO_SW_DISABLE << 16;
2168 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_RADIO, disable);
2169 if (err)
2170 bphy_err(drvr, "WLC_SET_RADIO error (%d)\n", err);
2171
2172 err = brcmf_fil_iovar_int_set(ifp, "qtxpower", qdbm);
2173 if (err)
2174 bphy_err(drvr, "qtxpower error (%d)\n", err);
2175
2176 done:
2177 brcmf_dbg(TRACE, "Exit %d (qdbm)\n", qdbm & ~WL_TXPWR_OVERRIDE);
2178 return err;
2179 }
2180
2181 static s32
2182 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
2183 s32 *dbm)
2184 {
2185 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2186 struct brcmf_cfg80211_vif *vif = wdev_to_vif(wdev);
2187 struct brcmf_pub *drvr = cfg->pub;
2188 s32 qdbm = 0;
2189 s32 err;
2190
2191 brcmf_dbg(TRACE, "Enter\n");
2192 if (!check_vif_up(vif))
2193 return -EIO;
2194
2195 err = brcmf_fil_iovar_int_get(vif->ifp, "qtxpower", &qdbm);
2196 if (err) {
2197 bphy_err(drvr, "error (%d)\n", err);
2198 goto done;
2199 }
2200 *dbm = (qdbm & ~WL_TXPWR_OVERRIDE) / 4;
2201
2202 done:
2203 brcmf_dbg(TRACE, "Exit (0x%x %d)\n", qdbm, *dbm);
2204 return err;
2205 }
2206
2207 static s32
2208 brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *ndev,
2209 u8 key_idx, bool unicast, bool multicast)
2210 {
2211 struct brcmf_if *ifp = netdev_priv(ndev);
2212 struct brcmf_pub *drvr = ifp->drvr;
2213 u32 index;
2214 u32 wsec;
2215 s32 err = 0;
2216
2217 brcmf_dbg(TRACE, "Enter\n");
2218 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2219 if (!check_vif_up(ifp->vif))
2220 return -EIO;
2221
2222 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2223 if (err) {
2224 bphy_err(drvr, "WLC_GET_WSEC error (%d)\n", err);
2225 goto done;
2226 }
2227
2228 if (wsec & WEP_ENABLED) {
2229
2230 index = key_idx;
2231 err = brcmf_fil_cmd_int_set(ifp,
2232 BRCMF_C_SET_KEY_PRIMARY, index);
2233 if (err)
2234 bphy_err(drvr, "error (%d)\n", err);
2235 }
2236 done:
2237 brcmf_dbg(TRACE, "Exit\n");
2238 return err;
2239 }
2240
2241 static s32
2242 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
2243 u8 key_idx, bool pairwise, const u8 *mac_addr)
2244 {
2245 struct brcmf_if *ifp = netdev_priv(ndev);
2246 struct brcmf_wsec_key *key;
2247 s32 err;
2248
2249 brcmf_dbg(TRACE, "Enter\n");
2250 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2251
2252 if (!check_vif_up(ifp->vif))
2253 return -EIO;
2254
2255 if (key_idx >= BRCMF_MAX_DEFAULT_KEYS) {
2256
2257 return -EINVAL;
2258 }
2259
2260 key = &ifp->vif->profile.key[key_idx];
2261
2262 if (key->algo == CRYPTO_ALGO_OFF) {
2263 brcmf_dbg(CONN, "Ignore clearing of (never configured) key\n");
2264 return -EINVAL;
2265 }
2266
2267 memset(key, 0, sizeof(*key));
2268 key->index = (u32)key_idx;
2269 key->flags = BRCMF_PRIMARY_KEY;
2270
2271
2272 err = send_key_to_dongle(ifp, key);
2273
2274 brcmf_dbg(TRACE, "Exit\n");
2275 return err;
2276 }
2277
2278 static s32
2279 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
2280 u8 key_idx, bool pairwise, const u8 *mac_addr,
2281 struct key_params *params)
2282 {
2283 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2284 struct brcmf_if *ifp = netdev_priv(ndev);
2285 struct brcmf_pub *drvr = cfg->pub;
2286 struct brcmf_wsec_key *key;
2287 s32 val;
2288 s32 wsec;
2289 s32 err;
2290 u8 keybuf[8];
2291 bool ext_key;
2292
2293 brcmf_dbg(TRACE, "Enter\n");
2294 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2295 if (!check_vif_up(ifp->vif))
2296 return -EIO;
2297
2298 if (key_idx >= BRCMF_MAX_DEFAULT_KEYS) {
2299
2300 bphy_err(drvr, "invalid key index (%d)\n", key_idx);
2301 return -EINVAL;
2302 }
2303
2304 if (params->key_len == 0)
2305 return brcmf_cfg80211_del_key(wiphy, ndev, key_idx, pairwise,
2306 mac_addr);
2307
2308 if (params->key_len > sizeof(key->data)) {
2309 bphy_err(drvr, "Too long key length (%u)\n", params->key_len);
2310 return -EINVAL;
2311 }
2312
2313 ext_key = false;
2314 if (mac_addr && (params->cipher != WLAN_CIPHER_SUITE_WEP40) &&
2315 (params->cipher != WLAN_CIPHER_SUITE_WEP104)) {
2316 brcmf_dbg(TRACE, "Ext key, mac %pM", mac_addr);
2317 ext_key = true;
2318 }
2319
2320 key = &ifp->vif->profile.key[key_idx];
2321 memset(key, 0, sizeof(*key));
2322 if ((ext_key) && (!is_multicast_ether_addr(mac_addr)))
2323 memcpy((char *)&key->ea, (void *)mac_addr, ETH_ALEN);
2324 key->len = params->key_len;
2325 key->index = key_idx;
2326 memcpy(key->data, params->key, key->len);
2327 if (!ext_key)
2328 key->flags = BRCMF_PRIMARY_KEY;
2329
2330 switch (params->cipher) {
2331 case WLAN_CIPHER_SUITE_WEP40:
2332 key->algo = CRYPTO_ALGO_WEP1;
2333 val = WEP_ENABLED;
2334 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
2335 break;
2336 case WLAN_CIPHER_SUITE_WEP104:
2337 key->algo = CRYPTO_ALGO_WEP128;
2338 val = WEP_ENABLED;
2339 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
2340 break;
2341 case WLAN_CIPHER_SUITE_TKIP:
2342 if (!brcmf_is_apmode(ifp->vif)) {
2343 brcmf_dbg(CONN, "Swapping RX/TX MIC key\n");
2344 memcpy(keybuf, &key->data[24], sizeof(keybuf));
2345 memcpy(&key->data[24], &key->data[16], sizeof(keybuf));
2346 memcpy(&key->data[16], keybuf, sizeof(keybuf));
2347 }
2348 key->algo = CRYPTO_ALGO_TKIP;
2349 val = TKIP_ENABLED;
2350 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
2351 break;
2352 case WLAN_CIPHER_SUITE_AES_CMAC:
2353 key->algo = CRYPTO_ALGO_AES_CCM;
2354 val = AES_ENABLED;
2355 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
2356 break;
2357 case WLAN_CIPHER_SUITE_CCMP:
2358 key->algo = CRYPTO_ALGO_AES_CCM;
2359 val = AES_ENABLED;
2360 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_CCMP\n");
2361 break;
2362 default:
2363 bphy_err(drvr, "Invalid cipher (0x%x)\n", params->cipher);
2364 err = -EINVAL;
2365 goto done;
2366 }
2367
2368 err = send_key_to_dongle(ifp, key);
2369 if (ext_key || err)
2370 goto done;
2371
2372 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2373 if (err) {
2374 bphy_err(drvr, "get wsec error (%d)\n", err);
2375 goto done;
2376 }
2377 wsec |= val;
2378 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
2379 if (err) {
2380 bphy_err(drvr, "set wsec error (%d)\n", err);
2381 goto done;
2382 }
2383
2384 done:
2385 brcmf_dbg(TRACE, "Exit\n");
2386 return err;
2387 }
2388
2389 static s32
2390 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev, u8 key_idx,
2391 bool pairwise, const u8 *mac_addr, void *cookie,
2392 void (*callback)(void *cookie,
2393 struct key_params *params))
2394 {
2395 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2396 struct key_params params;
2397 struct brcmf_if *ifp = netdev_priv(ndev);
2398 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2399 struct brcmf_pub *drvr = cfg->pub;
2400 struct brcmf_cfg80211_security *sec;
2401 s32 wsec;
2402 s32 err = 0;
2403
2404 brcmf_dbg(TRACE, "Enter\n");
2405 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2406 if (!check_vif_up(ifp->vif))
2407 return -EIO;
2408
2409 memset(¶ms, 0, sizeof(params));
2410
2411 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2412 if (err) {
2413 bphy_err(drvr, "WLC_GET_WSEC error (%d)\n", err);
2414
2415 err = -EAGAIN;
2416 goto done;
2417 }
2418 if (wsec & WEP_ENABLED) {
2419 sec = &profile->sec;
2420 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
2421 params.cipher = WLAN_CIPHER_SUITE_WEP40;
2422 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
2423 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
2424 params.cipher = WLAN_CIPHER_SUITE_WEP104;
2425 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
2426 }
2427 } else if (wsec & TKIP_ENABLED) {
2428 params.cipher = WLAN_CIPHER_SUITE_TKIP;
2429 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
2430 } else if (wsec & AES_ENABLED) {
2431 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
2432 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
2433 } else {
2434 bphy_err(drvr, "Invalid algo (0x%x)\n", wsec);
2435 err = -EINVAL;
2436 goto done;
2437 }
2438 callback(cookie, ¶ms);
2439
2440 done:
2441 brcmf_dbg(TRACE, "Exit\n");
2442 return err;
2443 }
2444
2445 static s32
2446 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
2447 struct net_device *ndev, u8 key_idx)
2448 {
2449 struct brcmf_if *ifp = netdev_priv(ndev);
2450
2451 brcmf_dbg(TRACE, "Enter key_idx %d\n", key_idx);
2452
2453 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP))
2454 return 0;
2455
2456 brcmf_dbg(INFO, "Not supported\n");
2457
2458 return -EOPNOTSUPP;
2459 }
2460
2461 static void
2462 brcmf_cfg80211_reconfigure_wep(struct brcmf_if *ifp)
2463 {
2464 struct brcmf_pub *drvr = ifp->drvr;
2465 s32 err;
2466 u8 key_idx;
2467 struct brcmf_wsec_key *key;
2468 s32 wsec;
2469
2470 for (key_idx = 0; key_idx < BRCMF_MAX_DEFAULT_KEYS; key_idx++) {
2471 key = &ifp->vif->profile.key[key_idx];
2472 if ((key->algo == CRYPTO_ALGO_WEP1) ||
2473 (key->algo == CRYPTO_ALGO_WEP128))
2474 break;
2475 }
2476 if (key_idx == BRCMF_MAX_DEFAULT_KEYS)
2477 return;
2478
2479 err = send_key_to_dongle(ifp, key);
2480 if (err) {
2481 bphy_err(drvr, "Setting WEP key failed (%d)\n", err);
2482 return;
2483 }
2484 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2485 if (err) {
2486 bphy_err(drvr, "get wsec error (%d)\n", err);
2487 return;
2488 }
2489 wsec |= WEP_ENABLED;
2490 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
2491 if (err)
2492 bphy_err(drvr, "set wsec error (%d)\n", err);
2493 }
2494
2495 static void brcmf_convert_sta_flags(u32 fw_sta_flags, struct station_info *si)
2496 {
2497 struct nl80211_sta_flag_update *sfu;
2498
2499 brcmf_dbg(TRACE, "flags %08x\n", fw_sta_flags);
2500 si->filled |= BIT_ULL(NL80211_STA_INFO_STA_FLAGS);
2501 sfu = &si->sta_flags;
2502 sfu->mask = BIT(NL80211_STA_FLAG_WME) |
2503 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2504 BIT(NL80211_STA_FLAG_ASSOCIATED) |
2505 BIT(NL80211_STA_FLAG_AUTHORIZED);
2506 if (fw_sta_flags & BRCMF_STA_WME)
2507 sfu->set |= BIT(NL80211_STA_FLAG_WME);
2508 if (fw_sta_flags & BRCMF_STA_AUTHE)
2509 sfu->set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
2510 if (fw_sta_flags & BRCMF_STA_ASSOC)
2511 sfu->set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
2512 if (fw_sta_flags & BRCMF_STA_AUTHO)
2513 sfu->set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
2514 }
2515
2516 static void brcmf_fill_bss_param(struct brcmf_if *ifp, struct station_info *si)
2517 {
2518 struct brcmf_pub *drvr = ifp->drvr;
2519 struct {
2520 __le32 len;
2521 struct brcmf_bss_info_le bss_le;
2522 } *buf;
2523 u16 capability;
2524 int err;
2525
2526 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2527 if (!buf)
2528 return;
2529
2530 buf->len = cpu_to_le32(WL_BSS_INFO_MAX);
2531 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO, buf,
2532 WL_BSS_INFO_MAX);
2533 if (err) {
2534 bphy_err(drvr, "Failed to get bss info (%d)\n", err);
2535 goto out_kfree;
2536 }
2537 si->filled |= BIT_ULL(NL80211_STA_INFO_BSS_PARAM);
2538 si->bss_param.beacon_interval = le16_to_cpu(buf->bss_le.beacon_period);
2539 si->bss_param.dtim_period = buf->bss_le.dtim_period;
2540 capability = le16_to_cpu(buf->bss_le.capability);
2541 if (capability & IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT)
2542 si->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
2543 if (capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
2544 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
2545 if (capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
2546 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
2547
2548 out_kfree:
2549 kfree(buf);
2550 }
2551
2552 static s32
2553 brcmf_cfg80211_get_station_ibss(struct brcmf_if *ifp,
2554 struct station_info *sinfo)
2555 {
2556 struct brcmf_pub *drvr = ifp->drvr;
2557 struct brcmf_scb_val_le scbval;
2558 struct brcmf_pktcnt_le pktcnt;
2559 s32 err;
2560 u32 rate;
2561 u32 rssi;
2562
2563
2564 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_RATE, &rate);
2565 if (err < 0) {
2566 bphy_err(drvr, "BRCMF_C_GET_RATE error (%d)\n", err);
2567 return err;
2568 }
2569 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
2570 sinfo->txrate.legacy = rate * 5;
2571
2572 memset(&scbval, 0, sizeof(scbval));
2573 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_RSSI, &scbval,
2574 sizeof(scbval));
2575 if (err) {
2576 bphy_err(drvr, "BRCMF_C_GET_RSSI error (%d)\n", err);
2577 return err;
2578 }
2579 rssi = le32_to_cpu(scbval.val);
2580 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
2581 sinfo->signal = rssi;
2582
2583 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_GET_PKTCNTS, &pktcnt,
2584 sizeof(pktcnt));
2585 if (err) {
2586 bphy_err(drvr, "BRCMF_C_GET_GET_PKTCNTS error (%d)\n", err);
2587 return err;
2588 }
2589 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS) |
2590 BIT_ULL(NL80211_STA_INFO_RX_DROP_MISC) |
2591 BIT_ULL(NL80211_STA_INFO_TX_PACKETS) |
2592 BIT_ULL(NL80211_STA_INFO_TX_FAILED);
2593 sinfo->rx_packets = le32_to_cpu(pktcnt.rx_good_pkt);
2594 sinfo->rx_dropped_misc = le32_to_cpu(pktcnt.rx_bad_pkt);
2595 sinfo->tx_packets = le32_to_cpu(pktcnt.tx_good_pkt);
2596 sinfo->tx_failed = le32_to_cpu(pktcnt.tx_bad_pkt);
2597
2598 return 0;
2599 }
2600
2601 static s32
2602 brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *ndev,
2603 const u8 *mac, struct station_info *sinfo)
2604 {
2605 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2606 struct brcmf_if *ifp = netdev_priv(ndev);
2607 struct brcmf_pub *drvr = cfg->pub;
2608 struct brcmf_scb_val_le scb_val;
2609 s32 err = 0;
2610 struct brcmf_sta_info_le sta_info_le;
2611 u32 sta_flags;
2612 u32 is_tdls_peer;
2613 s32 total_rssi;
2614 s32 count_rssi;
2615 int rssi;
2616 u32 i;
2617
2618 brcmf_dbg(TRACE, "Enter, MAC %pM\n", mac);
2619 if (!check_vif_up(ifp->vif))
2620 return -EIO;
2621
2622 if (brcmf_is_ibssmode(ifp->vif))
2623 return brcmf_cfg80211_get_station_ibss(ifp, sinfo);
2624
2625 memset(&sta_info_le, 0, sizeof(sta_info_le));
2626 memcpy(&sta_info_le, mac, ETH_ALEN);
2627 err = brcmf_fil_iovar_data_get(ifp, "tdls_sta_info",
2628 &sta_info_le,
2629 sizeof(sta_info_le));
2630 is_tdls_peer = !err;
2631 if (err) {
2632 err = brcmf_fil_iovar_data_get(ifp, "sta_info",
2633 &sta_info_le,
2634 sizeof(sta_info_le));
2635 if (err < 0) {
2636 bphy_err(drvr, "GET STA INFO failed, %d\n", err);
2637 goto done;
2638 }
2639 }
2640 brcmf_dbg(TRACE, "version %d\n", le16_to_cpu(sta_info_le.ver));
2641 sinfo->filled = BIT_ULL(NL80211_STA_INFO_INACTIVE_TIME);
2642 sinfo->inactive_time = le32_to_cpu(sta_info_le.idle) * 1000;
2643 sta_flags = le32_to_cpu(sta_info_le.flags);
2644 brcmf_convert_sta_flags(sta_flags, sinfo);
2645 sinfo->sta_flags.mask |= BIT(NL80211_STA_FLAG_TDLS_PEER);
2646 if (is_tdls_peer)
2647 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
2648 else
2649 sinfo->sta_flags.set &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
2650 if (sta_flags & BRCMF_STA_ASSOC) {
2651 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CONNECTED_TIME);
2652 sinfo->connected_time = le32_to_cpu(sta_info_le.in);
2653 brcmf_fill_bss_param(ifp, sinfo);
2654 }
2655 if (sta_flags & BRCMF_STA_SCBSTATS) {
2656 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);
2657 sinfo->tx_failed = le32_to_cpu(sta_info_le.tx_failures);
2658 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_PACKETS);
2659 sinfo->tx_packets = le32_to_cpu(sta_info_le.tx_pkts);
2660 sinfo->tx_packets += le32_to_cpu(sta_info_le.tx_mcast_pkts);
2661 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS);
2662 sinfo->rx_packets = le32_to_cpu(sta_info_le.rx_ucast_pkts);
2663 sinfo->rx_packets += le32_to_cpu(sta_info_le.rx_mcast_pkts);
2664 if (sinfo->tx_packets) {
2665 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
2666 sinfo->txrate.legacy =
2667 le32_to_cpu(sta_info_le.tx_rate) / 100;
2668 }
2669 if (sinfo->rx_packets) {
2670 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE);
2671 sinfo->rxrate.legacy =
2672 le32_to_cpu(sta_info_le.rx_rate) / 100;
2673 }
2674 if (le16_to_cpu(sta_info_le.ver) >= 4) {
2675 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BYTES);
2676 sinfo->tx_bytes = le64_to_cpu(sta_info_le.tx_tot_bytes);
2677 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BYTES);
2678 sinfo->rx_bytes = le64_to_cpu(sta_info_le.rx_tot_bytes);
2679 }
2680 total_rssi = 0;
2681 count_rssi = 0;
2682 for (i = 0; i < BRCMF_ANT_MAX; i++) {
2683 if (sta_info_le.rssi[i]) {
2684 sinfo->chain_signal_avg[count_rssi] =
2685 sta_info_le.rssi[i];
2686 sinfo->chain_signal[count_rssi] =
2687 sta_info_le.rssi[i];
2688 total_rssi += sta_info_le.rssi[i];
2689 count_rssi++;
2690 }
2691 }
2692 if (count_rssi) {
2693 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
2694 sinfo->chains = count_rssi;
2695
2696 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
2697 total_rssi /= count_rssi;
2698 sinfo->signal = total_rssi;
2699 } else if (test_bit(BRCMF_VIF_STATUS_CONNECTED,
2700 &ifp->vif->sme_state)) {
2701 memset(&scb_val, 0, sizeof(scb_val));
2702 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_RSSI,
2703 &scb_val, sizeof(scb_val));
2704 if (err) {
2705 bphy_err(drvr, "Could not get rssi (%d)\n",
2706 err);
2707 goto done;
2708 } else {
2709 rssi = le32_to_cpu(scb_val.val);
2710 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
2711 sinfo->signal = rssi;
2712 brcmf_dbg(CONN, "RSSI %d dBm\n", rssi);
2713 }
2714 }
2715 }
2716 done:
2717 brcmf_dbg(TRACE, "Exit\n");
2718 return err;
2719 }
2720
2721 static int
2722 brcmf_cfg80211_dump_station(struct wiphy *wiphy, struct net_device *ndev,
2723 int idx, u8 *mac, struct station_info *sinfo)
2724 {
2725 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2726 struct brcmf_if *ifp = netdev_priv(ndev);
2727 struct brcmf_pub *drvr = cfg->pub;
2728 s32 err;
2729
2730 brcmf_dbg(TRACE, "Enter, idx %d\n", idx);
2731
2732 if (idx == 0) {
2733 cfg->assoclist.count = cpu_to_le32(BRCMF_MAX_ASSOCLIST);
2734 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_ASSOCLIST,
2735 &cfg->assoclist,
2736 sizeof(cfg->assoclist));
2737 if (err) {
2738 bphy_err(drvr, "BRCMF_C_GET_ASSOCLIST unsupported, err=%d\n",
2739 err);
2740 cfg->assoclist.count = 0;
2741 return -EOPNOTSUPP;
2742 }
2743 }
2744 if (idx < le32_to_cpu(cfg->assoclist.count)) {
2745 memcpy(mac, cfg->assoclist.mac[idx], ETH_ALEN);
2746 return brcmf_cfg80211_get_station(wiphy, ndev, mac, sinfo);
2747 }
2748 return -ENOENT;
2749 }
2750
2751 static s32
2752 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *ndev,
2753 bool enabled, s32 timeout)
2754 {
2755 s32 pm;
2756 s32 err = 0;
2757 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2758 struct brcmf_if *ifp = netdev_priv(ndev);
2759 struct brcmf_pub *drvr = cfg->pub;
2760
2761 brcmf_dbg(TRACE, "Enter\n");
2762
2763
2764
2765
2766
2767
2768
2769
2770 cfg->pwr_save = enabled;
2771 if (!check_vif_up(ifp->vif)) {
2772
2773 brcmf_dbg(INFO, "Device is not ready, storing the value in cfg_info struct\n");
2774 goto done;
2775 }
2776
2777 pm = enabled ? PM_FAST : PM_OFF;
2778
2779 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) {
2780 brcmf_dbg(INFO, "Do not enable power save for P2P clients\n");
2781 pm = PM_OFF;
2782 }
2783 brcmf_dbg(INFO, "power save %s\n", (pm ? "enabled" : "disabled"));
2784
2785 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, pm);
2786 if (err) {
2787 if (err == -ENODEV)
2788 bphy_err(drvr, "net_device is not ready yet\n");
2789 else
2790 bphy_err(drvr, "error (%d)\n", err);
2791 }
2792 done:
2793 brcmf_dbg(TRACE, "Exit\n");
2794 return err;
2795 }
2796
2797 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_info *cfg,
2798 struct brcmf_bss_info_le *bi)
2799 {
2800 struct wiphy *wiphy = cfg_to_wiphy(cfg);
2801 struct brcmf_pub *drvr = cfg->pub;
2802 struct cfg80211_bss *bss;
2803 enum nl80211_band band;
2804 struct brcmu_chan ch;
2805 u16 channel;
2806 u32 freq;
2807 u16 notify_capability;
2808 u16 notify_interval;
2809 u8 *notify_ie;
2810 size_t notify_ielen;
2811 struct cfg80211_inform_bss bss_data = {};
2812
2813 if (le32_to_cpu(bi->length) > WL_BSS_INFO_MAX) {
2814 bphy_err(drvr, "Bss info is larger than buffer. Discarding\n");
2815 return 0;
2816 }
2817
2818 if (!bi->ctl_ch) {
2819 ch.chspec = le16_to_cpu(bi->chanspec);
2820 cfg->d11inf.decchspec(&ch);
2821 bi->ctl_ch = ch.control_ch_num;
2822 }
2823 channel = bi->ctl_ch;
2824
2825 if (channel <= CH_MAX_2G_CHANNEL)
2826 band = NL80211_BAND_2GHZ;
2827 else
2828 band = NL80211_BAND_5GHZ;
2829
2830 freq = ieee80211_channel_to_frequency(channel, band);
2831 bss_data.chan = ieee80211_get_channel(wiphy, freq);
2832 bss_data.scan_width = NL80211_BSS_CHAN_WIDTH_20;
2833 bss_data.boottime_ns = ktime_to_ns(ktime_get_boottime());
2834
2835 notify_capability = le16_to_cpu(bi->capability);
2836 notify_interval = le16_to_cpu(bi->beacon_period);
2837 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2838 notify_ielen = le32_to_cpu(bi->ie_length);
2839 bss_data.signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2840
2841 brcmf_dbg(CONN, "bssid: %pM\n", bi->BSSID);
2842 brcmf_dbg(CONN, "Channel: %d(%d)\n", channel, freq);
2843 brcmf_dbg(CONN, "Capability: %X\n", notify_capability);
2844 brcmf_dbg(CONN, "Beacon interval: %d\n", notify_interval);
2845 brcmf_dbg(CONN, "Signal: %d\n", bss_data.signal);
2846
2847 bss = cfg80211_inform_bss_data(wiphy, &bss_data,
2848 CFG80211_BSS_FTYPE_UNKNOWN,
2849 (const u8 *)bi->BSSID,
2850 0, notify_capability,
2851 notify_interval, notify_ie,
2852 notify_ielen, GFP_KERNEL);
2853
2854 if (!bss)
2855 return -ENOMEM;
2856
2857 cfg80211_put_bss(wiphy, bss);
2858
2859 return 0;
2860 }
2861
2862 static struct brcmf_bss_info_le *
2863 next_bss_le(struct brcmf_scan_results *list, struct brcmf_bss_info_le *bss)
2864 {
2865 if (bss == NULL)
2866 return list->bss_info_le;
2867 return (struct brcmf_bss_info_le *)((unsigned long)bss +
2868 le32_to_cpu(bss->length));
2869 }
2870
2871 static s32 brcmf_inform_bss(struct brcmf_cfg80211_info *cfg)
2872 {
2873 struct brcmf_pub *drvr = cfg->pub;
2874 struct brcmf_scan_results *bss_list;
2875 struct brcmf_bss_info_le *bi = NULL;
2876 s32 err = 0;
2877 int i;
2878
2879 bss_list = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
2880 if (bss_list->count != 0 &&
2881 bss_list->version != BRCMF_BSS_INFO_VERSION) {
2882 bphy_err(drvr, "Version %d != WL_BSS_INFO_VERSION\n",
2883 bss_list->version);
2884 return -EOPNOTSUPP;
2885 }
2886 brcmf_dbg(SCAN, "scanned AP count (%d)\n", bss_list->count);
2887 for (i = 0; i < bss_list->count; i++) {
2888 bi = next_bss_le(bss_list, bi);
2889 err = brcmf_inform_single_bss(cfg, bi);
2890 if (err)
2891 break;
2892 }
2893 return err;
2894 }
2895
2896 static s32 brcmf_inform_ibss(struct brcmf_cfg80211_info *cfg,
2897 struct net_device *ndev, const u8 *bssid)
2898 {
2899 struct wiphy *wiphy = cfg_to_wiphy(cfg);
2900 struct brcmf_pub *drvr = cfg->pub;
2901 struct ieee80211_channel *notify_channel;
2902 struct brcmf_bss_info_le *bi = NULL;
2903 struct ieee80211_supported_band *band;
2904 struct cfg80211_bss *bss;
2905 struct brcmu_chan ch;
2906 u8 *buf = NULL;
2907 s32 err = 0;
2908 u32 freq;
2909 u16 notify_capability;
2910 u16 notify_interval;
2911 u8 *notify_ie;
2912 size_t notify_ielen;
2913 s32 notify_signal;
2914
2915 brcmf_dbg(TRACE, "Enter\n");
2916
2917 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2918 if (buf == NULL) {
2919 err = -ENOMEM;
2920 goto CleanUp;
2921 }
2922
2923 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2924
2925 err = brcmf_fil_cmd_data_get(netdev_priv(ndev), BRCMF_C_GET_BSS_INFO,
2926 buf, WL_BSS_INFO_MAX);
2927 if (err) {
2928 bphy_err(drvr, "WLC_GET_BSS_INFO failed: %d\n", err);
2929 goto CleanUp;
2930 }
2931
2932 bi = (struct brcmf_bss_info_le *)(buf + 4);
2933
2934 ch.chspec = le16_to_cpu(bi->chanspec);
2935 cfg->d11inf.decchspec(&ch);
2936
2937 if (ch.band == BRCMU_CHAN_BAND_2G)
2938 band = wiphy->bands[NL80211_BAND_2GHZ];
2939 else
2940 band = wiphy->bands[NL80211_BAND_5GHZ];
2941
2942 freq = ieee80211_channel_to_frequency(ch.control_ch_num, band->band);
2943 cfg->channel = freq;
2944 notify_channel = ieee80211_get_channel(wiphy, freq);
2945
2946 notify_capability = le16_to_cpu(bi->capability);
2947 notify_interval = le16_to_cpu(bi->beacon_period);
2948 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2949 notify_ielen = le32_to_cpu(bi->ie_length);
2950 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2951
2952 brcmf_dbg(CONN, "channel: %d(%d)\n", ch.control_ch_num, freq);
2953 brcmf_dbg(CONN, "capability: %X\n", notify_capability);
2954 brcmf_dbg(CONN, "beacon interval: %d\n", notify_interval);
2955 brcmf_dbg(CONN, "signal: %d\n", notify_signal);
2956
2957 bss = cfg80211_inform_bss(wiphy, notify_channel,
2958 CFG80211_BSS_FTYPE_UNKNOWN, bssid, 0,
2959 notify_capability, notify_interval,
2960 notify_ie, notify_ielen, notify_signal,
2961 GFP_KERNEL);
2962
2963 if (!bss) {
2964 err = -ENOMEM;
2965 goto CleanUp;
2966 }
2967
2968 cfg80211_put_bss(wiphy, bss);
2969
2970 CleanUp:
2971
2972 kfree(buf);
2973
2974 brcmf_dbg(TRACE, "Exit\n");
2975
2976 return err;
2977 }
2978
2979 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_info *cfg,
2980 struct brcmf_if *ifp)
2981 {
2982 struct brcmf_pub *drvr = cfg->pub;
2983 struct brcmf_bss_info_le *bi;
2984 const struct brcmf_tlv *tim;
2985 size_t ie_len;
2986 u8 *ie;
2987 s32 err = 0;
2988
2989 brcmf_dbg(TRACE, "Enter\n");
2990 if (brcmf_is_ibssmode(ifp->vif))
2991 return err;
2992
2993 *(__le32 *)cfg->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2994 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
2995 cfg->extra_buf, WL_EXTRA_BUF_MAX);
2996 if (err) {
2997 bphy_err(drvr, "Could not get bss info %d\n", err);
2998 goto update_bss_info_out;
2999 }
3000
3001 bi = (struct brcmf_bss_info_le *)(cfg->extra_buf + 4);
3002 err = brcmf_inform_single_bss(cfg, bi);
3003 if (err)
3004 goto update_bss_info_out;
3005
3006 ie = ((u8 *)bi) + le16_to_cpu(bi->ie_offset);
3007 ie_len = le32_to_cpu(bi->ie_length);
3008
3009 tim = brcmf_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
3010 if (!tim) {
3011
3012
3013
3014
3015
3016 u32 var;
3017 err = brcmf_fil_iovar_int_get(ifp, "dtim_assoc", &var);
3018 if (err) {
3019 bphy_err(drvr, "wl dtim_assoc failed (%d)\n", err);
3020 goto update_bss_info_out;
3021 }
3022 }
3023
3024 update_bss_info_out:
3025 brcmf_dbg(TRACE, "Exit");
3026 return err;
3027 }
3028
3029 void brcmf_abort_scanning(struct brcmf_cfg80211_info *cfg)
3030 {
3031 struct escan_info *escan = &cfg->escan_info;
3032
3033 set_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
3034 if (cfg->int_escan_map || cfg->scan_request) {
3035 escan->escan_state = WL_ESCAN_STATE_IDLE;
3036 brcmf_notify_escan_complete(cfg, escan->ifp, true, true);
3037 }
3038 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3039 clear_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
3040 }
3041
3042 static void brcmf_cfg80211_escan_timeout_worker(struct work_struct *work)
3043 {
3044 struct brcmf_cfg80211_info *cfg =
3045 container_of(work, struct brcmf_cfg80211_info,
3046 escan_timeout_work);
3047
3048 brcmf_inform_bss(cfg);
3049 brcmf_notify_escan_complete(cfg, cfg->escan_info.ifp, true, true);
3050 }
3051
3052 static void brcmf_escan_timeout(struct timer_list *t)
3053 {
3054 struct brcmf_cfg80211_info *cfg =
3055 from_timer(cfg, t, escan_timeout);
3056 struct brcmf_pub *drvr = cfg->pub;
3057
3058 if (cfg->int_escan_map || cfg->scan_request) {
3059 bphy_err(drvr, "timer expired\n");
3060 schedule_work(&cfg->escan_timeout_work);
3061 }
3062 }
3063
3064 static s32
3065 brcmf_compare_update_same_bss(struct brcmf_cfg80211_info *cfg,
3066 struct brcmf_bss_info_le *bss,
3067 struct brcmf_bss_info_le *bss_info_le)
3068 {
3069 struct brcmu_chan ch_bss, ch_bss_info_le;
3070
3071 ch_bss.chspec = le16_to_cpu(bss->chanspec);
3072 cfg->d11inf.decchspec(&ch_bss);
3073 ch_bss_info_le.chspec = le16_to_cpu(bss_info_le->chanspec);
3074 cfg->d11inf.decchspec(&ch_bss_info_le);
3075
3076 if (!memcmp(&bss_info_le->BSSID, &bss->BSSID, ETH_ALEN) &&
3077 ch_bss.band == ch_bss_info_le.band &&
3078 bss_info_le->SSID_len == bss->SSID_len &&
3079 !memcmp(bss_info_le->SSID, bss->SSID, bss_info_le->SSID_len)) {
3080 if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) ==
3081 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL)) {
3082 s16 bss_rssi = le16_to_cpu(bss->RSSI);
3083 s16 bss_info_rssi = le16_to_cpu(bss_info_le->RSSI);
3084
3085
3086
3087
3088 if (bss_info_rssi > bss_rssi)
3089 bss->RSSI = bss_info_le->RSSI;
3090 } else if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) &&
3091 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL) == 0) {
3092
3093
3094
3095 bss->RSSI = bss_info_le->RSSI;
3096 bss->flags |= BRCMF_BSS_RSSI_ON_CHANNEL;
3097 }
3098 return 1;
3099 }
3100 return 0;
3101 }
3102
3103 static s32
3104 brcmf_cfg80211_escan_handler(struct brcmf_if *ifp,
3105 const struct brcmf_event_msg *e, void *data)
3106 {
3107 struct brcmf_pub *drvr = ifp->drvr;
3108 struct brcmf_cfg80211_info *cfg = drvr->config;
3109 s32 status;
3110 struct brcmf_escan_result_le *escan_result_le;
3111 u32 escan_buflen;
3112 struct brcmf_bss_info_le *bss_info_le;
3113 struct brcmf_bss_info_le *bss = NULL;
3114 u32 bi_length;
3115 struct brcmf_scan_results *list;
3116 u32 i;
3117 bool aborted;
3118
3119 status = e->status;
3120
3121 if (status == BRCMF_E_STATUS_ABORT)
3122 goto exit;
3123
3124 if (!test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3125 bphy_err(drvr, "scan not ready, bsscfgidx=%d\n",
3126 ifp->bsscfgidx);
3127 return -EPERM;
3128 }
3129
3130 if (status == BRCMF_E_STATUS_PARTIAL) {
3131 brcmf_dbg(SCAN, "ESCAN Partial result\n");
3132 if (e->datalen < sizeof(*escan_result_le)) {
3133 bphy_err(drvr, "invalid event data length\n");
3134 goto exit;
3135 }
3136 escan_result_le = (struct brcmf_escan_result_le *) data;
3137 if (!escan_result_le) {
3138 bphy_err(drvr, "Invalid escan result (NULL pointer)\n");
3139 goto exit;
3140 }
3141 escan_buflen = le32_to_cpu(escan_result_le->buflen);
3142 if (escan_buflen > BRCMF_ESCAN_BUF_SIZE ||
3143 escan_buflen > e->datalen ||
3144 escan_buflen < sizeof(*escan_result_le)) {
3145 bphy_err(drvr, "Invalid escan buffer length: %d\n",
3146 escan_buflen);
3147 goto exit;
3148 }
3149 if (le16_to_cpu(escan_result_le->bss_count) != 1) {
3150 bphy_err(drvr, "Invalid bss_count %d: ignoring\n",
3151 escan_result_le->bss_count);
3152 goto exit;
3153 }
3154 bss_info_le = &escan_result_le->bss_info_le;
3155
3156 if (brcmf_p2p_scan_finding_common_channel(cfg, bss_info_le))
3157 goto exit;
3158
3159 if (!cfg->int_escan_map && !cfg->scan_request) {
3160 brcmf_dbg(SCAN, "result without cfg80211 request\n");
3161 goto exit;
3162 }
3163
3164 bi_length = le32_to_cpu(bss_info_le->length);
3165 if (bi_length != escan_buflen - WL_ESCAN_RESULTS_FIXED_SIZE) {
3166 bphy_err(drvr, "Ignoring invalid bss_info length: %d\n",
3167 bi_length);
3168 goto exit;
3169 }
3170
3171 if (!(cfg_to_wiphy(cfg)->interface_modes &
3172 BIT(NL80211_IFTYPE_ADHOC))) {
3173 if (le16_to_cpu(bss_info_le->capability) &
3174 WLAN_CAPABILITY_IBSS) {
3175 bphy_err(drvr, "Ignoring IBSS result\n");
3176 goto exit;
3177 }
3178 }
3179
3180 list = (struct brcmf_scan_results *)
3181 cfg->escan_info.escan_buf;
3182 if (bi_length > BRCMF_ESCAN_BUF_SIZE - list->buflen) {
3183 bphy_err(drvr, "Buffer is too small: ignoring\n");
3184 goto exit;
3185 }
3186
3187 for (i = 0; i < list->count; i++) {
3188 bss = bss ? (struct brcmf_bss_info_le *)
3189 ((unsigned char *)bss +
3190 le32_to_cpu(bss->length)) : list->bss_info_le;
3191 if (brcmf_compare_update_same_bss(cfg, bss,
3192 bss_info_le))
3193 goto exit;
3194 }
3195 memcpy(&cfg->escan_info.escan_buf[list->buflen], bss_info_le,
3196 bi_length);
3197 list->version = le32_to_cpu(bss_info_le->version);
3198 list->buflen += bi_length;
3199 list->count++;
3200 } else {
3201 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
3202 if (brcmf_p2p_scan_finding_common_channel(cfg, NULL))
3203 goto exit;
3204 if (cfg->int_escan_map || cfg->scan_request) {
3205 brcmf_inform_bss(cfg);
3206 aborted = status != BRCMF_E_STATUS_SUCCESS;
3207 brcmf_notify_escan_complete(cfg, ifp, aborted, false);
3208 } else
3209 brcmf_dbg(SCAN, "Ignored scan complete result 0x%x\n",
3210 status);
3211 }
3212 exit:
3213 return 0;
3214 }
3215
3216 static void brcmf_init_escan(struct brcmf_cfg80211_info *cfg)
3217 {
3218 brcmf_fweh_register(cfg->pub, BRCMF_E_ESCAN_RESULT,
3219 brcmf_cfg80211_escan_handler);
3220 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
3221
3222 timer_setup(&cfg->escan_timeout, brcmf_escan_timeout, 0);
3223 INIT_WORK(&cfg->escan_timeout_work,
3224 brcmf_cfg80211_escan_timeout_worker);
3225 }
3226
3227 static struct cfg80211_scan_request *
3228 brcmf_alloc_internal_escan_request(struct wiphy *wiphy, u32 n_netinfo) {
3229 struct cfg80211_scan_request *req;
3230 size_t req_size;
3231
3232 req_size = sizeof(*req) +
3233 n_netinfo * sizeof(req->channels[0]) +
3234 n_netinfo * sizeof(*req->ssids);
3235
3236 req = kzalloc(req_size, GFP_KERNEL);
3237 if (req) {
3238 req->wiphy = wiphy;
3239 req->ssids = (void *)(&req->channels[0]) +
3240 n_netinfo * sizeof(req->channels[0]);
3241 }
3242 return req;
3243 }
3244
3245 static int brcmf_internal_escan_add_info(struct cfg80211_scan_request *req,
3246 u8 *ssid, u8 ssid_len, u8 channel)
3247 {
3248 struct ieee80211_channel *chan;
3249 enum nl80211_band band;
3250 int freq, i;
3251
3252 if (channel <= CH_MAX_2G_CHANNEL)
3253 band = NL80211_BAND_2GHZ;
3254 else
3255 band = NL80211_BAND_5GHZ;
3256
3257 freq = ieee80211_channel_to_frequency(channel, band);
3258 if (!freq)
3259 return -EINVAL;
3260
3261 chan = ieee80211_get_channel(req->wiphy, freq);
3262 if (!chan)
3263 return -EINVAL;
3264
3265 for (i = 0; i < req->n_channels; i++) {
3266 if (req->channels[i] == chan)
3267 break;
3268 }
3269 if (i == req->n_channels)
3270 req->channels[req->n_channels++] = chan;
3271
3272 for (i = 0; i < req->n_ssids; i++) {
3273 if (req->ssids[i].ssid_len == ssid_len &&
3274 !memcmp(req->ssids[i].ssid, ssid, ssid_len))
3275 break;
3276 }
3277 if (i == req->n_ssids) {
3278 memcpy(req->ssids[req->n_ssids].ssid, ssid, ssid_len);
3279 req->ssids[req->n_ssids++].ssid_len = ssid_len;
3280 }
3281 return 0;
3282 }
3283
3284 static int brcmf_start_internal_escan(struct brcmf_if *ifp, u32 fwmap,
3285 struct cfg80211_scan_request *request)
3286 {
3287 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
3288 int err;
3289
3290 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3291 if (cfg->int_escan_map)
3292 brcmf_dbg(SCAN, "aborting internal scan: map=%u\n",
3293 cfg->int_escan_map);
3294
3295 brcmf_abort_scanning(cfg);
3296 }
3297
3298 brcmf_dbg(SCAN, "start internal scan: map=%u\n", fwmap);
3299 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3300 cfg->escan_info.run = brcmf_run_escan;
3301 err = brcmf_do_escan(ifp, request);
3302 if (err) {
3303 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3304 return err;
3305 }
3306 cfg->int_escan_map = fwmap;
3307 return 0;
3308 }
3309
3310 static struct brcmf_pno_net_info_le *
3311 brcmf_get_netinfo_array(struct brcmf_pno_scanresults_le *pfn_v1)
3312 {
3313 struct brcmf_pno_scanresults_v2_le *pfn_v2;
3314 struct brcmf_pno_net_info_le *netinfo;
3315
3316 switch (pfn_v1->version) {
3317 default:
3318 WARN_ON(1);
3319
3320 case cpu_to_le32(1):
3321 netinfo = (struct brcmf_pno_net_info_le *)(pfn_v1 + 1);
3322 break;
3323 case cpu_to_le32(2):
3324 pfn_v2 = (struct brcmf_pno_scanresults_v2_le *)pfn_v1;
3325 netinfo = (struct brcmf_pno_net_info_le *)(pfn_v2 + 1);
3326 break;
3327 }
3328
3329 return netinfo;
3330 }
3331
3332
3333
3334
3335
3336
3337
3338 static s32
3339 brcmf_notify_sched_scan_results(struct brcmf_if *ifp,
3340 const struct brcmf_event_msg *e, void *data)
3341 {
3342 struct brcmf_pub *drvr = ifp->drvr;
3343 struct brcmf_cfg80211_info *cfg = drvr->config;
3344 struct brcmf_pno_net_info_le *netinfo, *netinfo_start;
3345 struct cfg80211_scan_request *request = NULL;
3346 struct wiphy *wiphy = cfg_to_wiphy(cfg);
3347 int i, err = 0;
3348 struct brcmf_pno_scanresults_le *pfn_result;
3349 u32 bucket_map;
3350 u32 result_count;
3351 u32 status;
3352 u32 datalen;
3353
3354 brcmf_dbg(SCAN, "Enter\n");
3355
3356 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) {
3357 brcmf_dbg(SCAN, "Event data to small. Ignore\n");
3358 return 0;
3359 }
3360
3361 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
3362 brcmf_dbg(SCAN, "PFN NET LOST event. Do Nothing\n");
3363 return 0;
3364 }
3365
3366 pfn_result = (struct brcmf_pno_scanresults_le *)data;
3367 result_count = le32_to_cpu(pfn_result->count);
3368 status = le32_to_cpu(pfn_result->status);
3369
3370
3371
3372
3373 WARN_ON(status != BRCMF_PNO_SCAN_COMPLETE);
3374 brcmf_dbg(SCAN, "PFN NET FOUND event. count: %d\n", result_count);
3375 if (!result_count) {
3376 bphy_err(drvr, "FALSE PNO Event. (pfn_count == 0)\n");
3377 goto out_err;
3378 }
3379
3380 netinfo_start = brcmf_get_netinfo_array(pfn_result);
3381 datalen = e->datalen - ((void *)netinfo_start - (void *)pfn_result);
3382 if (datalen < result_count * sizeof(*netinfo)) {
3383 bphy_err(drvr, "insufficient event data\n");
3384 goto out_err;
3385 }
3386
3387 request = brcmf_alloc_internal_escan_request(wiphy,
3388 result_count);
3389 if (!request) {
3390 err = -ENOMEM;
3391 goto out_err;
3392 }
3393
3394 bucket_map = 0;
3395 for (i = 0; i < result_count; i++) {
3396 netinfo = &netinfo_start[i];
3397
3398 if (netinfo->SSID_len > IEEE80211_MAX_SSID_LEN)
3399 netinfo->SSID_len = IEEE80211_MAX_SSID_LEN;
3400 brcmf_dbg(SCAN, "SSID:%.32s Channel:%d\n",
3401 netinfo->SSID, netinfo->channel);
3402 bucket_map |= brcmf_pno_get_bucket_map(cfg->pno, netinfo);
3403 err = brcmf_internal_escan_add_info(request,
3404 netinfo->SSID,
3405 netinfo->SSID_len,
3406 netinfo->channel);
3407 if (err)
3408 goto out_err;
3409 }
3410
3411 if (!bucket_map)
3412 goto free_req;
3413
3414 err = brcmf_start_internal_escan(ifp, bucket_map, request);
3415 if (!err)
3416 goto free_req;
3417
3418 out_err:
3419 cfg80211_sched_scan_stopped(wiphy, 0);
3420 free_req:
3421 kfree(request);
3422 return err;
3423 }
3424
3425 static int
3426 brcmf_cfg80211_sched_scan_start(struct wiphy *wiphy,
3427 struct net_device *ndev,
3428 struct cfg80211_sched_scan_request *req)
3429 {
3430 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3431 struct brcmf_if *ifp = netdev_priv(ndev);
3432 struct brcmf_pub *drvr = cfg->pub;
3433
3434 brcmf_dbg(SCAN, "Enter: n_match_sets=%d n_ssids=%d\n",
3435 req->n_match_sets, req->n_ssids);
3436
3437 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
3438 bphy_err(drvr, "Scanning suppressed: status=%lu\n",
3439 cfg->scan_status);
3440 return -EAGAIN;
3441 }
3442
3443 if (req->n_match_sets <= 0) {
3444 brcmf_dbg(SCAN, "invalid number of matchsets specified: %d\n",
3445 req->n_match_sets);
3446 return -EINVAL;
3447 }
3448
3449 return brcmf_pno_start_sched_scan(ifp, req);
3450 }
3451
3452 static int brcmf_cfg80211_sched_scan_stop(struct wiphy *wiphy,
3453 struct net_device *ndev, u64 reqid)
3454 {
3455 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3456 struct brcmf_if *ifp = netdev_priv(ndev);
3457
3458 brcmf_dbg(SCAN, "enter\n");
3459 brcmf_pno_stop_sched_scan(ifp, reqid);
3460 if (cfg->int_escan_map)
3461 brcmf_notify_escan_complete(cfg, ifp, true, true);
3462 return 0;
3463 }
3464
3465 static __always_inline void brcmf_delay(u32 ms)
3466 {
3467 if (ms < 1000 / HZ) {
3468 cond_resched();
3469 mdelay(ms);
3470 } else {
3471 msleep(ms);
3472 }
3473 }
3474
3475 static s32 brcmf_config_wowl_pattern(struct brcmf_if *ifp, u8 cmd[4],
3476 u8 *pattern, u32 patternsize, u8 *mask,
3477 u32 packet_offset)
3478 {
3479 struct brcmf_fil_wowl_pattern_le *filter;
3480 u32 masksize;
3481 u32 patternoffset;
3482 u8 *buf;
3483 u32 bufsize;
3484 s32 ret;
3485
3486 masksize = (patternsize + 7) / 8;
3487 patternoffset = sizeof(*filter) - sizeof(filter->cmd) + masksize;
3488
3489 bufsize = sizeof(*filter) + patternsize + masksize;
3490 buf = kzalloc(bufsize, GFP_KERNEL);
3491 if (!buf)
3492 return -ENOMEM;
3493 filter = (struct brcmf_fil_wowl_pattern_le *)buf;
3494
3495 memcpy(filter->cmd, cmd, 4);
3496 filter->masksize = cpu_to_le32(masksize);
3497 filter->offset = cpu_to_le32(packet_offset);
3498 filter->patternoffset = cpu_to_le32(patternoffset);
3499 filter->patternsize = cpu_to_le32(patternsize);
3500 filter->type = cpu_to_le32(BRCMF_WOWL_PATTERN_TYPE_BITMAP);
3501
3502 if ((mask) && (masksize))
3503 memcpy(buf + sizeof(*filter), mask, masksize);
3504 if ((pattern) && (patternsize))
3505 memcpy(buf + sizeof(*filter) + masksize, pattern, patternsize);
3506
3507 ret = brcmf_fil_iovar_data_set(ifp, "wowl_pattern", buf, bufsize);
3508
3509 kfree(buf);
3510 return ret;
3511 }
3512
3513 static s32
3514 brcmf_wowl_nd_results(struct brcmf_if *ifp, const struct brcmf_event_msg *e,
3515 void *data)
3516 {
3517 struct brcmf_pub *drvr = ifp->drvr;
3518 struct brcmf_cfg80211_info *cfg = drvr->config;
3519 struct brcmf_pno_scanresults_le *pfn_result;
3520 struct brcmf_pno_net_info_le *netinfo;
3521
3522 brcmf_dbg(SCAN, "Enter\n");
3523
3524 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) {
3525 brcmf_dbg(SCAN, "Event data to small. Ignore\n");
3526 return 0;
3527 }
3528
3529 pfn_result = (struct brcmf_pno_scanresults_le *)data;
3530
3531 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
3532 brcmf_dbg(SCAN, "PFN NET LOST event. Ignore\n");
3533 return 0;
3534 }
3535
3536 if (le32_to_cpu(pfn_result->count) < 1) {
3537 bphy_err(drvr, "Invalid result count, expected 1 (%d)\n",
3538 le32_to_cpu(pfn_result->count));
3539 return -EINVAL;
3540 }
3541
3542 netinfo = brcmf_get_netinfo_array(pfn_result);
3543 if (netinfo->SSID_len > IEEE80211_MAX_SSID_LEN)
3544 netinfo->SSID_len = IEEE80211_MAX_SSID_LEN;
3545 memcpy(cfg->wowl.nd->ssid.ssid, netinfo->SSID, netinfo->SSID_len);
3546 cfg->wowl.nd->ssid.ssid_len = netinfo->SSID_len;
3547 cfg->wowl.nd->n_channels = 1;
3548 cfg->wowl.nd->channels[0] =
3549 ieee80211_channel_to_frequency(netinfo->channel,
3550 netinfo->channel <= CH_MAX_2G_CHANNEL ?
3551 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ);
3552 cfg->wowl.nd_info->n_matches = 1;
3553 cfg->wowl.nd_info->matches[0] = cfg->wowl.nd;
3554
3555
3556 cfg->wowl.nd_data_completed = true;
3557 wake_up(&cfg->wowl.nd_data_wait);
3558
3559 return 0;
3560 }
3561
3562 #ifdef CONFIG_PM
3563
3564 static void brcmf_report_wowl_wakeind(struct wiphy *wiphy, struct brcmf_if *ifp)
3565 {
3566 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3567 struct brcmf_pub *drvr = cfg->pub;
3568 struct brcmf_wowl_wakeind_le wake_ind_le;
3569 struct cfg80211_wowlan_wakeup wakeup_data;
3570 struct cfg80211_wowlan_wakeup *wakeup;
3571 u32 wakeind;
3572 s32 err;
3573 int timeout;
3574
3575 err = brcmf_fil_iovar_data_get(ifp, "wowl_wakeind", &wake_ind_le,
3576 sizeof(wake_ind_le));
3577 if (err) {
3578 bphy_err(drvr, "Get wowl_wakeind failed, err = %d\n", err);
3579 return;
3580 }
3581
3582 wakeind = le32_to_cpu(wake_ind_le.ucode_wakeind);
3583 if (wakeind & (BRCMF_WOWL_MAGIC | BRCMF_WOWL_DIS | BRCMF_WOWL_BCN |
3584 BRCMF_WOWL_RETR | BRCMF_WOWL_NET |
3585 BRCMF_WOWL_PFN_FOUND)) {
3586 wakeup = &wakeup_data;
3587 memset(&wakeup_data, 0, sizeof(wakeup_data));
3588 wakeup_data.pattern_idx = -1;
3589
3590 if (wakeind & BRCMF_WOWL_MAGIC) {
3591 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_MAGIC\n");
3592 wakeup_data.magic_pkt = true;
3593 }
3594 if (wakeind & BRCMF_WOWL_DIS) {
3595 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_DIS\n");
3596 wakeup_data.disconnect = true;
3597 }
3598 if (wakeind & BRCMF_WOWL_BCN) {
3599 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_BCN\n");
3600 wakeup_data.disconnect = true;
3601 }
3602 if (wakeind & BRCMF_WOWL_RETR) {
3603 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_RETR\n");
3604 wakeup_data.disconnect = true;
3605 }
3606 if (wakeind & BRCMF_WOWL_NET) {
3607 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_NET\n");
3608
3609
3610
3611 wakeup_data.pattern_idx = 0;
3612 }
3613 if (wakeind & BRCMF_WOWL_PFN_FOUND) {
3614 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_PFN_FOUND\n");
3615 timeout = wait_event_timeout(cfg->wowl.nd_data_wait,
3616 cfg->wowl.nd_data_completed,
3617 BRCMF_ND_INFO_TIMEOUT);
3618 if (!timeout)
3619 bphy_err(drvr, "No result for wowl net detect\n");
3620 else
3621 wakeup_data.net_detect = cfg->wowl.nd_info;
3622 }
3623 if (wakeind & BRCMF_WOWL_GTK_FAILURE) {
3624 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_GTK_FAILURE\n");
3625 wakeup_data.gtk_rekey_failure = true;
3626 }
3627 } else {
3628 wakeup = NULL;
3629 }
3630 cfg80211_report_wowlan_wakeup(&ifp->vif->wdev, wakeup, GFP_KERNEL);
3631 }
3632
3633 #else
3634
3635 static void brcmf_report_wowl_wakeind(struct wiphy *wiphy, struct brcmf_if *ifp)
3636 {
3637 }
3638
3639 #endif
3640
3641 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
3642 {
3643 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3644 struct net_device *ndev = cfg_to_ndev(cfg);
3645 struct brcmf_if *ifp = netdev_priv(ndev);
3646
3647 brcmf_dbg(TRACE, "Enter\n");
3648
3649 if (cfg->wowl.active) {
3650 brcmf_report_wowl_wakeind(wiphy, ifp);
3651 brcmf_fil_iovar_int_set(ifp, "wowl_clear", 0);
3652 brcmf_config_wowl_pattern(ifp, "clr", NULL, 0, NULL, 0);
3653 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_ARP_ND))
3654 brcmf_configure_arp_nd_offload(ifp, true);
3655 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM,
3656 cfg->wowl.pre_pmmode);
3657 cfg->wowl.active = false;
3658 if (cfg->wowl.nd_enabled) {
3659 brcmf_cfg80211_sched_scan_stop(cfg->wiphy, ifp->ndev, 0);
3660 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND);
3661 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
3662 brcmf_notify_sched_scan_results);
3663 cfg->wowl.nd_enabled = false;
3664 }
3665 }
3666 return 0;
3667 }
3668
3669 static void brcmf_configure_wowl(struct brcmf_cfg80211_info *cfg,
3670 struct brcmf_if *ifp,
3671 struct cfg80211_wowlan *wowl)
3672 {
3673 u32 wowl_config;
3674 struct brcmf_wowl_wakeind_le wowl_wakeind;
3675 u32 i;
3676
3677 brcmf_dbg(TRACE, "Suspend, wowl config.\n");
3678
3679 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_ARP_ND))
3680 brcmf_configure_arp_nd_offload(ifp, false);
3681 brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_PM, &cfg->wowl.pre_pmmode);
3682 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, PM_MAX);
3683
3684 wowl_config = 0;
3685 if (wowl->disconnect)
3686 wowl_config = BRCMF_WOWL_DIS | BRCMF_WOWL_BCN | BRCMF_WOWL_RETR;
3687 if (wowl->magic_pkt)
3688 wowl_config |= BRCMF_WOWL_MAGIC;
3689 if ((wowl->patterns) && (wowl->n_patterns)) {
3690 wowl_config |= BRCMF_WOWL_NET;
3691 for (i = 0; i < wowl->n_patterns; i++) {
3692 brcmf_config_wowl_pattern(ifp, "add",
3693 (u8 *)wowl->patterns[i].pattern,
3694 wowl->patterns[i].pattern_len,
3695 (u8 *)wowl->patterns[i].mask,
3696 wowl->patterns[i].pkt_offset);
3697 }
3698 }
3699 if (wowl->nd_config) {
3700 brcmf_cfg80211_sched_scan_start(cfg->wiphy, ifp->ndev,
3701 wowl->nd_config);
3702 wowl_config |= BRCMF_WOWL_PFN_FOUND;
3703
3704 cfg->wowl.nd_data_completed = false;
3705 cfg->wowl.nd_enabled = true;
3706
3707 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND);
3708 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
3709 brcmf_wowl_nd_results);
3710 }
3711 if (wowl->gtk_rekey_failure)
3712 wowl_config |= BRCMF_WOWL_GTK_FAILURE;
3713 if (!test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))
3714 wowl_config |= BRCMF_WOWL_UNASSOC;
3715
3716 memcpy(&wowl_wakeind, "clear", 6);
3717 brcmf_fil_iovar_data_set(ifp, "wowl_wakeind", &wowl_wakeind,
3718 sizeof(wowl_wakeind));
3719 brcmf_fil_iovar_int_set(ifp, "wowl", wowl_config);
3720 brcmf_fil_iovar_int_set(ifp, "wowl_activate", 1);
3721 brcmf_bus_wowl_config(cfg->pub->bus_if, true);
3722 cfg->wowl.active = true;
3723 }
3724
3725 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
3726 struct cfg80211_wowlan *wowl)
3727 {
3728 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3729 struct net_device *ndev = cfg_to_ndev(cfg);
3730 struct brcmf_if *ifp = netdev_priv(ndev);
3731 struct brcmf_cfg80211_vif *vif;
3732
3733 brcmf_dbg(TRACE, "Enter\n");
3734
3735
3736
3737
3738 if (!check_vif_up(ifp->vif))
3739 goto exit;
3740
3741
3742 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO))
3743 brcmf_cfg80211_sched_scan_stop(wiphy, ndev, 0);
3744
3745
3746 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
3747 brcmf_abort_scanning(cfg);
3748
3749 if (wowl == NULL) {
3750 brcmf_bus_wowl_config(cfg->pub->bus_if, false);
3751 list_for_each_entry(vif, &cfg->vif_list, list) {
3752 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state))
3753 continue;
3754
3755
3756
3757
3758 brcmf_link_down(vif, WLAN_REASON_UNSPECIFIED);
3759
3760
3761
3762
3763 brcmf_delay(500);
3764 }
3765
3766 brcmf_set_mpc(ifp, 1);
3767
3768 } else {
3769
3770 brcmf_configure_wowl(cfg, ifp, wowl);
3771 }
3772
3773 exit:
3774 brcmf_dbg(TRACE, "Exit\n");
3775
3776 cfg->scan_status = 0;
3777 return 0;
3778 }
3779
3780 static __used s32
3781 brcmf_update_pmklist(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp)
3782 {
3783 struct brcmf_pmk_list_le *pmk_list;
3784 int i;
3785 u32 npmk;
3786 s32 err;
3787
3788 pmk_list = &cfg->pmk_list;
3789 npmk = le32_to_cpu(pmk_list->npmk);
3790
3791 brcmf_dbg(CONN, "No of elements %d\n", npmk);
3792 for (i = 0; i < npmk; i++)
3793 brcmf_dbg(CONN, "PMK[%d]: %pM\n", i, &pmk_list->pmk[i].bssid);
3794
3795 err = brcmf_fil_iovar_data_set(ifp, "pmkid_info", pmk_list,
3796 sizeof(*pmk_list));
3797
3798 return err;
3799 }
3800
3801 static s32
3802 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev,
3803 struct cfg80211_pmksa *pmksa)
3804 {
3805 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3806 struct brcmf_if *ifp = netdev_priv(ndev);
3807 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0];
3808 struct brcmf_pub *drvr = cfg->pub;
3809 s32 err;
3810 u32 npmk, i;
3811
3812 brcmf_dbg(TRACE, "Enter\n");
3813 if (!check_vif_up(ifp->vif))
3814 return -EIO;
3815
3816 npmk = le32_to_cpu(cfg->pmk_list.npmk);
3817 for (i = 0; i < npmk; i++)
3818 if (!memcmp(pmksa->bssid, pmk[i].bssid, ETH_ALEN))
3819 break;
3820 if (i < BRCMF_MAXPMKID) {
3821 memcpy(pmk[i].bssid, pmksa->bssid, ETH_ALEN);
3822 memcpy(pmk[i].pmkid, pmksa->pmkid, WLAN_PMKID_LEN);
3823 if (i == npmk) {
3824 npmk++;
3825 cfg->pmk_list.npmk = cpu_to_le32(npmk);
3826 }
3827 } else {
3828 bphy_err(drvr, "Too many PMKSA entries cached %d\n", npmk);
3829 return -EINVAL;
3830 }
3831
3832 brcmf_dbg(CONN, "set_pmksa - PMK bssid: %pM =\n", pmk[npmk].bssid);
3833 for (i = 0; i < WLAN_PMKID_LEN; i += 4)
3834 brcmf_dbg(CONN, "%02x %02x %02x %02x\n", pmk[npmk].pmkid[i],
3835 pmk[npmk].pmkid[i + 1], pmk[npmk].pmkid[i + 2],
3836 pmk[npmk].pmkid[i + 3]);
3837
3838 err = brcmf_update_pmklist(cfg, ifp);
3839
3840 brcmf_dbg(TRACE, "Exit\n");
3841 return err;
3842 }
3843
3844 static s32
3845 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *ndev,
3846 struct cfg80211_pmksa *pmksa)
3847 {
3848 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3849 struct brcmf_if *ifp = netdev_priv(ndev);
3850 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0];
3851 struct brcmf_pub *drvr = cfg->pub;
3852 s32 err;
3853 u32 npmk, i;
3854
3855 brcmf_dbg(TRACE, "Enter\n");
3856 if (!check_vif_up(ifp->vif))
3857 return -EIO;
3858
3859 brcmf_dbg(CONN, "del_pmksa - PMK bssid = %pM\n", pmksa->bssid);
3860
3861 npmk = le32_to_cpu(cfg->pmk_list.npmk);
3862 for (i = 0; i < npmk; i++)
3863 if (!memcmp(pmksa->bssid, pmk[i].bssid, ETH_ALEN))
3864 break;
3865
3866 if ((npmk > 0) && (i < npmk)) {
3867 for (; i < (npmk - 1); i++) {
3868 memcpy(&pmk[i].bssid, &pmk[i + 1].bssid, ETH_ALEN);
3869 memcpy(&pmk[i].pmkid, &pmk[i + 1].pmkid,
3870 WLAN_PMKID_LEN);
3871 }
3872 memset(&pmk[i], 0, sizeof(*pmk));
3873 cfg->pmk_list.npmk = cpu_to_le32(npmk - 1);
3874 } else {
3875 bphy_err(drvr, "Cache entry not found\n");
3876 return -EINVAL;
3877 }
3878
3879 err = brcmf_update_pmklist(cfg, ifp);
3880
3881 brcmf_dbg(TRACE, "Exit\n");
3882 return err;
3883
3884 }
3885
3886 static s32
3887 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev)
3888 {
3889 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3890 struct brcmf_if *ifp = netdev_priv(ndev);
3891 s32 err;
3892
3893 brcmf_dbg(TRACE, "Enter\n");
3894 if (!check_vif_up(ifp->vif))
3895 return -EIO;
3896
3897 memset(&cfg->pmk_list, 0, sizeof(cfg->pmk_list));
3898 err = brcmf_update_pmklist(cfg, ifp);
3899
3900 brcmf_dbg(TRACE, "Exit\n");
3901 return err;
3902
3903 }
3904
3905 static s32 brcmf_configure_opensecurity(struct brcmf_if *ifp)
3906 {
3907 struct brcmf_pub *drvr = ifp->drvr;
3908 s32 err;
3909 s32 wpa_val;
3910
3911
3912 err = brcmf_fil_bsscfg_int_set(ifp, "auth", 0);
3913 if (err < 0) {
3914 bphy_err(drvr, "auth error %d\n", err);
3915 return err;
3916 }
3917
3918 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", 0);
3919 if (err < 0) {
3920 bphy_err(drvr, "wsec error %d\n", err);
3921 return err;
3922 }
3923
3924 if (brcmf_is_ibssmode(ifp->vif))
3925 wpa_val = WPA_AUTH_NONE;
3926 else
3927 wpa_val = WPA_AUTH_DISABLED;
3928 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", wpa_val);
3929 if (err < 0) {
3930 bphy_err(drvr, "wpa_auth error %d\n", err);
3931 return err;
3932 }
3933
3934 return 0;
3935 }
3936
3937 static bool brcmf_valid_wpa_oui(u8 *oui, bool is_rsn_ie)
3938 {
3939 if (is_rsn_ie)
3940 return (memcmp(oui, RSN_OUI, TLV_OUI_LEN) == 0);
3941
3942 return (memcmp(oui, WPA_OUI, TLV_OUI_LEN) == 0);
3943 }
3944
3945 static s32
3946 brcmf_configure_wpaie(struct brcmf_if *ifp,
3947 const struct brcmf_vs_tlv *wpa_ie,
3948 bool is_rsn_ie)
3949 {
3950 struct brcmf_pub *drvr = ifp->drvr;
3951 u32 auth = 0;
3952 u16 count;
3953 s32 err = 0;
3954 s32 len;
3955 u32 i;
3956 u32 wsec;
3957 u32 pval = 0;
3958 u32 gval = 0;
3959 u32 wpa_auth = 0;
3960 u32 offset;
3961 u8 *data;
3962 u16 rsn_cap;
3963 u32 wme_bss_disable;
3964 u32 mfp;
3965
3966 brcmf_dbg(TRACE, "Enter\n");
3967 if (wpa_ie == NULL)
3968 goto exit;
3969
3970 len = wpa_ie->len + TLV_HDR_LEN;
3971 data = (u8 *)wpa_ie;
3972 offset = TLV_HDR_LEN;
3973 if (!is_rsn_ie)
3974 offset += VS_IE_FIXED_HDR_LEN;
3975 else
3976 offset += WPA_IE_VERSION_LEN;
3977
3978
3979 if (offset + WPA_IE_MIN_OUI_LEN > len) {
3980 err = -EINVAL;
3981 bphy_err(drvr, "no multicast cipher suite\n");
3982 goto exit;
3983 }
3984
3985 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3986 err = -EINVAL;
3987 bphy_err(drvr, "ivalid OUI\n");
3988 goto exit;
3989 }
3990 offset += TLV_OUI_LEN;
3991
3992
3993 switch (data[offset]) {
3994 case WPA_CIPHER_NONE:
3995 gval = 0;
3996 break;
3997 case WPA_CIPHER_WEP_40:
3998 case WPA_CIPHER_WEP_104:
3999 gval = WEP_ENABLED;
4000 break;
4001 case WPA_CIPHER_TKIP:
4002 gval = TKIP_ENABLED;
4003 break;
4004 case WPA_CIPHER_AES_CCM:
4005 gval = AES_ENABLED;
4006 break;
4007 default:
4008 err = -EINVAL;
4009 bphy_err(drvr, "Invalid multi cast cipher info\n");
4010 goto exit;
4011 }
4012
4013 offset++;
4014
4015 count = data[offset] + (data[offset + 1] << 8);
4016 offset += WPA_IE_SUITE_COUNT_LEN;
4017
4018 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
4019 err = -EINVAL;
4020 bphy_err(drvr, "no unicast cipher suite\n");
4021 goto exit;
4022 }
4023 for (i = 0; i < count; i++) {
4024 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
4025 err = -EINVAL;
4026 bphy_err(drvr, "ivalid OUI\n");
4027 goto exit;
4028 }
4029 offset += TLV_OUI_LEN;
4030 switch (data[offset]) {
4031 case WPA_CIPHER_NONE:
4032 break;
4033 case WPA_CIPHER_WEP_40:
4034 case WPA_CIPHER_WEP_104:
4035 pval |= WEP_ENABLED;
4036 break;
4037 case WPA_CIPHER_TKIP:
4038 pval |= TKIP_ENABLED;
4039 break;
4040 case WPA_CIPHER_AES_CCM:
4041 pval |= AES_ENABLED;
4042 break;
4043 default:
4044 bphy_err(drvr, "Invalid unicast security info\n");
4045 }
4046 offset++;
4047 }
4048
4049 count = data[offset] + (data[offset + 1] << 8);
4050 offset += WPA_IE_SUITE_COUNT_LEN;
4051
4052 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
4053 err = -EINVAL;
4054 bphy_err(drvr, "no auth key mgmt suite\n");
4055 goto exit;
4056 }
4057 for (i = 0; i < count; i++) {
4058 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
4059 err = -EINVAL;
4060 bphy_err(drvr, "ivalid OUI\n");
4061 goto exit;
4062 }
4063 offset += TLV_OUI_LEN;
4064 switch (data[offset]) {
4065 case RSN_AKM_NONE:
4066 brcmf_dbg(TRACE, "RSN_AKM_NONE\n");
4067 wpa_auth |= WPA_AUTH_NONE;
4068 break;
4069 case RSN_AKM_UNSPECIFIED:
4070 brcmf_dbg(TRACE, "RSN_AKM_UNSPECIFIED\n");
4071 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_UNSPECIFIED) :
4072 (wpa_auth |= WPA_AUTH_UNSPECIFIED);
4073 break;
4074 case RSN_AKM_PSK:
4075 brcmf_dbg(TRACE, "RSN_AKM_PSK\n");
4076 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_PSK) :
4077 (wpa_auth |= WPA_AUTH_PSK);
4078 break;
4079 case RSN_AKM_SHA256_PSK:
4080 brcmf_dbg(TRACE, "RSN_AKM_MFP_PSK\n");
4081 wpa_auth |= WPA2_AUTH_PSK_SHA256;
4082 break;
4083 case RSN_AKM_SHA256_1X:
4084 brcmf_dbg(TRACE, "RSN_AKM_MFP_1X\n");
4085 wpa_auth |= WPA2_AUTH_1X_SHA256;
4086 break;
4087 default:
4088 bphy_err(drvr, "Invalid key mgmt info\n");
4089 }
4090 offset++;
4091 }
4092
4093 mfp = BRCMF_MFP_NONE;
4094 if (is_rsn_ie) {
4095 wme_bss_disable = 1;
4096 if ((offset + RSN_CAP_LEN) <= len) {
4097 rsn_cap = data[offset] + (data[offset + 1] << 8);
4098 if (rsn_cap & RSN_CAP_PTK_REPLAY_CNTR_MASK)
4099 wme_bss_disable = 0;
4100 if (rsn_cap & RSN_CAP_MFPR_MASK) {
4101 brcmf_dbg(TRACE, "MFP Required\n");
4102 mfp = BRCMF_MFP_REQUIRED;
4103
4104
4105
4106
4107 if (!(wpa_auth & (WPA2_AUTH_PSK_SHA256 |
4108 WPA2_AUTH_1X_SHA256))) {
4109 err = -EINVAL;
4110 goto exit;
4111 }
4112
4113
4114
4115
4116 if (wpa_auth & WPA2_AUTH_PSK_SHA256)
4117 wpa_auth |= WPA2_AUTH_PSK;
4118 else if (wpa_auth & WPA2_AUTH_1X_SHA256)
4119 wpa_auth |= WPA2_AUTH_UNSPECIFIED;
4120 } else if (rsn_cap & RSN_CAP_MFPC_MASK) {
4121 brcmf_dbg(TRACE, "MFP Capable\n");
4122 mfp = BRCMF_MFP_CAPABLE;
4123 }
4124 }
4125 offset += RSN_CAP_LEN;
4126
4127 err = brcmf_fil_bsscfg_int_set(ifp, "wme_bss_disable",
4128 wme_bss_disable);
4129 if (err < 0) {
4130 bphy_err(drvr, "wme_bss_disable error %d\n", err);
4131 goto exit;
4132 }
4133
4134
4135 offset += RSN_PMKID_COUNT_LEN;
4136
4137
4138 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP) &&
4139 ((offset + WPA_IE_MIN_OUI_LEN) <= len)) {
4140 err = brcmf_fil_bsscfg_data_set(ifp, "bip",
4141 &data[offset],
4142 WPA_IE_MIN_OUI_LEN);
4143 if (err < 0) {
4144 bphy_err(drvr, "bip error %d\n", err);
4145 goto exit;
4146 }
4147 }
4148 }
4149
4150 wsec = (pval | gval | SES_OW_ENABLED);
4151
4152
4153 err = brcmf_fil_bsscfg_int_set(ifp, "auth", auth);
4154 if (err < 0) {
4155 bphy_err(drvr, "auth error %d\n", err);
4156 goto exit;
4157 }
4158
4159 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
4160 if (err < 0) {
4161 bphy_err(drvr, "wsec error %d\n", err);
4162 goto exit;
4163 }
4164
4165
4166
4167 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP)) {
4168 err = brcmf_fil_bsscfg_int_set(ifp, "mfp", mfp);
4169 if (err < 0) {
4170 bphy_err(drvr, "mfp error %d\n", err);
4171 goto exit;
4172 }
4173 }
4174
4175 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", wpa_auth);
4176 if (err < 0) {
4177 bphy_err(drvr, "wpa_auth error %d\n", err);
4178 goto exit;
4179 }
4180
4181 exit:
4182 return err;
4183 }
4184
4185 static s32
4186 brcmf_parse_vndr_ies(const u8 *vndr_ie_buf, u32 vndr_ie_len,
4187 struct parsed_vndr_ies *vndr_ies)
4188 {
4189 struct brcmf_vs_tlv *vndrie;
4190 struct brcmf_tlv *ie;
4191 struct parsed_vndr_ie_info *parsed_info;
4192 s32 remaining_len;
4193
4194 remaining_len = (s32)vndr_ie_len;
4195 memset(vndr_ies, 0, sizeof(*vndr_ies));
4196
4197 ie = (struct brcmf_tlv *)vndr_ie_buf;
4198 while (ie) {
4199 if (ie->id != WLAN_EID_VENDOR_SPECIFIC)
4200 goto next;
4201 vndrie = (struct brcmf_vs_tlv *)ie;
4202
4203 if (vndrie->len < (VS_IE_FIXED_HDR_LEN - TLV_HDR_LEN + 1)) {
4204 brcmf_err("invalid vndr ie. length is too small %d\n",
4205 vndrie->len);
4206 goto next;
4207 }
4208
4209 if (!memcmp(vndrie->oui, (u8 *)WPA_OUI, TLV_OUI_LEN) &&
4210 ((vndrie->oui_type == WPA_OUI_TYPE) ||
4211 (vndrie->oui_type == WME_OUI_TYPE))) {
4212 brcmf_dbg(TRACE, "Found WPA/WME oui. Do not add it\n");
4213 goto next;
4214 }
4215
4216 parsed_info = &vndr_ies->ie_info[vndr_ies->count];
4217
4218
4219 parsed_info->ie_ptr = (char *)vndrie;
4220 parsed_info->ie_len = vndrie->len + TLV_HDR_LEN;
4221 memcpy(&parsed_info->vndrie, vndrie, sizeof(*vndrie));
4222
4223 vndr_ies->count++;
4224
4225 brcmf_dbg(TRACE, "** OUI %3ph, type 0x%02x\n",
4226 parsed_info->vndrie.oui,
4227 parsed_info->vndrie.oui_type);
4228
4229 if (vndr_ies->count >= VNDR_IE_PARSE_LIMIT)
4230 break;
4231 next:
4232 remaining_len -= (ie->len + TLV_HDR_LEN);
4233 if (remaining_len <= TLV_HDR_LEN)
4234 ie = NULL;
4235 else
4236 ie = (struct brcmf_tlv *)(((u8 *)ie) + ie->len +
4237 TLV_HDR_LEN);
4238 }
4239 return 0;
4240 }
4241
4242 static u32
4243 brcmf_vndr_ie(u8 *iebuf, s32 pktflag, u8 *ie_ptr, u32 ie_len, s8 *add_del_cmd)
4244 {
4245 strscpy(iebuf, add_del_cmd, VNDR_IE_CMD_LEN);
4246
4247 put_unaligned_le32(1, &iebuf[VNDR_IE_COUNT_OFFSET]);
4248
4249 put_unaligned_le32(pktflag, &iebuf[VNDR_IE_PKTFLAG_OFFSET]);
4250
4251 memcpy(&iebuf[VNDR_IE_VSIE_OFFSET], ie_ptr, ie_len);
4252
4253 return ie_len + VNDR_IE_HDR_SIZE;
4254 }
4255
4256 s32 brcmf_vif_set_mgmt_ie(struct brcmf_cfg80211_vif *vif, s32 pktflag,
4257 const u8 *vndr_ie_buf, u32 vndr_ie_len)
4258 {
4259 struct brcmf_pub *drvr;
4260 struct brcmf_if *ifp;
4261 struct vif_saved_ie *saved_ie;
4262 s32 err = 0;
4263 u8 *iovar_ie_buf;
4264 u8 *curr_ie_buf;
4265 u8 *mgmt_ie_buf = NULL;
4266 int mgmt_ie_buf_len;
4267 u32 *mgmt_ie_len;
4268 u32 del_add_ie_buf_len = 0;
4269 u32 total_ie_buf_len = 0;
4270 u32 parsed_ie_buf_len = 0;
4271 struct parsed_vndr_ies old_vndr_ies;
4272 struct parsed_vndr_ies new_vndr_ies;
4273 struct parsed_vndr_ie_info *vndrie_info;
4274 s32 i;
4275 u8 *ptr;
4276 int remained_buf_len;
4277
4278 if (!vif)
4279 return -ENODEV;
4280 ifp = vif->ifp;
4281 drvr = ifp->drvr;
4282 saved_ie = &vif->saved_ie;
4283
4284 brcmf_dbg(TRACE, "bsscfgidx %d, pktflag : 0x%02X\n", ifp->bsscfgidx,
4285 pktflag);
4286 iovar_ie_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
4287 if (!iovar_ie_buf)
4288 return -ENOMEM;
4289 curr_ie_buf = iovar_ie_buf;
4290 switch (pktflag) {
4291 case BRCMF_VNDR_IE_PRBREQ_FLAG:
4292 mgmt_ie_buf = saved_ie->probe_req_ie;
4293 mgmt_ie_len = &saved_ie->probe_req_ie_len;
4294 mgmt_ie_buf_len = sizeof(saved_ie->probe_req_ie);
4295 break;
4296 case BRCMF_VNDR_IE_PRBRSP_FLAG:
4297 mgmt_ie_buf = saved_ie->probe_res_ie;
4298 mgmt_ie_len = &saved_ie->probe_res_ie_len;
4299 mgmt_ie_buf_len = sizeof(saved_ie->probe_res_ie);
4300 break;
4301 case BRCMF_VNDR_IE_BEACON_FLAG:
4302 mgmt_ie_buf = saved_ie->beacon_ie;
4303 mgmt_ie_len = &saved_ie->beacon_ie_len;
4304 mgmt_ie_buf_len = sizeof(saved_ie->beacon_ie);
4305 break;
4306 case BRCMF_VNDR_IE_ASSOCREQ_FLAG:
4307 mgmt_ie_buf = saved_ie->assoc_req_ie;
4308 mgmt_ie_len = &saved_ie->assoc_req_ie_len;
4309 mgmt_ie_buf_len = sizeof(saved_ie->assoc_req_ie);
4310 break;
4311 default:
4312 err = -EPERM;
4313 bphy_err(drvr, "not suitable type\n");
4314 goto exit;
4315 }
4316
4317 if (vndr_ie_len > mgmt_ie_buf_len) {
4318 err = -ENOMEM;
4319 bphy_err(drvr, "extra IE size too big\n");
4320 goto exit;
4321 }
4322
4323
4324 if (vndr_ie_buf && vndr_ie_len && curr_ie_buf) {
4325 ptr = curr_ie_buf;
4326 brcmf_parse_vndr_ies(vndr_ie_buf, vndr_ie_len, &new_vndr_ies);
4327 for (i = 0; i < new_vndr_ies.count; i++) {
4328 vndrie_info = &new_vndr_ies.ie_info[i];
4329 memcpy(ptr + parsed_ie_buf_len, vndrie_info->ie_ptr,
4330 vndrie_info->ie_len);
4331 parsed_ie_buf_len += vndrie_info->ie_len;
4332 }
4333 }
4334
4335 if (mgmt_ie_buf && *mgmt_ie_len) {
4336 if (parsed_ie_buf_len && (parsed_ie_buf_len == *mgmt_ie_len) &&
4337 (memcmp(mgmt_ie_buf, curr_ie_buf,
4338 parsed_ie_buf_len) == 0)) {
4339 brcmf_dbg(TRACE, "Previous mgmt IE equals to current IE\n");
4340 goto exit;
4341 }
4342
4343
4344 brcmf_parse_vndr_ies(mgmt_ie_buf, *mgmt_ie_len, &old_vndr_ies);
4345
4346
4347 for (i = 0; i < old_vndr_ies.count; i++) {
4348 vndrie_info = &old_vndr_ies.ie_info[i];
4349
4350 brcmf_dbg(TRACE, "DEL ID : %d, Len: %d , OUI:%3ph\n",
4351 vndrie_info->vndrie.id,
4352 vndrie_info->vndrie.len,
4353 vndrie_info->vndrie.oui);
4354
4355 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
4356 vndrie_info->ie_ptr,
4357 vndrie_info->ie_len,
4358 "del");
4359 curr_ie_buf += del_add_ie_buf_len;
4360 total_ie_buf_len += del_add_ie_buf_len;
4361 }
4362 }
4363
4364 *mgmt_ie_len = 0;
4365
4366 if (mgmt_ie_buf && parsed_ie_buf_len) {
4367 ptr = mgmt_ie_buf;
4368
4369 remained_buf_len = mgmt_ie_buf_len;
4370
4371
4372 for (i = 0; i < new_vndr_ies.count; i++) {
4373 vndrie_info = &new_vndr_ies.ie_info[i];
4374
4375
4376 if (remained_buf_len < (vndrie_info->vndrie.len +
4377 VNDR_IE_VSIE_OFFSET)) {
4378 bphy_err(drvr, "no space in mgmt_ie_buf: len left %d",
4379 remained_buf_len);
4380 break;
4381 }
4382 remained_buf_len -= (vndrie_info->ie_len +
4383 VNDR_IE_VSIE_OFFSET);
4384
4385 brcmf_dbg(TRACE, "ADDED ID : %d, Len: %d, OUI:%3ph\n",
4386 vndrie_info->vndrie.id,
4387 vndrie_info->vndrie.len,
4388 vndrie_info->vndrie.oui);
4389
4390 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
4391 vndrie_info->ie_ptr,
4392 vndrie_info->ie_len,
4393 "add");
4394
4395
4396 memcpy(ptr + (*mgmt_ie_len), vndrie_info->ie_ptr,
4397 vndrie_info->ie_len);
4398 *mgmt_ie_len += vndrie_info->ie_len;
4399
4400 curr_ie_buf += del_add_ie_buf_len;
4401 total_ie_buf_len += del_add_ie_buf_len;
4402 }
4403 }
4404 if (total_ie_buf_len) {
4405 err = brcmf_fil_bsscfg_data_set(ifp, "vndr_ie", iovar_ie_buf,
4406 total_ie_buf_len);
4407 if (err)
4408 bphy_err(drvr, "vndr ie set error : %d\n", err);
4409 }
4410
4411 exit:
4412 kfree(iovar_ie_buf);
4413 return err;
4414 }
4415
4416 s32 brcmf_vif_clear_mgmt_ies(struct brcmf_cfg80211_vif *vif)
4417 {
4418 s32 pktflags[] = {
4419 BRCMF_VNDR_IE_PRBREQ_FLAG,
4420 BRCMF_VNDR_IE_PRBRSP_FLAG,
4421 BRCMF_VNDR_IE_BEACON_FLAG
4422 };
4423 int i;
4424
4425 for (i = 0; i < ARRAY_SIZE(pktflags); i++)
4426 brcmf_vif_set_mgmt_ie(vif, pktflags[i], NULL, 0);
4427
4428 memset(&vif->saved_ie, 0, sizeof(vif->saved_ie));
4429 return 0;
4430 }
4431
4432 static s32
4433 brcmf_config_ap_mgmt_ie(struct brcmf_cfg80211_vif *vif,
4434 struct cfg80211_beacon_data *beacon)
4435 {
4436 struct brcmf_pub *drvr = vif->ifp->drvr;
4437 s32 err;
4438
4439
4440 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_BEACON_FLAG,
4441 beacon->tail, beacon->tail_len);
4442 if (err) {
4443 bphy_err(drvr, "Set Beacon IE Failed\n");
4444 return err;
4445 }
4446 brcmf_dbg(TRACE, "Applied Vndr IEs for Beacon\n");
4447
4448
4449 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_PRBRSP_FLAG,
4450 beacon->proberesp_ies,
4451 beacon->proberesp_ies_len);
4452 if (err)
4453 bphy_err(drvr, "Set Probe Resp IE Failed\n");
4454 else
4455 brcmf_dbg(TRACE, "Applied Vndr IEs for Probe Resp\n");
4456
4457 return err;
4458 }
4459
4460 static s32
4461 brcmf_cfg80211_start_ap(struct wiphy *wiphy, struct net_device *ndev,
4462 struct cfg80211_ap_settings *settings)
4463 {
4464 s32 ie_offset;
4465 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4466 struct brcmf_if *ifp = netdev_priv(ndev);
4467 struct brcmf_pub *drvr = cfg->pub;
4468 const struct brcmf_tlv *ssid_ie;
4469 const struct brcmf_tlv *country_ie;
4470 struct brcmf_ssid_le ssid_le;
4471 s32 err = -EPERM;
4472 const struct brcmf_tlv *rsn_ie;
4473 const struct brcmf_vs_tlv *wpa_ie;
4474 struct brcmf_join_params join_params;
4475 enum nl80211_iftype dev_role;
4476 struct brcmf_fil_bss_enable_le bss_enable;
4477 u16 chanspec = chandef_to_chanspec(&cfg->d11inf, &settings->chandef);
4478 bool mbss;
4479 int is_11d;
4480 bool supports_11d;
4481
4482 brcmf_dbg(TRACE, "ctrlchn=%d, center=%d, bw=%d, beacon_interval=%d, dtim_period=%d,\n",
4483 settings->chandef.chan->hw_value,
4484 settings->chandef.center_freq1, settings->chandef.width,
4485 settings->beacon_interval, settings->dtim_period);
4486 brcmf_dbg(TRACE, "ssid=%s(%zu), auth_type=%d, inactivity_timeout=%d\n",
4487 settings->ssid, settings->ssid_len, settings->auth_type,
4488 settings->inactivity_timeout);
4489 dev_role = ifp->vif->wdev.iftype;
4490 mbss = ifp->vif->mbss;
4491
4492
4493 if (brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_REGULATORY,
4494 &ifp->vif->is_11d)) {
4495 is_11d = supports_11d = false;
4496 } else {
4497 country_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
4498 settings->beacon.tail_len,
4499 WLAN_EID_COUNTRY);
4500 is_11d = country_ie ? 1 : 0;
4501 supports_11d = true;
4502 }
4503
4504 memset(&ssid_le, 0, sizeof(ssid_le));
4505 if (settings->ssid == NULL || settings->ssid_len == 0) {
4506 ie_offset = DOT11_MGMT_HDR_LEN + DOT11_BCN_PRB_FIXED_LEN;
4507 ssid_ie = brcmf_parse_tlvs(
4508 (u8 *)&settings->beacon.head[ie_offset],
4509 settings->beacon.head_len - ie_offset,
4510 WLAN_EID_SSID);
4511 if (!ssid_ie || ssid_ie->len > IEEE80211_MAX_SSID_LEN)
4512 return -EINVAL;
4513
4514 memcpy(ssid_le.SSID, ssid_ie->data, ssid_ie->len);
4515 ssid_le.SSID_len = cpu_to_le32(ssid_ie->len);
4516 brcmf_dbg(TRACE, "SSID is (%s) in Head\n", ssid_le.SSID);
4517 } else {
4518 memcpy(ssid_le.SSID, settings->ssid, settings->ssid_len);
4519 ssid_le.SSID_len = cpu_to_le32((u32)settings->ssid_len);
4520 }
4521
4522 if (!mbss) {
4523 brcmf_set_mpc(ifp, 0);
4524 brcmf_configure_arp_nd_offload(ifp, false);
4525 }
4526
4527
4528 rsn_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
4529 settings->beacon.tail_len, WLAN_EID_RSN);
4530
4531
4532 wpa_ie = brcmf_find_wpaie((u8 *)settings->beacon.tail,
4533 settings->beacon.tail_len);
4534
4535 if ((wpa_ie != NULL || rsn_ie != NULL)) {
4536 brcmf_dbg(TRACE, "WPA(2) IE is found\n");
4537 if (wpa_ie != NULL) {
4538
4539 err = brcmf_configure_wpaie(ifp, wpa_ie, false);
4540 if (err < 0)
4541 goto exit;
4542 } else {
4543 struct brcmf_vs_tlv *tmp_ie;
4544
4545 tmp_ie = (struct brcmf_vs_tlv *)rsn_ie;
4546
4547
4548 err = brcmf_configure_wpaie(ifp, tmp_ie, true);
4549 if (err < 0)
4550 goto exit;
4551 }
4552 } else {
4553 brcmf_dbg(TRACE, "No WPA(2) IEs found\n");
4554 brcmf_configure_opensecurity(ifp);
4555 }
4556
4557
4558 if (!mbss) {
4559 if ((supports_11d) && (is_11d != ifp->vif->is_11d)) {
4560 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY,
4561 is_11d);
4562 if (err < 0) {
4563 bphy_err(drvr, "Regulatory Set Error, %d\n",
4564 err);
4565 goto exit;
4566 }
4567 }
4568 if (settings->beacon_interval) {
4569 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD,
4570 settings->beacon_interval);
4571 if (err < 0) {
4572 bphy_err(drvr, "Beacon Interval Set Error, %d\n",
4573 err);
4574 goto exit;
4575 }
4576 }
4577 if (settings->dtim_period) {
4578 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_DTIMPRD,
4579 settings->dtim_period);
4580 if (err < 0) {
4581 bphy_err(drvr, "DTIM Interval Set Error, %d\n",
4582 err);
4583 goto exit;
4584 }
4585 }
4586
4587 if ((dev_role == NL80211_IFTYPE_AP) &&
4588 ((ifp->ifidx == 0) ||
4589 !brcmf_feat_is_enabled(ifp, BRCMF_FEAT_RSDB))) {
4590 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4591 if (err < 0) {
4592 bphy_err(drvr, "BRCMF_C_DOWN error %d\n",
4593 err);
4594 goto exit;
4595 }
4596 brcmf_fil_iovar_int_set(ifp, "apsta", 0);
4597 }
4598
4599 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 1);
4600 if (err < 0) {
4601 bphy_err(drvr, "SET INFRA error %d\n", err);
4602 goto exit;
4603 }
4604 } else if (WARN_ON(supports_11d && (is_11d != ifp->vif->is_11d))) {
4605
4606 err = -EINVAL;
4607 goto exit;
4608 }
4609
4610
4611 if (dev_role == NL80211_IFTYPE_AP) {
4612 if ((brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS)) && (!mbss))
4613 brcmf_fil_iovar_int_set(ifp, "mbss", 1);
4614
4615 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 1);
4616 if (err < 0) {
4617 bphy_err(drvr, "setting AP mode failed %d\n",
4618 err);
4619 goto exit;
4620 }
4621 if (!mbss) {
4622
4623
4624
4625 err = brcmf_fil_iovar_int_set(ifp, "chanspec", chanspec);
4626 if (err < 0) {
4627 bphy_err(drvr, "Set Channel failed: chspec=%d, %d\n",
4628 chanspec, err);
4629 goto exit;
4630 }
4631 }
4632 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
4633 if (err < 0) {
4634 bphy_err(drvr, "BRCMF_C_UP error (%d)\n", err);
4635 goto exit;
4636 }
4637
4638
4639
4640 brcmf_cfg80211_reconfigure_wep(ifp);
4641
4642 memset(&join_params, 0, sizeof(join_params));
4643
4644 memcpy(&join_params.ssid_le, &ssid_le, sizeof(ssid_le));
4645
4646 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
4647 &join_params, sizeof(join_params));
4648 if (err < 0) {
4649 bphy_err(drvr, "SET SSID error (%d)\n", err);
4650 goto exit;
4651 }
4652
4653 if (settings->hidden_ssid) {
4654 err = brcmf_fil_iovar_int_set(ifp, "closednet", 1);
4655 if (err) {
4656 bphy_err(drvr, "closednet error (%d)\n", err);
4657 goto exit;
4658 }
4659 }
4660
4661 brcmf_dbg(TRACE, "AP mode configuration complete\n");
4662 } else if (dev_role == NL80211_IFTYPE_P2P_GO) {
4663 err = brcmf_fil_iovar_int_set(ifp, "chanspec", chanspec);
4664 if (err < 0) {
4665 bphy_err(drvr, "Set Channel failed: chspec=%d, %d\n",
4666 chanspec, err);
4667 goto exit;
4668 }
4669 err = brcmf_fil_bsscfg_data_set(ifp, "ssid", &ssid_le,
4670 sizeof(ssid_le));
4671 if (err < 0) {
4672 bphy_err(drvr, "setting ssid failed %d\n", err);
4673 goto exit;
4674 }
4675 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx);
4676 bss_enable.enable = cpu_to_le32(1);
4677 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
4678 sizeof(bss_enable));
4679 if (err < 0) {
4680 bphy_err(drvr, "bss_enable config failed %d\n", err);
4681 goto exit;
4682 }
4683
4684 brcmf_dbg(TRACE, "GO mode configuration complete\n");
4685 } else {
4686 WARN_ON(1);
4687 }
4688
4689 brcmf_config_ap_mgmt_ie(ifp->vif, &settings->beacon);
4690 set_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
4691 brcmf_net_setcarrier(ifp, true);
4692
4693 exit:
4694 if ((err) && (!mbss)) {
4695 brcmf_set_mpc(ifp, 1);
4696 brcmf_configure_arp_nd_offload(ifp, true);
4697 }
4698 return err;
4699 }
4700
4701 static int brcmf_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *ndev)
4702 {
4703 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4704 struct brcmf_if *ifp = netdev_priv(ndev);
4705 struct brcmf_pub *drvr = cfg->pub;
4706 s32 err;
4707 struct brcmf_fil_bss_enable_le bss_enable;
4708 struct brcmf_join_params join_params;
4709
4710 brcmf_dbg(TRACE, "Enter\n");
4711
4712 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_AP) {
4713
4714
4715 msleep(400);
4716
4717 if (ifp->vif->mbss) {
4718 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4719 return err;
4720 }
4721
4722
4723 if (ifp->bsscfgidx == 0)
4724 brcmf_fil_iovar_int_set(ifp, "closednet", 0);
4725
4726 memset(&join_params, 0, sizeof(join_params));
4727 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
4728 &join_params, sizeof(join_params));
4729 if (err < 0)
4730 bphy_err(drvr, "SET SSID error (%d)\n", err);
4731 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4732 if (err < 0)
4733 bphy_err(drvr, "BRCMF_C_DOWN error %d\n", err);
4734 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 0);
4735 if (err < 0)
4736 bphy_err(drvr, "setting AP mode failed %d\n", err);
4737 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS))
4738 brcmf_fil_iovar_int_set(ifp, "mbss", 0);
4739 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY,
4740 ifp->vif->is_11d);
4741
4742 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
4743 if (err < 0)
4744 bphy_err(drvr, "BRCMF_C_UP error %d\n", err);
4745
4746 brcmf_vif_clear_mgmt_ies(ifp->vif);
4747 } else {
4748 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx);
4749 bss_enable.enable = cpu_to_le32(0);
4750 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
4751 sizeof(bss_enable));
4752 if (err < 0)
4753 bphy_err(drvr, "bss_enable config failed %d\n", err);
4754 }
4755 brcmf_set_mpc(ifp, 1);
4756 brcmf_configure_arp_nd_offload(ifp, true);
4757 clear_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
4758 brcmf_net_setcarrier(ifp, false);
4759
4760 return err;
4761 }
4762
4763 static s32
4764 brcmf_cfg80211_change_beacon(struct wiphy *wiphy, struct net_device *ndev,
4765 struct cfg80211_beacon_data *info)
4766 {
4767 struct brcmf_if *ifp = netdev_priv(ndev);
4768 s32 err;
4769
4770 brcmf_dbg(TRACE, "Enter\n");
4771
4772 err = brcmf_config_ap_mgmt_ie(ifp->vif, info);
4773
4774 return err;
4775 }
4776
4777 static int
4778 brcmf_cfg80211_del_station(struct wiphy *wiphy, struct net_device *ndev,
4779 struct station_del_parameters *params)
4780 {
4781 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4782 struct brcmf_pub *drvr = cfg->pub;
4783 struct brcmf_scb_val_le scbval;
4784 struct brcmf_if *ifp = netdev_priv(ndev);
4785 s32 err;
4786
4787 if (!params->mac)
4788 return -EFAULT;
4789
4790 brcmf_dbg(TRACE, "Enter %pM\n", params->mac);
4791
4792 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
4793 ifp = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
4794 if (!check_vif_up(ifp->vif))
4795 return -EIO;
4796
4797 memcpy(&scbval.ea, params->mac, ETH_ALEN);
4798 scbval.val = cpu_to_le32(params->reason_code);
4799 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCB_DEAUTHENTICATE_FOR_REASON,
4800 &scbval, sizeof(scbval));
4801 if (err)
4802 bphy_err(drvr, "SCB_DEAUTHENTICATE_FOR_REASON failed %d\n",
4803 err);
4804
4805 brcmf_dbg(TRACE, "Exit\n");
4806 return err;
4807 }
4808
4809 static int
4810 brcmf_cfg80211_change_station(struct wiphy *wiphy, struct net_device *ndev,
4811 const u8 *mac, struct station_parameters *params)
4812 {
4813 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4814 struct brcmf_pub *drvr = cfg->pub;
4815 struct brcmf_if *ifp = netdev_priv(ndev);
4816 s32 err;
4817
4818 brcmf_dbg(TRACE, "Enter, MAC %pM, mask 0x%04x set 0x%04x\n", mac,
4819 params->sta_flags_mask, params->sta_flags_set);
4820
4821
4822 if (is_zero_ether_addr(mac))
4823 return 0;
4824
4825 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
4826 return 0;
4827
4828 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
4829 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_AUTHORIZE,
4830 (void *)mac, ETH_ALEN);
4831 else
4832 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_DEAUTHORIZE,
4833 (void *)mac, ETH_ALEN);
4834 if (err < 0)
4835 bphy_err(drvr, "Setting SCB (de-)authorize failed, %d\n", err);
4836
4837 return err;
4838 }
4839
4840 static void
4841 brcmf_cfg80211_mgmt_frame_register(struct wiphy *wiphy,
4842 struct wireless_dev *wdev,
4843 u16 frame_type, bool reg)
4844 {
4845 struct brcmf_cfg80211_vif *vif;
4846 u16 mgmt_type;
4847
4848 brcmf_dbg(TRACE, "Enter, frame_type %04x, reg=%d\n", frame_type, reg);
4849
4850 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
4851 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4852 if (reg)
4853 vif->mgmt_rx_reg |= BIT(mgmt_type);
4854 else
4855 vif->mgmt_rx_reg &= ~BIT(mgmt_type);
4856 }
4857
4858
4859 static int
4860 brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
4861 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
4862 {
4863 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4864 struct ieee80211_channel *chan = params->chan;
4865 struct brcmf_pub *drvr = cfg->pub;
4866 const u8 *buf = params->buf;
4867 size_t len = params->len;
4868 const struct ieee80211_mgmt *mgmt;
4869 struct brcmf_cfg80211_vif *vif;
4870 s32 err = 0;
4871 s32 ie_offset;
4872 s32 ie_len;
4873 struct brcmf_fil_action_frame_le *action_frame;
4874 struct brcmf_fil_af_params_le *af_params;
4875 bool ack;
4876 s32 chan_nr;
4877 u32 freq;
4878
4879 brcmf_dbg(TRACE, "Enter\n");
4880
4881 *cookie = 0;
4882
4883 mgmt = (const struct ieee80211_mgmt *)buf;
4884
4885 if (!ieee80211_is_mgmt(mgmt->frame_control)) {
4886 bphy_err(drvr, "Driver only allows MGMT packet type\n");
4887 return -EPERM;
4888 }
4889
4890 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4891
4892 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
4893
4894
4895
4896
4897
4898
4899
4900
4901
4902
4903
4904 ie_offset = DOT11_MGMT_HDR_LEN +
4905 DOT11_BCN_PRB_FIXED_LEN;
4906 ie_len = len - ie_offset;
4907 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif)
4908 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
4909 err = brcmf_vif_set_mgmt_ie(vif,
4910 BRCMF_VNDR_IE_PRBRSP_FLAG,
4911 &buf[ie_offset],
4912 ie_len);
4913 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true,
4914 GFP_KERNEL);
4915 } else if (ieee80211_is_action(mgmt->frame_control)) {
4916 if (len > BRCMF_FIL_ACTION_FRAME_SIZE + DOT11_MGMT_HDR_LEN) {
4917 bphy_err(drvr, "invalid action frame length\n");
4918 err = -EINVAL;
4919 goto exit;
4920 }
4921 af_params = kzalloc(sizeof(*af_params), GFP_KERNEL);
4922 if (af_params == NULL) {
4923 bphy_err(drvr, "unable to allocate frame\n");
4924 err = -ENOMEM;
4925 goto exit;
4926 }
4927 action_frame = &af_params->action_frame;
4928
4929 action_frame->packet_id = cpu_to_le32(*cookie);
4930
4931 memcpy(&action_frame->da[0], &mgmt->da[0], ETH_ALEN);
4932 memcpy(&af_params->bssid[0], &mgmt->bssid[0], ETH_ALEN);
4933
4934 action_frame->len = cpu_to_le16(len - DOT11_MGMT_HDR_LEN);
4935
4936
4937
4938 if (chan)
4939 freq = chan->center_freq;
4940 else
4941 brcmf_fil_cmd_int_get(vif->ifp, BRCMF_C_GET_CHANNEL,
4942 &freq);
4943 chan_nr = ieee80211_frequency_to_channel(freq);
4944 af_params->channel = cpu_to_le32(chan_nr);
4945
4946 memcpy(action_frame->data, &buf[DOT11_MGMT_HDR_LEN],
4947 le16_to_cpu(action_frame->len));
4948
4949 brcmf_dbg(TRACE, "Action frame, cookie=%lld, len=%d, freq=%d\n",
4950 *cookie, le16_to_cpu(action_frame->len), freq);
4951
4952 ack = brcmf_p2p_send_action_frame(cfg, cfg_to_ndev(cfg),
4953 af_params);
4954
4955 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, ack,
4956 GFP_KERNEL);
4957 kfree(af_params);
4958 } else {
4959 brcmf_dbg(TRACE, "Unhandled, fc=%04x!!\n", mgmt->frame_control);
4960 brcmf_dbg_hex_dump(true, buf, len, "payload, len=%zu\n", len);
4961 }
4962
4963 exit:
4964 return err;
4965 }
4966
4967
4968 static int
4969 brcmf_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
4970 struct wireless_dev *wdev,
4971 u64 cookie)
4972 {
4973 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4974 struct brcmf_pub *drvr = cfg->pub;
4975 struct brcmf_cfg80211_vif *vif;
4976 int err = 0;
4977
4978 brcmf_dbg(TRACE, "Enter p2p listen cancel\n");
4979
4980 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
4981 if (vif == NULL) {
4982 bphy_err(drvr, "No p2p device available for probe response\n");
4983 err = -ENODEV;
4984 goto exit;
4985 }
4986 brcmf_p2p_cancel_remain_on_channel(vif->ifp);
4987 exit:
4988 return err;
4989 }
4990
4991 static int brcmf_cfg80211_get_channel(struct wiphy *wiphy,
4992 struct wireless_dev *wdev,
4993 struct cfg80211_chan_def *chandef)
4994 {
4995 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4996 struct net_device *ndev = wdev->netdev;
4997 struct brcmf_pub *drvr = cfg->pub;
4998 struct brcmu_chan ch;
4999 enum nl80211_band band = 0;
5000 enum nl80211_chan_width width = 0;
5001 u32 chanspec;
5002 int freq, err;
5003
5004 if (!ndev || drvr->bus_if->state != BRCMF_BUS_UP)
5005 return -ENODEV;
5006
5007 err = brcmf_fil_iovar_int_get(netdev_priv(ndev), "chanspec", &chanspec);
5008 if (err) {
5009 bphy_err(drvr, "chanspec failed (%d)\n", err);
5010 return err;
5011 }
5012
5013 ch.chspec = chanspec;
5014 cfg->d11inf.decchspec(&ch);
5015
5016 switch (ch.band) {
5017 case BRCMU_CHAN_BAND_2G:
5018 band = NL80211_BAND_2GHZ;
5019 break;
5020 case BRCMU_CHAN_BAND_5G:
5021 band = NL80211_BAND_5GHZ;
5022 break;
5023 }
5024
5025 switch (ch.bw) {
5026 case BRCMU_CHAN_BW_80:
5027 width = NL80211_CHAN_WIDTH_80;
5028 break;
5029 case BRCMU_CHAN_BW_40:
5030 width = NL80211_CHAN_WIDTH_40;
5031 break;
5032 case BRCMU_CHAN_BW_20:
5033 width = NL80211_CHAN_WIDTH_20;
5034 break;
5035 case BRCMU_CHAN_BW_80P80:
5036 width = NL80211_CHAN_WIDTH_80P80;
5037 break;
5038 case BRCMU_CHAN_BW_160:
5039 width = NL80211_CHAN_WIDTH_160;
5040 break;
5041 }
5042
5043 freq = ieee80211_channel_to_frequency(ch.control_ch_num, band);
5044 chandef->chan = ieee80211_get_channel(wiphy, freq);
5045 chandef->width = width;
5046 chandef->center_freq1 = ieee80211_channel_to_frequency(ch.chnum, band);
5047 chandef->center_freq2 = 0;
5048
5049 return 0;
5050 }
5051
5052 static int brcmf_cfg80211_crit_proto_start(struct wiphy *wiphy,
5053 struct wireless_dev *wdev,
5054 enum nl80211_crit_proto_id proto,
5055 u16 duration)
5056 {
5057 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
5058 struct brcmf_cfg80211_vif *vif;
5059
5060 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
5061
5062
5063 if (proto != NL80211_CRIT_PROTO_DHCP)
5064 return -EINVAL;
5065
5066
5067 set_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
5068 brcmf_abort_scanning(cfg);
5069
5070 return brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_DISABLED, duration);
5071 }
5072
5073 static void brcmf_cfg80211_crit_proto_stop(struct wiphy *wiphy,
5074 struct wireless_dev *wdev)
5075 {
5076 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
5077 struct brcmf_cfg80211_vif *vif;
5078
5079 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
5080
5081 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
5082 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
5083 }
5084
5085 static s32
5086 brcmf_notify_tdls_peer_event(struct brcmf_if *ifp,
5087 const struct brcmf_event_msg *e, void *data)
5088 {
5089 switch (e->reason) {
5090 case BRCMF_E_REASON_TDLS_PEER_DISCOVERED:
5091 brcmf_dbg(TRACE, "TDLS Peer Discovered\n");
5092 break;
5093 case BRCMF_E_REASON_TDLS_PEER_CONNECTED:
5094 brcmf_dbg(TRACE, "TDLS Peer Connected\n");
5095 brcmf_proto_add_tdls_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
5096 break;
5097 case BRCMF_E_REASON_TDLS_PEER_DISCONNECTED:
5098 brcmf_dbg(TRACE, "TDLS Peer Disconnected\n");
5099 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
5100 break;
5101 }
5102
5103 return 0;
5104 }
5105
5106 static int brcmf_convert_nl80211_tdls_oper(enum nl80211_tdls_operation oper)
5107 {
5108 int ret;
5109
5110 switch (oper) {
5111 case NL80211_TDLS_DISCOVERY_REQ:
5112 ret = BRCMF_TDLS_MANUAL_EP_DISCOVERY;
5113 break;
5114 case NL80211_TDLS_SETUP:
5115 ret = BRCMF_TDLS_MANUAL_EP_CREATE;
5116 break;
5117 case NL80211_TDLS_TEARDOWN:
5118 ret = BRCMF_TDLS_MANUAL_EP_DELETE;
5119 break;
5120 default:
5121 brcmf_err("unsupported operation: %d\n", oper);
5122 ret = -EOPNOTSUPP;
5123 }
5124 return ret;
5125 }
5126
5127 static int brcmf_cfg80211_tdls_oper(struct wiphy *wiphy,
5128 struct net_device *ndev, const u8 *peer,
5129 enum nl80211_tdls_operation oper)
5130 {
5131 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
5132 struct brcmf_pub *drvr = cfg->pub;
5133 struct brcmf_if *ifp;
5134 struct brcmf_tdls_iovar_le info;
5135 int ret = 0;
5136
5137 ret = brcmf_convert_nl80211_tdls_oper(oper);
5138 if (ret < 0)
5139 return ret;
5140
5141 ifp = netdev_priv(ndev);
5142 memset(&info, 0, sizeof(info));
5143 info.mode = (u8)ret;
5144 if (peer)
5145 memcpy(info.ea, peer, ETH_ALEN);
5146
5147 ret = brcmf_fil_iovar_data_set(ifp, "tdls_endpoint",
5148 &info, sizeof(info));
5149 if (ret < 0)
5150 bphy_err(drvr, "tdls_endpoint iovar failed: ret=%d\n", ret);
5151
5152 return ret;
5153 }
5154
5155 static int
5156 brcmf_cfg80211_update_conn_params(struct wiphy *wiphy,
5157 struct net_device *ndev,
5158 struct cfg80211_connect_params *sme,
5159 u32 changed)
5160 {
5161 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
5162 struct brcmf_pub *drvr = cfg->pub;
5163 struct brcmf_if *ifp;
5164 int err;
5165
5166 if (!(changed & UPDATE_ASSOC_IES))
5167 return 0;
5168
5169 ifp = netdev_priv(ndev);
5170 err = brcmf_vif_set_mgmt_ie(ifp->vif, BRCMF_VNDR_IE_ASSOCREQ_FLAG,
5171 sme->ie, sme->ie_len);
5172 if (err)
5173 bphy_err(drvr, "Set Assoc REQ IE Failed\n");
5174 else
5175 brcmf_dbg(TRACE, "Applied Vndr IEs for Assoc request\n");
5176
5177 return err;
5178 }
5179
5180 #ifdef CONFIG_PM
5181 static int
5182 brcmf_cfg80211_set_rekey_data(struct wiphy *wiphy, struct net_device *ndev,
5183 struct cfg80211_gtk_rekey_data *gtk)
5184 {
5185 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
5186 struct brcmf_pub *drvr = cfg->pub;
5187 struct brcmf_if *ifp = netdev_priv(ndev);
5188 struct brcmf_gtk_keyinfo_le gtk_le;
5189 int ret;
5190
5191 brcmf_dbg(TRACE, "Enter, bssidx=%d\n", ifp->bsscfgidx);
5192
5193 memcpy(gtk_le.kck, gtk->kck, sizeof(gtk_le.kck));
5194 memcpy(gtk_le.kek, gtk->kek, sizeof(gtk_le.kek));
5195 memcpy(gtk_le.replay_counter, gtk->replay_ctr,
5196 sizeof(gtk_le.replay_counter));
5197
5198 ret = brcmf_fil_iovar_data_set(ifp, "gtk_key_info", >k_le,
5199 sizeof(gtk_le));
5200 if (ret < 0)
5201 bphy_err(drvr, "gtk_key_info iovar failed: ret=%d\n", ret);
5202
5203 return ret;
5204 }
5205 #endif
5206
5207 static int brcmf_cfg80211_set_pmk(struct wiphy *wiphy, struct net_device *dev,
5208 const struct cfg80211_pmk_conf *conf)
5209 {
5210 struct brcmf_if *ifp;
5211
5212 brcmf_dbg(TRACE, "enter\n");
5213
5214
5215 ifp = netdev_priv(dev);
5216 if (WARN_ON(ifp->vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_1X))
5217 return -EINVAL;
5218
5219 if (conf->pmk_len > BRCMF_WSEC_MAX_PSK_LEN)
5220 return -ERANGE;
5221
5222 return brcmf_set_pmk(ifp, conf->pmk, conf->pmk_len);
5223 }
5224
5225 static int brcmf_cfg80211_del_pmk(struct wiphy *wiphy, struct net_device *dev,
5226 const u8 *aa)
5227 {
5228 struct brcmf_if *ifp;
5229
5230 brcmf_dbg(TRACE, "enter\n");
5231 ifp = netdev_priv(dev);
5232 if (WARN_ON(ifp->vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_1X))
5233 return -EINVAL;
5234
5235 return brcmf_set_pmk(ifp, NULL, 0);
5236 }
5237
5238 static struct cfg80211_ops brcmf_cfg80211_ops = {
5239 .add_virtual_intf = brcmf_cfg80211_add_iface,
5240 .del_virtual_intf = brcmf_cfg80211_del_iface,
5241 .change_virtual_intf = brcmf_cfg80211_change_iface,
5242 .scan = brcmf_cfg80211_scan,
5243 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
5244 .join_ibss = brcmf_cfg80211_join_ibss,
5245 .leave_ibss = brcmf_cfg80211_leave_ibss,
5246 .get_station = brcmf_cfg80211_get_station,
5247 .dump_station = brcmf_cfg80211_dump_station,
5248 .set_tx_power = brcmf_cfg80211_set_tx_power,
5249 .get_tx_power = brcmf_cfg80211_get_tx_power,
5250 .add_key = brcmf_cfg80211_add_key,
5251 .del_key = brcmf_cfg80211_del_key,
5252 .get_key = brcmf_cfg80211_get_key,
5253 .set_default_key = brcmf_cfg80211_config_default_key,
5254 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
5255 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
5256 .connect = brcmf_cfg80211_connect,
5257 .disconnect = brcmf_cfg80211_disconnect,
5258 .suspend = brcmf_cfg80211_suspend,
5259 .resume = brcmf_cfg80211_resume,
5260 .set_pmksa = brcmf_cfg80211_set_pmksa,
5261 .del_pmksa = brcmf_cfg80211_del_pmksa,
5262 .flush_pmksa = brcmf_cfg80211_flush_pmksa,
5263 .start_ap = brcmf_cfg80211_start_ap,
5264 .stop_ap = brcmf_cfg80211_stop_ap,
5265 .change_beacon = brcmf_cfg80211_change_beacon,
5266 .del_station = brcmf_cfg80211_del_station,
5267 .change_station = brcmf_cfg80211_change_station,
5268 .sched_scan_start = brcmf_cfg80211_sched_scan_start,
5269 .sched_scan_stop = brcmf_cfg80211_sched_scan_stop,
5270 .mgmt_frame_register = brcmf_cfg80211_mgmt_frame_register,
5271 .mgmt_tx = brcmf_cfg80211_mgmt_tx,
5272 .remain_on_channel = brcmf_p2p_remain_on_channel,
5273 .cancel_remain_on_channel = brcmf_cfg80211_cancel_remain_on_channel,
5274 .get_channel = brcmf_cfg80211_get_channel,
5275 .start_p2p_device = brcmf_p2p_start_device,
5276 .stop_p2p_device = brcmf_p2p_stop_device,
5277 .crit_proto_start = brcmf_cfg80211_crit_proto_start,
5278 .crit_proto_stop = brcmf_cfg80211_crit_proto_stop,
5279 .tdls_oper = brcmf_cfg80211_tdls_oper,
5280 .update_connect_params = brcmf_cfg80211_update_conn_params,
5281 .set_pmk = brcmf_cfg80211_set_pmk,
5282 .del_pmk = brcmf_cfg80211_del_pmk,
5283 };
5284
5285 struct cfg80211_ops *brcmf_cfg80211_get_ops(struct brcmf_mp_device *settings)
5286 {
5287 struct cfg80211_ops *ops;
5288
5289 ops = kmemdup(&brcmf_cfg80211_ops, sizeof(brcmf_cfg80211_ops),
5290 GFP_KERNEL);
5291
5292 if (ops && settings->roamoff)
5293 ops->update_connect_params = NULL;
5294
5295 return ops;
5296 }
5297
5298 struct brcmf_cfg80211_vif *brcmf_alloc_vif(struct brcmf_cfg80211_info *cfg,
5299 enum nl80211_iftype type)
5300 {
5301 struct brcmf_cfg80211_vif *vif_walk;
5302 struct brcmf_cfg80211_vif *vif;
5303 bool mbss;
5304
5305 brcmf_dbg(TRACE, "allocating virtual interface (size=%zu)\n",
5306 sizeof(*vif));
5307 vif = kzalloc(sizeof(*vif), GFP_KERNEL);
5308 if (!vif)
5309 return ERR_PTR(-ENOMEM);
5310
5311 vif->wdev.wiphy = cfg->wiphy;
5312 vif->wdev.iftype = type;
5313
5314 brcmf_init_prof(&vif->profile);
5315
5316 if (type == NL80211_IFTYPE_AP) {
5317 mbss = false;
5318 list_for_each_entry(vif_walk, &cfg->vif_list, list) {
5319 if (vif_walk->wdev.iftype == NL80211_IFTYPE_AP) {
5320 mbss = true;
5321 break;
5322 }
5323 }
5324 vif->mbss = mbss;
5325 }
5326
5327 list_add_tail(&vif->list, &cfg->vif_list);
5328 return vif;
5329 }
5330
5331 void brcmf_free_vif(struct brcmf_cfg80211_vif *vif)
5332 {
5333 list_del(&vif->list);
5334 kfree(vif);
5335 }
5336
5337 void brcmf_cfg80211_free_netdev(struct net_device *ndev)
5338 {
5339 struct brcmf_cfg80211_vif *vif;
5340 struct brcmf_if *ifp;
5341
5342 ifp = netdev_priv(ndev);
5343 vif = ifp->vif;
5344
5345 if (vif)
5346 brcmf_free_vif(vif);
5347 }
5348
5349 static bool brcmf_is_linkup(struct brcmf_cfg80211_vif *vif,
5350 const struct brcmf_event_msg *e)
5351 {
5352 u32 event = e->event_code;
5353 u32 status = e->status;
5354
5355 if (vif->profile.use_fwsup == BRCMF_PROFILE_FWSUP_PSK &&
5356 event == BRCMF_E_PSK_SUP &&
5357 status == BRCMF_E_STATUS_FWSUP_COMPLETED)
5358 set_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state);
5359 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
5360 brcmf_dbg(CONN, "Processing set ssid\n");
5361 memcpy(vif->profile.bssid, e->addr, ETH_ALEN);
5362 if (vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_PSK)
5363 return true;
5364
5365 set_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state);
5366 }
5367
5368 if (test_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state) &&
5369 test_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state)) {
5370 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state);
5371 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state);
5372 return true;
5373 }
5374 return false;
5375 }
5376
5377 static bool brcmf_is_linkdown(const struct brcmf_event_msg *e)
5378 {
5379 u32 event = e->event_code;
5380 u16 flags = e->flags;
5381
5382 if ((event == BRCMF_E_DEAUTH) || (event == BRCMF_E_DEAUTH_IND) ||
5383 (event == BRCMF_E_DISASSOC_IND) ||
5384 ((event == BRCMF_E_LINK) && (!(flags & BRCMF_EVENT_MSG_LINK)))) {
5385 brcmf_dbg(CONN, "Processing link down\n");
5386 return true;
5387 }
5388 return false;
5389 }
5390
5391 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_info *cfg,
5392 const struct brcmf_event_msg *e)
5393 {
5394 u32 event = e->event_code;
5395 u32 status = e->status;
5396
5397 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
5398 brcmf_dbg(CONN, "Processing Link %s & no network found\n",
5399 e->flags & BRCMF_EVENT_MSG_LINK ? "up" : "down");
5400 return true;
5401 }
5402
5403 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
5404 brcmf_dbg(CONN, "Processing connecting & no network found\n");
5405 return true;
5406 }
5407
5408 if (event == BRCMF_E_PSK_SUP &&
5409 status != BRCMF_E_STATUS_FWSUP_COMPLETED) {
5410 brcmf_dbg(CONN, "Processing failed supplicant state: %u\n",
5411 status);
5412 return true;
5413 }
5414
5415 return false;
5416 }
5417
5418 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_info *cfg)
5419 {
5420 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5421
5422 kfree(conn_info->req_ie);
5423 conn_info->req_ie = NULL;
5424 conn_info->req_ie_len = 0;
5425 kfree(conn_info->resp_ie);
5426 conn_info->resp_ie = NULL;
5427 conn_info->resp_ie_len = 0;
5428 }
5429
5430 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg,
5431 struct brcmf_if *ifp)
5432 {
5433 struct brcmf_pub *drvr = cfg->pub;
5434 struct brcmf_cfg80211_assoc_ielen_le *assoc_info;
5435 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5436 u32 req_len;
5437 u32 resp_len;
5438 s32 err = 0;
5439
5440 brcmf_clear_assoc_ies(cfg);
5441
5442 err = brcmf_fil_iovar_data_get(ifp, "assoc_info",
5443 cfg->extra_buf, WL_ASSOC_INFO_MAX);
5444 if (err) {
5445 bphy_err(drvr, "could not get assoc info (%d)\n", err);
5446 return err;
5447 }
5448 assoc_info =
5449 (struct brcmf_cfg80211_assoc_ielen_le *)cfg->extra_buf;
5450 req_len = le32_to_cpu(assoc_info->req_len);
5451 resp_len = le32_to_cpu(assoc_info->resp_len);
5452 if (req_len) {
5453 err = brcmf_fil_iovar_data_get(ifp, "assoc_req_ies",
5454 cfg->extra_buf,
5455 WL_ASSOC_INFO_MAX);
5456 if (err) {
5457 bphy_err(drvr, "could not get assoc req (%d)\n", err);
5458 return err;
5459 }
5460 conn_info->req_ie_len = req_len;
5461 conn_info->req_ie =
5462 kmemdup(cfg->extra_buf, conn_info->req_ie_len,
5463 GFP_KERNEL);
5464 if (!conn_info->req_ie)
5465 conn_info->req_ie_len = 0;
5466 } else {
5467 conn_info->req_ie_len = 0;
5468 conn_info->req_ie = NULL;
5469 }
5470 if (resp_len) {
5471 err = brcmf_fil_iovar_data_get(ifp, "assoc_resp_ies",
5472 cfg->extra_buf,
5473 WL_ASSOC_INFO_MAX);
5474 if (err) {
5475 bphy_err(drvr, "could not get assoc resp (%d)\n", err);
5476 return err;
5477 }
5478 conn_info->resp_ie_len = resp_len;
5479 conn_info->resp_ie =
5480 kmemdup(cfg->extra_buf, conn_info->resp_ie_len,
5481 GFP_KERNEL);
5482 if (!conn_info->resp_ie)
5483 conn_info->resp_ie_len = 0;
5484 } else {
5485 conn_info->resp_ie_len = 0;
5486 conn_info->resp_ie = NULL;
5487 }
5488 brcmf_dbg(CONN, "req len (%d) resp len (%d)\n",
5489 conn_info->req_ie_len, conn_info->resp_ie_len);
5490
5491 return err;
5492 }
5493
5494 static s32
5495 brcmf_bss_roaming_done(struct brcmf_cfg80211_info *cfg,
5496 struct net_device *ndev,
5497 const struct brcmf_event_msg *e)
5498 {
5499 struct brcmf_if *ifp = netdev_priv(ndev);
5500 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5501 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5502 struct wiphy *wiphy = cfg_to_wiphy(cfg);
5503 struct ieee80211_channel *notify_channel = NULL;
5504 struct ieee80211_supported_band *band;
5505 struct brcmf_bss_info_le *bi;
5506 struct brcmu_chan ch;
5507 struct cfg80211_roam_info roam_info = {};
5508 u32 freq;
5509 s32 err = 0;
5510 u8 *buf;
5511
5512 brcmf_dbg(TRACE, "Enter\n");
5513
5514 brcmf_get_assoc_ies(cfg, ifp);
5515 memcpy(profile->bssid, e->addr, ETH_ALEN);
5516 brcmf_update_bss_info(cfg, ifp);
5517
5518 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
5519 if (buf == NULL) {
5520 err = -ENOMEM;
5521 goto done;
5522 }
5523
5524
5525 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
5526 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
5527 buf, WL_BSS_INFO_MAX);
5528
5529 if (err)
5530 goto done;
5531
5532 bi = (struct brcmf_bss_info_le *)(buf + 4);
5533 ch.chspec = le16_to_cpu(bi->chanspec);
5534 cfg->d11inf.decchspec(&ch);
5535
5536 if (ch.band == BRCMU_CHAN_BAND_2G)
5537 band = wiphy->bands[NL80211_BAND_2GHZ];
5538 else
5539 band = wiphy->bands[NL80211_BAND_5GHZ];
5540
5541 freq = ieee80211_channel_to_frequency(ch.control_ch_num, band->band);
5542 notify_channel = ieee80211_get_channel(wiphy, freq);
5543
5544 done:
5545 kfree(buf);
5546
5547 roam_info.channel = notify_channel;
5548 roam_info.bssid = profile->bssid;
5549 roam_info.req_ie = conn_info->req_ie;
5550 roam_info.req_ie_len = conn_info->req_ie_len;
5551 roam_info.resp_ie = conn_info->resp_ie;
5552 roam_info.resp_ie_len = conn_info->resp_ie_len;
5553
5554 cfg80211_roamed(ndev, &roam_info, GFP_KERNEL);
5555 brcmf_dbg(CONN, "Report roaming result\n");
5556
5557 set_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
5558 brcmf_dbg(TRACE, "Exit\n");
5559 return err;
5560 }
5561
5562 static s32
5563 brcmf_bss_connect_done(struct brcmf_cfg80211_info *cfg,
5564 struct net_device *ndev, const struct brcmf_event_msg *e,
5565 bool completed)
5566 {
5567 struct brcmf_if *ifp = netdev_priv(ndev);
5568 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5569 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5570 struct cfg80211_connect_resp_params conn_params;
5571
5572 brcmf_dbg(TRACE, "Enter\n");
5573
5574 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5575 &ifp->vif->sme_state)) {
5576 memset(&conn_params, 0, sizeof(conn_params));
5577 if (completed) {
5578 brcmf_get_assoc_ies(cfg, ifp);
5579 brcmf_update_bss_info(cfg, ifp);
5580 set_bit(BRCMF_VIF_STATUS_CONNECTED,
5581 &ifp->vif->sme_state);
5582 conn_params.status = WLAN_STATUS_SUCCESS;
5583 } else {
5584 conn_params.status = WLAN_STATUS_AUTH_TIMEOUT;
5585 }
5586 conn_params.bssid = profile->bssid;
5587 conn_params.req_ie = conn_info->req_ie;
5588 conn_params.req_ie_len = conn_info->req_ie_len;
5589 conn_params.resp_ie = conn_info->resp_ie;
5590 conn_params.resp_ie_len = conn_info->resp_ie_len;
5591 cfg80211_connect_done(ndev, &conn_params, GFP_KERNEL);
5592 brcmf_dbg(CONN, "Report connect result - connection %s\n",
5593 completed ? "succeeded" : "failed");
5594 }
5595 brcmf_dbg(TRACE, "Exit\n");
5596 return 0;
5597 }
5598
5599 static s32
5600 brcmf_notify_connect_status_ap(struct brcmf_cfg80211_info *cfg,
5601 struct net_device *ndev,
5602 const struct brcmf_event_msg *e, void *data)
5603 {
5604 struct brcmf_pub *drvr = cfg->pub;
5605 static int generation;
5606 u32 event = e->event_code;
5607 u32 reason = e->reason;
5608 struct station_info *sinfo;
5609
5610 brcmf_dbg(CONN, "event %s (%u), reason %d\n",
5611 brcmf_fweh_event_name(event), event, reason);
5612 if (event == BRCMF_E_LINK && reason == BRCMF_E_REASON_LINK_BSSCFG_DIS &&
5613 ndev != cfg_to_ndev(cfg)) {
5614 brcmf_dbg(CONN, "AP mode link down\n");
5615 complete(&cfg->vif_disabled);
5616 return 0;
5617 }
5618
5619 if (((event == BRCMF_E_ASSOC_IND) || (event == BRCMF_E_REASSOC_IND)) &&
5620 (reason == BRCMF_E_STATUS_SUCCESS)) {
5621 if (!data) {
5622 bphy_err(drvr, "No IEs present in ASSOC/REASSOC_IND\n");
5623 return -EINVAL;
5624 }
5625
5626 sinfo = kzalloc(sizeof(*sinfo), GFP_KERNEL);
5627 if (!sinfo)
5628 return -ENOMEM;
5629
5630 sinfo->assoc_req_ies = data;
5631 sinfo->assoc_req_ies_len = e->datalen;
5632 generation++;
5633 sinfo->generation = generation;
5634 cfg80211_new_sta(ndev, e->addr, sinfo, GFP_KERNEL);
5635
5636 kfree(sinfo);
5637 } else if ((event == BRCMF_E_DISASSOC_IND) ||
5638 (event == BRCMF_E_DEAUTH_IND) ||
5639 (event == BRCMF_E_DEAUTH)) {
5640 cfg80211_del_sta(ndev, e->addr, GFP_KERNEL);
5641 }
5642 return 0;
5643 }
5644
5645 static s32
5646 brcmf_notify_connect_status(struct brcmf_if *ifp,
5647 const struct brcmf_event_msg *e, void *data)
5648 {
5649 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5650 struct net_device *ndev = ifp->ndev;
5651 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5652 struct ieee80211_channel *chan;
5653 s32 err = 0;
5654
5655 if ((e->event_code == BRCMF_E_DEAUTH) ||
5656 (e->event_code == BRCMF_E_DEAUTH_IND) ||
5657 (e->event_code == BRCMF_E_DISASSOC_IND) ||
5658 ((e->event_code == BRCMF_E_LINK) && (!e->flags))) {
5659 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
5660 }
5661
5662 if (brcmf_is_apmode(ifp->vif)) {
5663 err = brcmf_notify_connect_status_ap(cfg, ndev, e, data);
5664 } else if (brcmf_is_linkup(ifp->vif, e)) {
5665 brcmf_dbg(CONN, "Linkup\n");
5666 if (brcmf_is_ibssmode(ifp->vif)) {
5667 brcmf_inform_ibss(cfg, ndev, e->addr);
5668 chan = ieee80211_get_channel(cfg->wiphy, cfg->channel);
5669 memcpy(profile->bssid, e->addr, ETH_ALEN);
5670 cfg80211_ibss_joined(ndev, e->addr, chan, GFP_KERNEL);
5671 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5672 &ifp->vif->sme_state);
5673 set_bit(BRCMF_VIF_STATUS_CONNECTED,
5674 &ifp->vif->sme_state);
5675 } else
5676 brcmf_bss_connect_done(cfg, ndev, e, true);
5677 brcmf_net_setcarrier(ifp, true);
5678 } else if (brcmf_is_linkdown(e)) {
5679 brcmf_dbg(CONN, "Linkdown\n");
5680 if (!brcmf_is_ibssmode(ifp->vif)) {
5681 brcmf_bss_connect_done(cfg, ndev, e, false);
5682 brcmf_link_down(ifp->vif,
5683 brcmf_map_fw_linkdown_reason(e));
5684 brcmf_init_prof(ndev_to_prof(ndev));
5685 if (ndev != cfg_to_ndev(cfg))
5686 complete(&cfg->vif_disabled);
5687 brcmf_net_setcarrier(ifp, false);
5688 }
5689 } else if (brcmf_is_nonetwork(cfg, e)) {
5690 if (brcmf_is_ibssmode(ifp->vif))
5691 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5692 &ifp->vif->sme_state);
5693 else
5694 brcmf_bss_connect_done(cfg, ndev, e, false);
5695 }
5696
5697 return err;
5698 }
5699
5700 static s32
5701 brcmf_notify_roaming_status(struct brcmf_if *ifp,
5702 const struct brcmf_event_msg *e, void *data)
5703 {
5704 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5705 u32 event = e->event_code;
5706 u32 status = e->status;
5707
5708 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
5709 if (test_bit(BRCMF_VIF_STATUS_CONNECTED,
5710 &ifp->vif->sme_state)) {
5711 brcmf_bss_roaming_done(cfg, ifp->ndev, e);
5712 } else {
5713 brcmf_bss_connect_done(cfg, ifp->ndev, e, true);
5714 brcmf_net_setcarrier(ifp, true);
5715 }
5716 }
5717
5718 return 0;
5719 }
5720
5721 static s32
5722 brcmf_notify_mic_status(struct brcmf_if *ifp,
5723 const struct brcmf_event_msg *e, void *data)
5724 {
5725 u16 flags = e->flags;
5726 enum nl80211_key_type key_type;
5727
5728 if (flags & BRCMF_EVENT_MSG_GROUP)
5729 key_type = NL80211_KEYTYPE_GROUP;
5730 else
5731 key_type = NL80211_KEYTYPE_PAIRWISE;
5732
5733 cfg80211_michael_mic_failure(ifp->ndev, (u8 *)&e->addr, key_type, -1,
5734 NULL, GFP_KERNEL);
5735
5736 return 0;
5737 }
5738
5739 static s32 brcmf_notify_vif_event(struct brcmf_if *ifp,
5740 const struct brcmf_event_msg *e, void *data)
5741 {
5742 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5743 struct brcmf_if_event *ifevent = (struct brcmf_if_event *)data;
5744 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
5745 struct brcmf_cfg80211_vif *vif;
5746
5747 brcmf_dbg(TRACE, "Enter: action %u flags %u ifidx %u bsscfgidx %u\n",
5748 ifevent->action, ifevent->flags, ifevent->ifidx,
5749 ifevent->bsscfgidx);
5750
5751 spin_lock(&event->vif_event_lock);
5752 event->action = ifevent->action;
5753 vif = event->vif;
5754
5755 switch (ifevent->action) {
5756 case BRCMF_E_IF_ADD:
5757
5758 if (!cfg->vif_event.vif) {
5759 spin_unlock(&event->vif_event_lock);
5760 return -EBADF;
5761 }
5762
5763 ifp->vif = vif;
5764 vif->ifp = ifp;
5765 if (ifp->ndev) {
5766 vif->wdev.netdev = ifp->ndev;
5767 ifp->ndev->ieee80211_ptr = &vif->wdev;
5768 SET_NETDEV_DEV(ifp->ndev, wiphy_dev(cfg->wiphy));
5769 }
5770 spin_unlock(&event->vif_event_lock);
5771 wake_up(&event->vif_wq);
5772 return 0;
5773
5774 case BRCMF_E_IF_DEL:
5775 spin_unlock(&event->vif_event_lock);
5776
5777 if (brcmf_cfg80211_vif_event_armed(cfg))
5778 wake_up(&event->vif_wq);
5779 return 0;
5780
5781 case BRCMF_E_IF_CHANGE:
5782 spin_unlock(&event->vif_event_lock);
5783 wake_up(&event->vif_wq);
5784 return 0;
5785
5786 default:
5787 spin_unlock(&event->vif_event_lock);
5788 break;
5789 }
5790 return -EINVAL;
5791 }
5792
5793 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
5794 {
5795 conf->frag_threshold = (u32)-1;
5796 conf->rts_threshold = (u32)-1;
5797 conf->retry_short = (u32)-1;
5798 conf->retry_long = (u32)-1;
5799 }
5800
5801 static void brcmf_register_event_handlers(struct brcmf_cfg80211_info *cfg)
5802 {
5803 brcmf_fweh_register(cfg->pub, BRCMF_E_LINK,
5804 brcmf_notify_connect_status);
5805 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH_IND,
5806 brcmf_notify_connect_status);
5807 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH,
5808 brcmf_notify_connect_status);
5809 brcmf_fweh_register(cfg->pub, BRCMF_E_DISASSOC_IND,
5810 brcmf_notify_connect_status);
5811 brcmf_fweh_register(cfg->pub, BRCMF_E_ASSOC_IND,
5812 brcmf_notify_connect_status);
5813 brcmf_fweh_register(cfg->pub, BRCMF_E_REASSOC_IND,
5814 brcmf_notify_connect_status);
5815 brcmf_fweh_register(cfg->pub, BRCMF_E_ROAM,
5816 brcmf_notify_roaming_status);
5817 brcmf_fweh_register(cfg->pub, BRCMF_E_MIC_ERROR,
5818 brcmf_notify_mic_status);
5819 brcmf_fweh_register(cfg->pub, BRCMF_E_SET_SSID,
5820 brcmf_notify_connect_status);
5821 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
5822 brcmf_notify_sched_scan_results);
5823 brcmf_fweh_register(cfg->pub, BRCMF_E_IF,
5824 brcmf_notify_vif_event);
5825 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_PROBEREQ_MSG,
5826 brcmf_p2p_notify_rx_mgmt_p2p_probereq);
5827 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_DISC_LISTEN_COMPLETE,
5828 brcmf_p2p_notify_listen_complete);
5829 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_RX,
5830 brcmf_p2p_notify_action_frame_rx);
5831 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_COMPLETE,
5832 brcmf_p2p_notify_action_tx_complete);
5833 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE,
5834 brcmf_p2p_notify_action_tx_complete);
5835 brcmf_fweh_register(cfg->pub, BRCMF_E_PSK_SUP,
5836 brcmf_notify_connect_status);
5837 }
5838
5839 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_info *cfg)
5840 {
5841 kfree(cfg->conf);
5842 cfg->conf = NULL;
5843 kfree(cfg->extra_buf);
5844 cfg->extra_buf = NULL;
5845 kfree(cfg->wowl.nd);
5846 cfg->wowl.nd = NULL;
5847 kfree(cfg->wowl.nd_info);
5848 cfg->wowl.nd_info = NULL;
5849 kfree(cfg->escan_info.escan_buf);
5850 cfg->escan_info.escan_buf = NULL;
5851 }
5852
5853 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_info *cfg)
5854 {
5855 cfg->conf = kzalloc(sizeof(*cfg->conf), GFP_KERNEL);
5856 if (!cfg->conf)
5857 goto init_priv_mem_out;
5858 cfg->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
5859 if (!cfg->extra_buf)
5860 goto init_priv_mem_out;
5861 cfg->wowl.nd = kzalloc(sizeof(*cfg->wowl.nd) + sizeof(u32), GFP_KERNEL);
5862 if (!cfg->wowl.nd)
5863 goto init_priv_mem_out;
5864 cfg->wowl.nd_info = kzalloc(sizeof(*cfg->wowl.nd_info) +
5865 sizeof(struct cfg80211_wowlan_nd_match *),
5866 GFP_KERNEL);
5867 if (!cfg->wowl.nd_info)
5868 goto init_priv_mem_out;
5869 cfg->escan_info.escan_buf = kzalloc(BRCMF_ESCAN_BUF_SIZE, GFP_KERNEL);
5870 if (!cfg->escan_info.escan_buf)
5871 goto init_priv_mem_out;
5872
5873 return 0;
5874
5875 init_priv_mem_out:
5876 brcmf_deinit_priv_mem(cfg);
5877
5878 return -ENOMEM;
5879 }
5880
5881 static s32 wl_init_priv(struct brcmf_cfg80211_info *cfg)
5882 {
5883 s32 err = 0;
5884
5885 cfg->scan_request = NULL;
5886 cfg->pwr_save = true;
5887 cfg->dongle_up = false;
5888 err = brcmf_init_priv_mem(cfg);
5889 if (err)
5890 return err;
5891 brcmf_register_event_handlers(cfg);
5892 mutex_init(&cfg->usr_sync);
5893 brcmf_init_escan(cfg);
5894 brcmf_init_conf(cfg->conf);
5895 init_completion(&cfg->vif_disabled);
5896 return err;
5897 }
5898
5899 static void wl_deinit_priv(struct brcmf_cfg80211_info *cfg)
5900 {
5901 cfg->dongle_up = false;
5902 brcmf_abort_scanning(cfg);
5903 brcmf_deinit_priv_mem(cfg);
5904 }
5905
5906 static void init_vif_event(struct brcmf_cfg80211_vif_event *event)
5907 {
5908 init_waitqueue_head(&event->vif_wq);
5909 spin_lock_init(&event->vif_event_lock);
5910 }
5911
5912 static s32 brcmf_dongle_roam(struct brcmf_if *ifp)
5913 {
5914 struct brcmf_pub *drvr = ifp->drvr;
5915 s32 err;
5916 u32 bcn_timeout;
5917 __le32 roamtrigger[2];
5918 __le32 roam_delta[2];
5919
5920
5921 if (ifp->drvr->settings->roamoff)
5922 bcn_timeout = BRCMF_DEFAULT_BCN_TIMEOUT_ROAM_OFF;
5923 else
5924 bcn_timeout = BRCMF_DEFAULT_BCN_TIMEOUT_ROAM_ON;
5925 err = brcmf_fil_iovar_int_set(ifp, "bcn_timeout", bcn_timeout);
5926 if (err) {
5927 bphy_err(drvr, "bcn_timeout error (%d)\n", err);
5928 goto roam_setup_done;
5929 }
5930
5931
5932
5933
5934 brcmf_dbg(INFO, "Internal Roaming = %s\n",
5935 ifp->drvr->settings->roamoff ? "Off" : "On");
5936 err = brcmf_fil_iovar_int_set(ifp, "roam_off",
5937 ifp->drvr->settings->roamoff);
5938 if (err) {
5939 bphy_err(drvr, "roam_off error (%d)\n", err);
5940 goto roam_setup_done;
5941 }
5942
5943 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL);
5944 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL);
5945 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_TRIGGER,
5946 (void *)roamtrigger, sizeof(roamtrigger));
5947 if (err) {
5948 bphy_err(drvr, "WLC_SET_ROAM_TRIGGER error (%d)\n", err);
5949 goto roam_setup_done;
5950 }
5951
5952 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA);
5953 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL);
5954 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_DELTA,
5955 (void *)roam_delta, sizeof(roam_delta));
5956 if (err) {
5957 bphy_err(drvr, "WLC_SET_ROAM_DELTA error (%d)\n", err);
5958 goto roam_setup_done;
5959 }
5960
5961 roam_setup_done:
5962 return err;
5963 }
5964
5965 static s32
5966 brcmf_dongle_scantime(struct brcmf_if *ifp)
5967 {
5968 struct brcmf_pub *drvr = ifp->drvr;
5969 s32 err = 0;
5970
5971 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
5972 BRCMF_SCAN_CHANNEL_TIME);
5973 if (err) {
5974 bphy_err(drvr, "Scan assoc time error (%d)\n", err);
5975 goto dongle_scantime_out;
5976 }
5977 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
5978 BRCMF_SCAN_UNASSOC_TIME);
5979 if (err) {
5980 bphy_err(drvr, "Scan unassoc time error (%d)\n", err);
5981 goto dongle_scantime_out;
5982 }
5983
5984 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_PASSIVE_TIME,
5985 BRCMF_SCAN_PASSIVE_TIME);
5986 if (err) {
5987 bphy_err(drvr, "Scan passive time error (%d)\n", err);
5988 goto dongle_scantime_out;
5989 }
5990
5991 dongle_scantime_out:
5992 return err;
5993 }
5994
5995 static void brcmf_update_bw40_channel_flag(struct ieee80211_channel *channel,
5996 struct brcmu_chan *ch)
5997 {
5998 u32 ht40_flag;
5999
6000 ht40_flag = channel->flags & IEEE80211_CHAN_NO_HT40;
6001 if (ch->sb == BRCMU_CHAN_SB_U) {
6002 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
6003 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
6004 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
6005 } else {
6006
6007
6008
6009
6010 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
6011 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
6012 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
6013 }
6014 }
6015
6016 static int brcmf_construct_chaninfo(struct brcmf_cfg80211_info *cfg,
6017 u32 bw_cap[])
6018 {
6019 struct wiphy *wiphy = cfg_to_wiphy(cfg);
6020 struct brcmf_pub *drvr = cfg->pub;
6021 struct brcmf_if *ifp = brcmf_get_ifp(drvr, 0);
6022 struct ieee80211_supported_band *band;
6023 struct ieee80211_channel *channel;
6024 struct brcmf_chanspec_list *list;
6025 struct brcmu_chan ch;
6026 int err;
6027 u8 *pbuf;
6028 u32 i, j;
6029 u32 total;
6030 u32 chaninfo;
6031
6032 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
6033
6034 if (pbuf == NULL)
6035 return -ENOMEM;
6036
6037 list = (struct brcmf_chanspec_list *)pbuf;
6038
6039 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
6040 BRCMF_DCMD_MEDLEN);
6041 if (err) {
6042 bphy_err(drvr, "get chanspecs error (%d)\n", err);
6043 goto fail_pbuf;
6044 }
6045
6046 band = wiphy->bands[NL80211_BAND_2GHZ];
6047 if (band)
6048 for (i = 0; i < band->n_channels; i++)
6049 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
6050 band = wiphy->bands[NL80211_BAND_5GHZ];
6051 if (band)
6052 for (i = 0; i < band->n_channels; i++)
6053 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
6054
6055 total = le32_to_cpu(list->count);
6056 for (i = 0; i < total; i++) {
6057 ch.chspec = (u16)le32_to_cpu(list->element[i]);
6058 cfg->d11inf.decchspec(&ch);
6059
6060 if (ch.band == BRCMU_CHAN_BAND_2G) {
6061 band = wiphy->bands[NL80211_BAND_2GHZ];
6062 } else if (ch.band == BRCMU_CHAN_BAND_5G) {
6063 band = wiphy->bands[NL80211_BAND_5GHZ];
6064 } else {
6065 bphy_err(drvr, "Invalid channel Spec. 0x%x.\n",
6066 ch.chspec);
6067 continue;
6068 }
6069 if (!band)
6070 continue;
6071 if (!(bw_cap[band->band] & WLC_BW_40MHZ_BIT) &&
6072 ch.bw == BRCMU_CHAN_BW_40)
6073 continue;
6074 if (!(bw_cap[band->band] & WLC_BW_80MHZ_BIT) &&
6075 ch.bw == BRCMU_CHAN_BW_80)
6076 continue;
6077
6078 channel = NULL;
6079 for (j = 0; j < band->n_channels; j++) {
6080 if (band->channels[j].hw_value == ch.control_ch_num) {
6081 channel = &band->channels[j];
6082 break;
6083 }
6084 }
6085 if (!channel) {
6086
6087
6088
6089 bphy_err(drvr, "Ignoring unexpected firmware channel %d\n",
6090 ch.control_ch_num);
6091 continue;
6092 }
6093
6094 if (channel->orig_flags & IEEE80211_CHAN_DISABLED)
6095 continue;
6096
6097
6098
6099
6100 switch (ch.bw) {
6101 case BRCMU_CHAN_BW_160:
6102 channel->flags &= ~IEEE80211_CHAN_NO_160MHZ;
6103 break;
6104 case BRCMU_CHAN_BW_80:
6105 channel->flags &= ~IEEE80211_CHAN_NO_80MHZ;
6106 break;
6107 case BRCMU_CHAN_BW_40:
6108 brcmf_update_bw40_channel_flag(channel, &ch);
6109 break;
6110 default:
6111 wiphy_warn(wiphy, "Firmware reported unsupported bandwidth %d\n",
6112 ch.bw);
6113
6114 case BRCMU_CHAN_BW_20:
6115
6116
6117
6118
6119 channel->flags = IEEE80211_CHAN_NO_HT40 |
6120 IEEE80211_CHAN_NO_80MHZ |
6121 IEEE80211_CHAN_NO_160MHZ;
6122 ch.bw = BRCMU_CHAN_BW_20;
6123 cfg->d11inf.encchspec(&ch);
6124 chaninfo = ch.chspec;
6125 err = brcmf_fil_bsscfg_int_get(ifp, "per_chan_info",
6126 &chaninfo);
6127 if (!err) {
6128 if (chaninfo & WL_CHAN_RADAR)
6129 channel->flags |=
6130 (IEEE80211_CHAN_RADAR |
6131 IEEE80211_CHAN_NO_IR);
6132 if (chaninfo & WL_CHAN_PASSIVE)
6133 channel->flags |=
6134 IEEE80211_CHAN_NO_IR;
6135 }
6136 }
6137 }
6138
6139 fail_pbuf:
6140 kfree(pbuf);
6141 return err;
6142 }
6143
6144 static int brcmf_enable_bw40_2g(struct brcmf_cfg80211_info *cfg)
6145 {
6146 struct brcmf_pub *drvr = cfg->pub;
6147 struct brcmf_if *ifp = brcmf_get_ifp(drvr, 0);
6148 struct ieee80211_supported_band *band;
6149 struct brcmf_fil_bwcap_le band_bwcap;
6150 struct brcmf_chanspec_list *list;
6151 u8 *pbuf;
6152 u32 val;
6153 int err;
6154 struct brcmu_chan ch;
6155 u32 num_chan;
6156 int i, j;
6157
6158
6159 val = WLC_BAND_5G;
6160 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &val);
6161
6162 if (!err) {
6163
6164 band_bwcap.band = cpu_to_le32(WLC_BAND_2G);
6165 band_bwcap.bw_cap = cpu_to_le32(WLC_BW_CAP_40MHZ);
6166 err = brcmf_fil_iovar_data_set(ifp, "bw_cap", &band_bwcap,
6167 sizeof(band_bwcap));
6168 } else {
6169 brcmf_dbg(INFO, "fallback to mimo_bw_cap\n");
6170 val = WLC_N_BW_40ALL;
6171 err = brcmf_fil_iovar_int_set(ifp, "mimo_bw_cap", val);
6172 }
6173
6174 if (!err) {
6175
6176 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
6177
6178 if (pbuf == NULL)
6179 return -ENOMEM;
6180
6181 ch.band = BRCMU_CHAN_BAND_2G;
6182 ch.bw = BRCMU_CHAN_BW_40;
6183 ch.sb = BRCMU_CHAN_SB_NONE;
6184 ch.chnum = 0;
6185 cfg->d11inf.encchspec(&ch);
6186
6187
6188 *(__le16 *)pbuf = cpu_to_le16(ch.chspec);
6189
6190 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
6191 BRCMF_DCMD_MEDLEN);
6192 if (err) {
6193 bphy_err(drvr, "get chanspecs error (%d)\n", err);
6194 kfree(pbuf);
6195 return err;
6196 }
6197
6198 band = cfg_to_wiphy(cfg)->bands[NL80211_BAND_2GHZ];
6199 list = (struct brcmf_chanspec_list *)pbuf;
6200 num_chan = le32_to_cpu(list->count);
6201 for (i = 0; i < num_chan; i++) {
6202 ch.chspec = (u16)le32_to_cpu(list->element[i]);
6203 cfg->d11inf.decchspec(&ch);
6204 if (WARN_ON(ch.band != BRCMU_CHAN_BAND_2G))
6205 continue;
6206 if (WARN_ON(ch.bw != BRCMU_CHAN_BW_40))
6207 continue;
6208 for (j = 0; j < band->n_channels; j++) {
6209 if (band->channels[j].hw_value == ch.control_ch_num)
6210 break;
6211 }
6212 if (WARN_ON(j == band->n_channels))
6213 continue;
6214
6215 brcmf_update_bw40_channel_flag(&band->channels[j], &ch);
6216 }
6217 kfree(pbuf);
6218 }
6219 return err;
6220 }
6221
6222 static void brcmf_get_bwcap(struct brcmf_if *ifp, u32 bw_cap[])
6223 {
6224 struct brcmf_pub *drvr = ifp->drvr;
6225 u32 band, mimo_bwcap;
6226 int err;
6227
6228 band = WLC_BAND_2G;
6229 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
6230 if (!err) {
6231 bw_cap[NL80211_BAND_2GHZ] = band;
6232 band = WLC_BAND_5G;
6233 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
6234 if (!err) {
6235 bw_cap[NL80211_BAND_5GHZ] = band;
6236 return;
6237 }
6238 WARN_ON(1);
6239 return;
6240 }
6241 brcmf_dbg(INFO, "fallback to mimo_bw_cap info\n");
6242 mimo_bwcap = 0;
6243 err = brcmf_fil_iovar_int_get(ifp, "mimo_bw_cap", &mimo_bwcap);
6244 if (err)
6245
6246 mimo_bwcap = WLC_N_BW_20ALL;
6247
6248 switch (mimo_bwcap) {
6249 case WLC_N_BW_40ALL:
6250 bw_cap[NL80211_BAND_2GHZ] |= WLC_BW_40MHZ_BIT;
6251
6252 case WLC_N_BW_20IN2G_40IN5G:
6253 bw_cap[NL80211_BAND_5GHZ] |= WLC_BW_40MHZ_BIT;
6254
6255 case WLC_N_BW_20ALL:
6256 bw_cap[NL80211_BAND_2GHZ] |= WLC_BW_20MHZ_BIT;
6257 bw_cap[NL80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT;
6258 break;
6259 default:
6260 bphy_err(drvr, "invalid mimo_bw_cap value\n");
6261 }
6262 }
6263
6264 static void brcmf_update_ht_cap(struct ieee80211_supported_band *band,
6265 u32 bw_cap[2], u32 nchain)
6266 {
6267 band->ht_cap.ht_supported = true;
6268 if (bw_cap[band->band] & WLC_BW_40MHZ_BIT) {
6269 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
6270 band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
6271 }
6272 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
6273 band->ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
6274 band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
6275 band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
6276 memset(band->ht_cap.mcs.rx_mask, 0xff, nchain);
6277 band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
6278 }
6279
6280 static __le16 brcmf_get_mcs_map(u32 nchain, enum ieee80211_vht_mcs_support supp)
6281 {
6282 u16 mcs_map;
6283 int i;
6284
6285 for (i = 0, mcs_map = 0xFFFF; i < nchain; i++)
6286 mcs_map = (mcs_map << 2) | supp;
6287
6288 return cpu_to_le16(mcs_map);
6289 }
6290
6291 static void brcmf_update_vht_cap(struct ieee80211_supported_band *band,
6292 u32 bw_cap[2], u32 nchain, u32 txstreams,
6293 u32 txbf_bfe_cap, u32 txbf_bfr_cap)
6294 {
6295 __le16 mcs_map;
6296
6297
6298 if (band->band == NL80211_BAND_2GHZ)
6299 return;
6300
6301 band->vht_cap.vht_supported = true;
6302
6303 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_80;
6304 if (bw_cap[band->band] & WLC_BW_160MHZ_BIT) {
6305 band->vht_cap.cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
6306 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_160;
6307 }
6308
6309 mcs_map = brcmf_get_mcs_map(nchain, IEEE80211_VHT_MCS_SUPPORT_0_9);
6310 band->vht_cap.vht_mcs.rx_mcs_map = mcs_map;
6311 band->vht_cap.vht_mcs.tx_mcs_map = mcs_map;
6312
6313
6314 if (txbf_bfe_cap & BRCMF_TXBF_SU_BFE_CAP)
6315 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE;
6316 if (txbf_bfe_cap & BRCMF_TXBF_MU_BFE_CAP)
6317 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
6318 if (txbf_bfr_cap & BRCMF_TXBF_SU_BFR_CAP)
6319 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
6320 if (txbf_bfr_cap & BRCMF_TXBF_MU_BFR_CAP)
6321 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE;
6322
6323 if ((txbf_bfe_cap || txbf_bfr_cap) && (txstreams > 1)) {
6324 band->vht_cap.cap |=
6325 (2 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT);
6326 band->vht_cap.cap |= ((txstreams - 1) <<
6327 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT);
6328 band->vht_cap.cap |=
6329 IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB;
6330 }
6331 }
6332
6333 static int brcmf_setup_wiphybands(struct brcmf_cfg80211_info *cfg)
6334 {
6335 struct brcmf_pub *drvr = cfg->pub;
6336 struct brcmf_if *ifp = brcmf_get_ifp(drvr, 0);
6337 struct wiphy *wiphy = cfg_to_wiphy(cfg);
6338 u32 nmode = 0;
6339 u32 vhtmode = 0;
6340 u32 bw_cap[2] = { WLC_BW_20MHZ_BIT, WLC_BW_20MHZ_BIT };
6341 u32 rxchain;
6342 u32 nchain;
6343 int err;
6344 s32 i;
6345 struct ieee80211_supported_band *band;
6346 u32 txstreams = 0;
6347 u32 txbf_bfe_cap = 0;
6348 u32 txbf_bfr_cap = 0;
6349
6350 (void)brcmf_fil_iovar_int_get(ifp, "vhtmode", &vhtmode);
6351 err = brcmf_fil_iovar_int_get(ifp, "nmode", &nmode);
6352 if (err) {
6353 bphy_err(drvr, "nmode error (%d)\n", err);
6354 } else {
6355 brcmf_get_bwcap(ifp, bw_cap);
6356 }
6357 brcmf_dbg(INFO, "nmode=%d, vhtmode=%d, bw_cap=(%d, %d)\n",
6358 nmode, vhtmode, bw_cap[NL80211_BAND_2GHZ],
6359 bw_cap[NL80211_BAND_5GHZ]);
6360
6361 err = brcmf_fil_iovar_int_get(ifp, "rxchain", &rxchain);
6362 if (err) {
6363 bphy_err(drvr, "rxchain error (%d)\n", err);
6364 nchain = 1;
6365 } else {
6366 for (nchain = 0; rxchain; nchain++)
6367 rxchain = rxchain & (rxchain - 1);
6368 }
6369 brcmf_dbg(INFO, "nchain=%d\n", nchain);
6370
6371 err = brcmf_construct_chaninfo(cfg, bw_cap);
6372 if (err) {
6373 bphy_err(drvr, "brcmf_construct_chaninfo failed (%d)\n", err);
6374 return err;
6375 }
6376
6377 if (vhtmode) {
6378 (void)brcmf_fil_iovar_int_get(ifp, "txstreams", &txstreams);
6379 (void)brcmf_fil_iovar_int_get(ifp, "txbf_bfe_cap",
6380 &txbf_bfe_cap);
6381 (void)brcmf_fil_iovar_int_get(ifp, "txbf_bfr_cap",
6382 &txbf_bfr_cap);
6383 }
6384
6385 for (i = 0; i < ARRAY_SIZE(wiphy->bands); i++) {
6386 band = wiphy->bands[i];
6387 if (band == NULL)
6388 continue;
6389
6390 if (nmode)
6391 brcmf_update_ht_cap(band, bw_cap, nchain);
6392 if (vhtmode)
6393 brcmf_update_vht_cap(band, bw_cap, nchain, txstreams,
6394 txbf_bfe_cap, txbf_bfr_cap);
6395 }
6396
6397 return 0;
6398 }
6399
6400 static const struct ieee80211_txrx_stypes
6401 brcmf_txrx_stypes[NUM_NL80211_IFTYPES] = {
6402 [NL80211_IFTYPE_STATION] = {
6403 .tx = 0xffff,
6404 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
6405 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
6406 },
6407 [NL80211_IFTYPE_P2P_CLIENT] = {
6408 .tx = 0xffff,
6409 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
6410 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
6411 },
6412 [NL80211_IFTYPE_P2P_GO] = {
6413 .tx = 0xffff,
6414 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
6415 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
6416 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
6417 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
6418 BIT(IEEE80211_STYPE_AUTH >> 4) |
6419 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
6420 BIT(IEEE80211_STYPE_ACTION >> 4)
6421 },
6422 [NL80211_IFTYPE_P2P_DEVICE] = {
6423 .tx = 0xffff,
6424 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
6425 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
6426 },
6427 [NL80211_IFTYPE_AP] = {
6428 .tx = 0xffff,
6429 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
6430 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
6431 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
6432 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
6433 BIT(IEEE80211_STYPE_AUTH >> 4) |
6434 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
6435 BIT(IEEE80211_STYPE_ACTION >> 4)
6436 }
6437 };
6438
6439
6440
6441
6442
6443
6444
6445
6446
6447
6448
6449
6450
6451
6452
6453
6454
6455
6456
6457
6458
6459
6460
6461
6462
6463
6464
6465
6466
6467
6468
6469 static int brcmf_setup_ifmodes(struct wiphy *wiphy, struct brcmf_if *ifp)
6470 {
6471 struct ieee80211_iface_combination *combo = NULL;
6472 struct ieee80211_iface_limit *c0_limits = NULL;
6473 struct ieee80211_iface_limit *p2p_limits = NULL;
6474 struct ieee80211_iface_limit *mbss_limits = NULL;
6475 bool mbss, p2p;
6476 int i, c, n_combos;
6477
6478 mbss = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS);
6479 p2p = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_P2P);
6480
6481 n_combos = 1 + !!p2p + !!mbss;
6482 combo = kcalloc(n_combos, sizeof(*combo), GFP_KERNEL);
6483 if (!combo)
6484 goto err;
6485
6486 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
6487 BIT(NL80211_IFTYPE_ADHOC) |
6488 BIT(NL80211_IFTYPE_AP);
6489
6490 c = 0;
6491 i = 0;
6492 c0_limits = kcalloc(p2p ? 3 : 2, sizeof(*c0_limits), GFP_KERNEL);
6493 if (!c0_limits)
6494 goto err;
6495 c0_limits[i].max = 1;
6496 c0_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
6497 if (p2p) {
6498 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MCHAN))
6499 combo[c].num_different_channels = 2;
6500 else
6501 combo[c].num_different_channels = 1;
6502 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_CLIENT) |
6503 BIT(NL80211_IFTYPE_P2P_GO) |
6504 BIT(NL80211_IFTYPE_P2P_DEVICE);
6505 c0_limits[i].max = 1;
6506 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
6507 c0_limits[i].max = 1;
6508 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT) |
6509 BIT(NL80211_IFTYPE_P2P_GO);
6510 } else {
6511 combo[c].num_different_channels = 1;
6512 c0_limits[i].max = 1;
6513 c0_limits[i++].types = BIT(NL80211_IFTYPE_AP);
6514 }
6515 combo[c].max_interfaces = i;
6516 combo[c].n_limits = i;
6517 combo[c].limits = c0_limits;
6518
6519 if (p2p) {
6520 c++;
6521 i = 0;
6522 p2p_limits = kcalloc(4, sizeof(*p2p_limits), GFP_KERNEL);
6523 if (!p2p_limits)
6524 goto err;
6525 p2p_limits[i].max = 1;
6526 p2p_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
6527 p2p_limits[i].max = 1;
6528 p2p_limits[i++].types = BIT(NL80211_IFTYPE_AP);
6529 p2p_limits[i].max = 1;
6530 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT);
6531 p2p_limits[i].max = 1;
6532 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
6533 combo[c].num_different_channels = 1;
6534 combo[c].max_interfaces = i;
6535 combo[c].n_limits = i;
6536 combo[c].limits = p2p_limits;
6537 }
6538
6539 if (mbss) {
6540 c++;
6541 i = 0;
6542 mbss_limits = kcalloc(1, sizeof(*mbss_limits), GFP_KERNEL);
6543 if (!mbss_limits)
6544 goto err;
6545 mbss_limits[i].max = 4;
6546 mbss_limits[i++].types = BIT(NL80211_IFTYPE_AP);
6547 combo[c].beacon_int_infra_match = true;
6548 combo[c].num_different_channels = 1;
6549 combo[c].max_interfaces = 4;
6550 combo[c].n_limits = i;
6551 combo[c].limits = mbss_limits;
6552 }
6553
6554 wiphy->n_iface_combinations = n_combos;
6555 wiphy->iface_combinations = combo;
6556 return 0;
6557
6558 err:
6559 kfree(c0_limits);
6560 kfree(p2p_limits);
6561 kfree(mbss_limits);
6562 kfree(combo);
6563 return -ENOMEM;
6564 }
6565
6566 #ifdef CONFIG_PM
6567 static const struct wiphy_wowlan_support brcmf_wowlan_support = {
6568 .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT,
6569 .n_patterns = BRCMF_WOWL_MAXPATTERNS,
6570 .pattern_max_len = BRCMF_WOWL_MAXPATTERNSIZE,
6571 .pattern_min_len = 1,
6572 .max_pkt_offset = 1500,
6573 };
6574 #endif
6575
6576 static void brcmf_wiphy_wowl_params(struct wiphy *wiphy, struct brcmf_if *ifp)
6577 {
6578 #ifdef CONFIG_PM
6579 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
6580 struct brcmf_pub *drvr = cfg->pub;
6581 struct wiphy_wowlan_support *wowl;
6582
6583 wowl = kmemdup(&brcmf_wowlan_support, sizeof(brcmf_wowlan_support),
6584 GFP_KERNEL);
6585 if (!wowl) {
6586 bphy_err(drvr, "only support basic wowlan features\n");
6587 wiphy->wowlan = &brcmf_wowlan_support;
6588 return;
6589 }
6590
6591 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO)) {
6592 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_ND)) {
6593 wowl->flags |= WIPHY_WOWLAN_NET_DETECT;
6594 wowl->max_nd_match_sets = BRCMF_PNO_MAX_PFN_COUNT;
6595 init_waitqueue_head(&cfg->wowl.nd_data_wait);
6596 }
6597 }
6598 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_GTK)) {
6599 wowl->flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY;
6600 wowl->flags |= WIPHY_WOWLAN_GTK_REKEY_FAILURE;
6601 }
6602
6603 wiphy->wowlan = wowl;
6604 #endif
6605 }
6606
6607 static int brcmf_setup_wiphy(struct wiphy *wiphy, struct brcmf_if *ifp)
6608 {
6609 struct brcmf_pub *drvr = ifp->drvr;
6610 const struct ieee80211_iface_combination *combo;
6611 struct ieee80211_supported_band *band;
6612 u16 max_interfaces = 0;
6613 bool gscan;
6614 __le32 bandlist[3];
6615 u32 n_bands;
6616 int err, i;
6617
6618 wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
6619 wiphy->max_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
6620 wiphy->max_num_pmkids = BRCMF_MAXPMKID;
6621
6622 err = brcmf_setup_ifmodes(wiphy, ifp);
6623 if (err)
6624 return err;
6625
6626 for (i = 0, combo = wiphy->iface_combinations;
6627 i < wiphy->n_iface_combinations; i++, combo++) {
6628 max_interfaces = max(max_interfaces, combo->max_interfaces);
6629 }
6630
6631 for (i = 0; i < max_interfaces && i < ARRAY_SIZE(drvr->addresses);
6632 i++) {
6633 u8 *addr = drvr->addresses[i].addr;
6634
6635 memcpy(addr, drvr->mac, ETH_ALEN);
6636 if (i) {
6637 addr[0] |= BIT(1);
6638 addr[ETH_ALEN - 1] ^= i;
6639 }
6640 }
6641 wiphy->addresses = drvr->addresses;
6642 wiphy->n_addresses = i;
6643
6644 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
6645 wiphy->cipher_suites = brcmf_cipher_suites;
6646 wiphy->n_cipher_suites = ARRAY_SIZE(brcmf_cipher_suites);
6647 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP))
6648 wiphy->n_cipher_suites--;
6649 wiphy->bss_select_support = BIT(NL80211_BSS_SELECT_ATTR_RSSI) |
6650 BIT(NL80211_BSS_SELECT_ATTR_BAND_PREF) |
6651 BIT(NL80211_BSS_SELECT_ATTR_RSSI_ADJUST);
6652
6653 wiphy->flags |= WIPHY_FLAG_NETNS_OK |
6654 WIPHY_FLAG_PS_ON_BY_DEFAULT |
6655 WIPHY_FLAG_HAVE_AP_SME |
6656 WIPHY_FLAG_OFFCHAN_TX |
6657 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
6658 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_TDLS))
6659 wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
6660 if (!ifp->drvr->settings->roamoff)
6661 wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM;
6662 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_FWSUP)) {
6663 wiphy_ext_feature_set(wiphy,
6664 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK);
6665 wiphy_ext_feature_set(wiphy,
6666 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X);
6667 }
6668 wiphy->mgmt_stypes = brcmf_txrx_stypes;
6669 wiphy->max_remain_on_channel_duration = 5000;
6670 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO)) {
6671 gscan = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_GSCAN);
6672 brcmf_pno_wiphy_params(wiphy, gscan);
6673 }
6674
6675 wiphy->vendor_commands = brcmf_vendor_cmds;
6676 wiphy->n_vendor_commands = BRCMF_VNDR_CMDS_LAST - 1;
6677
6678 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL))
6679 brcmf_wiphy_wowl_params(wiphy, ifp);
6680 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BANDLIST, &bandlist,
6681 sizeof(bandlist));
6682 if (err) {
6683 bphy_err(drvr, "could not obtain band info: err=%d\n", err);
6684 return err;
6685 }
6686
6687 n_bands = le32_to_cpu(bandlist[0]);
6688 for (i = 1; i <= n_bands && i < ARRAY_SIZE(bandlist); i++) {
6689 if (bandlist[i] == cpu_to_le32(WLC_BAND_2G)) {
6690 band = kmemdup(&__wl_band_2ghz, sizeof(__wl_band_2ghz),
6691 GFP_KERNEL);
6692 if (!band)
6693 return -ENOMEM;
6694
6695 band->channels = kmemdup(&__wl_2ghz_channels,
6696 sizeof(__wl_2ghz_channels),
6697 GFP_KERNEL);
6698 if (!band->channels) {
6699 kfree(band);
6700 return -ENOMEM;
6701 }
6702
6703 band->n_channels = ARRAY_SIZE(__wl_2ghz_channels);
6704 wiphy->bands[NL80211_BAND_2GHZ] = band;
6705 }
6706 if (bandlist[i] == cpu_to_le32(WLC_BAND_5G)) {
6707 band = kmemdup(&__wl_band_5ghz, sizeof(__wl_band_5ghz),
6708 GFP_KERNEL);
6709 if (!band)
6710 return -ENOMEM;
6711
6712 band->channels = kmemdup(&__wl_5ghz_channels,
6713 sizeof(__wl_5ghz_channels),
6714 GFP_KERNEL);
6715 if (!band->channels) {
6716 kfree(band);
6717 return -ENOMEM;
6718 }
6719
6720 band->n_channels = ARRAY_SIZE(__wl_5ghz_channels);
6721 wiphy->bands[NL80211_BAND_5GHZ] = band;
6722 }
6723 }
6724
6725 if (wiphy->bands[NL80211_BAND_5GHZ] &&
6726 brcmf_feat_is_enabled(ifp, BRCMF_FEAT_DOT11H))
6727 wiphy_ext_feature_set(wiphy,
6728 NL80211_EXT_FEATURE_DFS_OFFLOAD);
6729
6730 wiphy_read_of_freq_limits(wiphy);
6731
6732 return 0;
6733 }
6734
6735 static s32 brcmf_config_dongle(struct brcmf_cfg80211_info *cfg)
6736 {
6737 struct brcmf_pub *drvr = cfg->pub;
6738 struct net_device *ndev;
6739 struct wireless_dev *wdev;
6740 struct brcmf_if *ifp;
6741 s32 power_mode;
6742 s32 err = 0;
6743
6744 if (cfg->dongle_up)
6745 return err;
6746
6747 ndev = cfg_to_ndev(cfg);
6748 wdev = ndev->ieee80211_ptr;
6749 ifp = netdev_priv(ndev);
6750
6751
6752 brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 0);
6753
6754 brcmf_dongle_scantime(ifp);
6755
6756 power_mode = cfg->pwr_save ? PM_FAST : PM_OFF;
6757 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, power_mode);
6758 if (err)
6759 goto default_conf_out;
6760 brcmf_dbg(INFO, "power save set to %s\n",
6761 (power_mode ? "enabled" : "disabled"));
6762
6763 err = brcmf_dongle_roam(ifp);
6764 if (err)
6765 goto default_conf_out;
6766 err = brcmf_cfg80211_change_iface(wdev->wiphy, ndev, wdev->iftype,
6767 NULL);
6768 if (err)
6769 goto default_conf_out;
6770
6771 brcmf_configure_arp_nd_offload(ifp, true);
6772
6773 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_FAKEFRAG, 1);
6774 if (err) {
6775 bphy_err(drvr, "failed to set frameburst mode\n");
6776 goto default_conf_out;
6777 }
6778
6779 cfg->dongle_up = true;
6780 default_conf_out:
6781
6782 return err;
6783
6784 }
6785
6786 static s32 __brcmf_cfg80211_up(struct brcmf_if *ifp)
6787 {
6788 set_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
6789
6790 return brcmf_config_dongle(ifp->drvr->config);
6791 }
6792
6793 static s32 __brcmf_cfg80211_down(struct brcmf_if *ifp)
6794 {
6795 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
6796
6797
6798
6799
6800
6801 if (check_vif_up(ifp->vif)) {
6802 brcmf_link_down(ifp->vif, WLAN_REASON_UNSPECIFIED);
6803
6804
6805
6806
6807
6808 brcmf_delay(500);
6809 }
6810
6811 brcmf_abort_scanning(cfg);
6812 clear_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
6813
6814 return 0;
6815 }
6816
6817 s32 brcmf_cfg80211_up(struct net_device *ndev)
6818 {
6819 struct brcmf_if *ifp = netdev_priv(ndev);
6820 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
6821 s32 err = 0;
6822
6823 mutex_lock(&cfg->usr_sync);
6824 err = __brcmf_cfg80211_up(ifp);
6825 mutex_unlock(&cfg->usr_sync);
6826
6827 return err;
6828 }
6829
6830 s32 brcmf_cfg80211_down(struct net_device *ndev)
6831 {
6832 struct brcmf_if *ifp = netdev_priv(ndev);
6833 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
6834 s32 err = 0;
6835
6836 mutex_lock(&cfg->usr_sync);
6837 err = __brcmf_cfg80211_down(ifp);
6838 mutex_unlock(&cfg->usr_sync);
6839
6840 return err;
6841 }
6842
6843 enum nl80211_iftype brcmf_cfg80211_get_iftype(struct brcmf_if *ifp)
6844 {
6845 struct wireless_dev *wdev = &ifp->vif->wdev;
6846
6847 return wdev->iftype;
6848 }
6849
6850 bool brcmf_get_vif_state_any(struct brcmf_cfg80211_info *cfg,
6851 unsigned long state)
6852 {
6853 struct brcmf_cfg80211_vif *vif;
6854
6855 list_for_each_entry(vif, &cfg->vif_list, list) {
6856 if (test_bit(state, &vif->sme_state))
6857 return true;
6858 }
6859 return false;
6860 }
6861
6862 static inline bool vif_event_equals(struct brcmf_cfg80211_vif_event *event,
6863 u8 action)
6864 {
6865 u8 evt_action;
6866
6867 spin_lock(&event->vif_event_lock);
6868 evt_action = event->action;
6869 spin_unlock(&event->vif_event_lock);
6870 return evt_action == action;
6871 }
6872
6873 void brcmf_cfg80211_arm_vif_event(struct brcmf_cfg80211_info *cfg,
6874 struct brcmf_cfg80211_vif *vif)
6875 {
6876 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6877
6878 spin_lock(&event->vif_event_lock);
6879 event->vif = vif;
6880 event->action = 0;
6881 spin_unlock(&event->vif_event_lock);
6882 }
6883
6884 bool brcmf_cfg80211_vif_event_armed(struct brcmf_cfg80211_info *cfg)
6885 {
6886 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6887 bool armed;
6888
6889 spin_lock(&event->vif_event_lock);
6890 armed = event->vif != NULL;
6891 spin_unlock(&event->vif_event_lock);
6892
6893 return armed;
6894 }
6895
6896 int brcmf_cfg80211_wait_vif_event(struct brcmf_cfg80211_info *cfg,
6897 u8 action, ulong timeout)
6898 {
6899 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6900
6901 return wait_event_timeout(event->vif_wq,
6902 vif_event_equals(event, action), timeout);
6903 }
6904
6905 static s32 brcmf_translate_country_code(struct brcmf_pub *drvr, char alpha2[2],
6906 struct brcmf_fil_country_le *ccreq)
6907 {
6908 struct brcmfmac_pd_cc *country_codes;
6909 struct brcmfmac_pd_cc_entry *cc;
6910 s32 found_index;
6911 int i;
6912
6913 country_codes = drvr->settings->country_codes;
6914 if (!country_codes) {
6915 brcmf_dbg(TRACE, "No country codes configured for device\n");
6916 return -EINVAL;
6917 }
6918
6919 if ((alpha2[0] == ccreq->country_abbrev[0]) &&
6920 (alpha2[1] == ccreq->country_abbrev[1])) {
6921 brcmf_dbg(TRACE, "Country code already set\n");
6922 return -EAGAIN;
6923 }
6924
6925 found_index = -1;
6926 for (i = 0; i < country_codes->table_size; i++) {
6927 cc = &country_codes->table[i];
6928 if ((cc->iso3166[0] == '\0') && (found_index == -1))
6929 found_index = i;
6930 if ((cc->iso3166[0] == alpha2[0]) &&
6931 (cc->iso3166[1] == alpha2[1])) {
6932 found_index = i;
6933 break;
6934 }
6935 }
6936 if (found_index == -1) {
6937 brcmf_dbg(TRACE, "No country code match found\n");
6938 return -EINVAL;
6939 }
6940 memset(ccreq, 0, sizeof(*ccreq));
6941 ccreq->rev = cpu_to_le32(country_codes->table[found_index].rev);
6942 memcpy(ccreq->ccode, country_codes->table[found_index].cc,
6943 BRCMF_COUNTRY_BUF_SZ);
6944 ccreq->country_abbrev[0] = alpha2[0];
6945 ccreq->country_abbrev[1] = alpha2[1];
6946 ccreq->country_abbrev[2] = 0;
6947
6948 return 0;
6949 }
6950
6951 static void brcmf_cfg80211_reg_notifier(struct wiphy *wiphy,
6952 struct regulatory_request *req)
6953 {
6954 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
6955 struct brcmf_if *ifp = brcmf_get_ifp(cfg->pub, 0);
6956 struct brcmf_pub *drvr = cfg->pub;
6957 struct brcmf_fil_country_le ccreq;
6958 s32 err;
6959 int i;
6960
6961
6962 if (req->alpha2[0] == '0' && req->alpha2[1] == '0')
6963 return;
6964
6965
6966 for (i = 0; i < 2; i++)
6967 if (req->alpha2[i] < 'A' || req->alpha2[i] > 'Z') {
6968 bphy_err(drvr, "not an ISO3166 code (0x%02x 0x%02x)\n",
6969 req->alpha2[0], req->alpha2[1]);
6970 return;
6971 }
6972
6973 brcmf_dbg(TRACE, "Enter: initiator=%d, alpha=%c%c\n", req->initiator,
6974 req->alpha2[0], req->alpha2[1]);
6975
6976 err = brcmf_fil_iovar_data_get(ifp, "country", &ccreq, sizeof(ccreq));
6977 if (err) {
6978 bphy_err(drvr, "Country code iovar returned err = %d\n", err);
6979 return;
6980 }
6981
6982 err = brcmf_translate_country_code(ifp->drvr, req->alpha2, &ccreq);
6983 if (err)
6984 return;
6985
6986 err = brcmf_fil_iovar_data_set(ifp, "country", &ccreq, sizeof(ccreq));
6987 if (err) {
6988 bphy_err(drvr, "Firmware rejected country setting\n");
6989 return;
6990 }
6991 brcmf_setup_wiphybands(cfg);
6992 }
6993
6994 static void brcmf_free_wiphy(struct wiphy *wiphy)
6995 {
6996 int i;
6997
6998 if (!wiphy)
6999 return;
7000
7001 if (wiphy->iface_combinations) {
7002 for (i = 0; i < wiphy->n_iface_combinations; i++)
7003 kfree(wiphy->iface_combinations[i].limits);
7004 }
7005 kfree(wiphy->iface_combinations);
7006 if (wiphy->bands[NL80211_BAND_2GHZ]) {
7007 kfree(wiphy->bands[NL80211_BAND_2GHZ]->channels);
7008 kfree(wiphy->bands[NL80211_BAND_2GHZ]);
7009 }
7010 if (wiphy->bands[NL80211_BAND_5GHZ]) {
7011 kfree(wiphy->bands[NL80211_BAND_5GHZ]->channels);
7012 kfree(wiphy->bands[NL80211_BAND_5GHZ]);
7013 }
7014 #if IS_ENABLED(CONFIG_PM)
7015 if (wiphy->wowlan != &brcmf_wowlan_support)
7016 kfree(wiphy->wowlan);
7017 #endif
7018 }
7019
7020 struct brcmf_cfg80211_info *brcmf_cfg80211_attach(struct brcmf_pub *drvr,
7021 struct cfg80211_ops *ops,
7022 bool p2pdev_forced)
7023 {
7024 struct wiphy *wiphy = drvr->wiphy;
7025 struct net_device *ndev = brcmf_get_ifp(drvr, 0)->ndev;
7026 struct brcmf_cfg80211_info *cfg;
7027 struct brcmf_cfg80211_vif *vif;
7028 struct brcmf_if *ifp;
7029 s32 err = 0;
7030 s32 io_type;
7031 u16 *cap = NULL;
7032
7033 if (!ndev) {
7034 bphy_err(drvr, "ndev is invalid\n");
7035 return NULL;
7036 }
7037
7038 cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
7039 if (!cfg) {
7040 bphy_err(drvr, "Could not allocate wiphy device\n");
7041 return NULL;
7042 }
7043
7044 cfg->wiphy = wiphy;
7045 cfg->pub = drvr;
7046 init_vif_event(&cfg->vif_event);
7047 INIT_LIST_HEAD(&cfg->vif_list);
7048
7049 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_STATION);
7050 if (IS_ERR(vif))
7051 goto wiphy_out;
7052
7053 ifp = netdev_priv(ndev);
7054 vif->ifp = ifp;
7055 vif->wdev.netdev = ndev;
7056 ndev->ieee80211_ptr = &vif->wdev;
7057 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy));
7058
7059 err = wl_init_priv(cfg);
7060 if (err) {
7061 bphy_err(drvr, "Failed to init iwm_priv (%d)\n", err);
7062 brcmf_free_vif(vif);
7063 goto wiphy_out;
7064 }
7065 ifp->vif = vif;
7066
7067
7068 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_VERSION, &io_type);
7069 if (err) {
7070 bphy_err(drvr, "Failed to get D11 version (%d)\n", err);
7071 goto priv_out;
7072 }
7073 cfg->d11inf.io_type = (u8)io_type;
7074 brcmu_d11_attach(&cfg->d11inf);
7075
7076
7077
7078
7079 drvr->config = cfg;
7080
7081 err = brcmf_setup_wiphy(wiphy, ifp);
7082 if (err < 0)
7083 goto priv_out;
7084
7085 brcmf_dbg(INFO, "Registering custom regulatory\n");
7086 wiphy->reg_notifier = brcmf_cfg80211_reg_notifier;
7087 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
7088 wiphy_apply_custom_regulatory(wiphy, &brcmf_regdom);
7089
7090
7091
7092
7093
7094 if (wiphy->bands[NL80211_BAND_2GHZ]) {
7095 cap = &wiphy->bands[NL80211_BAND_2GHZ]->ht_cap.cap;
7096 *cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
7097 }
7098 #ifdef CONFIG_PM
7099 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_GTK))
7100 ops->set_rekey_data = brcmf_cfg80211_set_rekey_data;
7101 #endif
7102 err = wiphy_register(wiphy);
7103 if (err < 0) {
7104 bphy_err(drvr, "Could not register wiphy device (%d)\n", err);
7105 goto priv_out;
7106 }
7107
7108 err = brcmf_setup_wiphybands(cfg);
7109 if (err) {
7110 bphy_err(drvr, "Setting wiphy bands failed (%d)\n", err);
7111 goto wiphy_unreg_out;
7112 }
7113
7114
7115
7116
7117 if (cap && (*cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)) {
7118 err = brcmf_enable_bw40_2g(cfg);
7119 if (!err)
7120 err = brcmf_fil_iovar_int_set(ifp, "obss_coex",
7121 BRCMF_OBSS_COEX_AUTO);
7122 else
7123 *cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
7124 }
7125
7126 err = brcmf_fweh_activate_events(ifp);
7127 if (err) {
7128 bphy_err(drvr, "FWEH activation failed (%d)\n", err);
7129 goto wiphy_unreg_out;
7130 }
7131
7132 err = brcmf_p2p_attach(cfg, p2pdev_forced);
7133 if (err) {
7134 bphy_err(drvr, "P2P initialisation failed (%d)\n", err);
7135 goto wiphy_unreg_out;
7136 }
7137 err = brcmf_btcoex_attach(cfg);
7138 if (err) {
7139 bphy_err(drvr, "BT-coex initialisation failed (%d)\n", err);
7140 brcmf_p2p_detach(&cfg->p2p);
7141 goto wiphy_unreg_out;
7142 }
7143 err = brcmf_pno_attach(cfg);
7144 if (err) {
7145 bphy_err(drvr, "PNO initialisation failed (%d)\n", err);
7146 brcmf_btcoex_detach(cfg);
7147 brcmf_p2p_detach(&cfg->p2p);
7148 goto wiphy_unreg_out;
7149 }
7150
7151 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_TDLS)) {
7152 err = brcmf_fil_iovar_int_set(ifp, "tdls_enable", 1);
7153 if (err) {
7154 brcmf_dbg(INFO, "TDLS not enabled (%d)\n", err);
7155 wiphy->flags &= ~WIPHY_FLAG_SUPPORTS_TDLS;
7156 } else {
7157 brcmf_fweh_register(cfg->pub, BRCMF_E_TDLS_PEER_EVENT,
7158 brcmf_notify_tdls_peer_event);
7159 }
7160 }
7161
7162
7163 err = brcmf_fweh_activate_events(ifp);
7164 if (err) {
7165 bphy_err(drvr, "FWEH activation failed (%d)\n", err);
7166 goto detach;
7167 }
7168
7169
7170 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_SCAN_RANDOM_MAC)) {
7171 wiphy->features |= NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR;
7172 #ifdef CONFIG_PM
7173 if (wiphy->wowlan &&
7174 wiphy->wowlan->flags & WIPHY_WOWLAN_NET_DETECT)
7175 wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
7176 #endif
7177 }
7178
7179 return cfg;
7180
7181 detach:
7182 brcmf_pno_detach(cfg);
7183 brcmf_btcoex_detach(cfg);
7184 brcmf_p2p_detach(&cfg->p2p);
7185 wiphy_unreg_out:
7186 wiphy_unregister(cfg->wiphy);
7187 priv_out:
7188 wl_deinit_priv(cfg);
7189 brcmf_free_vif(vif);
7190 ifp->vif = NULL;
7191 wiphy_out:
7192 brcmf_free_wiphy(wiphy);
7193 kfree(cfg);
7194 return NULL;
7195 }
7196
7197 void brcmf_cfg80211_detach(struct brcmf_cfg80211_info *cfg)
7198 {
7199 if (!cfg)
7200 return;
7201
7202 brcmf_pno_detach(cfg);
7203 brcmf_btcoex_detach(cfg);
7204 wiphy_unregister(cfg->wiphy);
7205 wl_deinit_priv(cfg);
7206 brcmf_free_wiphy(cfg->wiphy);
7207 kfree(cfg);
7208 }