2 * Copyright (c) 2010 Broadcom Corporation
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 /* Toplevel file. Relies on dhd_linux.c to send commands to the dongle. */
19 #include <linux/kernel.h>
20 #include <linux/if_arp.h>
21 #include <linux/sched.h>
22 #include <linux/kthread.h>
23 #include <linux/netdevice.h>
24 #include <linux/bitops.h>
25 #include <linux/etherdevice.h>
26 #include <linux/ieee80211.h>
27 #include <linux/uaccess.h>
28 #include <net/cfg80211.h>
30 #include <brcmu_utils.h>
32 #include <brcmu_wifi.h>
34 #include "wl_cfg80211.h"
36 #define BRCMF_ASSOC_PARAMS_FIXED_SIZE \
37 (sizeof(struct brcmf_assoc_params_le) - sizeof(u16))
39 static const u8 ether_bcast[ETH_ALEN] = {255, 255, 255, 255, 255, 255};
41 static u32 brcmf_dbg_level = WL_DBG_ERR;
43 static void brcmf_set_drvdata(struct brcmf_cfg80211_dev *dev, void *data)
45 dev->driver_data = data;
48 static void *brcmf_get_drvdata(struct brcmf_cfg80211_dev *dev)
53 data = dev->driver_data;
58 struct brcmf_cfg80211_priv *brcmf_priv_get(struct brcmf_cfg80211_dev *cfg_dev)
60 struct brcmf_cfg80211_iface *ci = brcmf_get_drvdata(cfg_dev);
64 static bool check_sys_up(struct wiphy *wiphy)
66 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
67 if (!test_bit(WL_STATUS_READY, &cfg_priv->status)) {
68 WL_INFO("device is not ready : status (%d)\n",
69 (int)cfg_priv->status);
75 #define CHAN2G(_channel, _freq, _flags) { \
76 .band = IEEE80211_BAND_2GHZ, \
77 .center_freq = (_freq), \
78 .hw_value = (_channel), \
80 .max_antenna_gain = 0, \
84 #define CHAN5G(_channel, _flags) { \
85 .band = IEEE80211_BAND_5GHZ, \
86 .center_freq = 5000 + (5 * (_channel)), \
87 .hw_value = (_channel), \
89 .max_antenna_gain = 0, \
93 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
94 #define RATETAB_ENT(_rateid, _flags) \
96 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
97 .hw_value = (_rateid), \
101 static struct ieee80211_rate __wl_rates[] = {
102 RATETAB_ENT(BRCM_RATE_1M, 0),
103 RATETAB_ENT(BRCM_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
104 RATETAB_ENT(BRCM_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
105 RATETAB_ENT(BRCM_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
106 RATETAB_ENT(BRCM_RATE_6M, 0),
107 RATETAB_ENT(BRCM_RATE_9M, 0),
108 RATETAB_ENT(BRCM_RATE_12M, 0),
109 RATETAB_ENT(BRCM_RATE_18M, 0),
110 RATETAB_ENT(BRCM_RATE_24M, 0),
111 RATETAB_ENT(BRCM_RATE_36M, 0),
112 RATETAB_ENT(BRCM_RATE_48M, 0),
113 RATETAB_ENT(BRCM_RATE_54M, 0),
116 #define wl_a_rates (__wl_rates + 4)
117 #define wl_a_rates_size 8
118 #define wl_g_rates (__wl_rates + 0)
119 #define wl_g_rates_size 12
121 static struct ieee80211_channel __wl_2ghz_channels[] = {
138 static struct ieee80211_channel __wl_5ghz_a_channels[] = {
139 CHAN5G(34, 0), CHAN5G(36, 0),
140 CHAN5G(38, 0), CHAN5G(40, 0),
141 CHAN5G(42, 0), CHAN5G(44, 0),
142 CHAN5G(46, 0), CHAN5G(48, 0),
143 CHAN5G(52, 0), CHAN5G(56, 0),
144 CHAN5G(60, 0), CHAN5G(64, 0),
145 CHAN5G(100, 0), CHAN5G(104, 0),
146 CHAN5G(108, 0), CHAN5G(112, 0),
147 CHAN5G(116, 0), CHAN5G(120, 0),
148 CHAN5G(124, 0), CHAN5G(128, 0),
149 CHAN5G(132, 0), CHAN5G(136, 0),
150 CHAN5G(140, 0), CHAN5G(149, 0),
151 CHAN5G(153, 0), CHAN5G(157, 0),
152 CHAN5G(161, 0), CHAN5G(165, 0),
153 CHAN5G(184, 0), CHAN5G(188, 0),
154 CHAN5G(192, 0), CHAN5G(196, 0),
155 CHAN5G(200, 0), CHAN5G(204, 0),
156 CHAN5G(208, 0), CHAN5G(212, 0),
160 static struct ieee80211_channel __wl_5ghz_n_channels[] = {
161 CHAN5G(32, 0), CHAN5G(34, 0),
162 CHAN5G(36, 0), CHAN5G(38, 0),
163 CHAN5G(40, 0), CHAN5G(42, 0),
164 CHAN5G(44, 0), CHAN5G(46, 0),
165 CHAN5G(48, 0), CHAN5G(50, 0),
166 CHAN5G(52, 0), CHAN5G(54, 0),
167 CHAN5G(56, 0), CHAN5G(58, 0),
168 CHAN5G(60, 0), CHAN5G(62, 0),
169 CHAN5G(64, 0), CHAN5G(66, 0),
170 CHAN5G(68, 0), CHAN5G(70, 0),
171 CHAN5G(72, 0), CHAN5G(74, 0),
172 CHAN5G(76, 0), CHAN5G(78, 0),
173 CHAN5G(80, 0), CHAN5G(82, 0),
174 CHAN5G(84, 0), CHAN5G(86, 0),
175 CHAN5G(88, 0), CHAN5G(90, 0),
176 CHAN5G(92, 0), CHAN5G(94, 0),
177 CHAN5G(96, 0), CHAN5G(98, 0),
178 CHAN5G(100, 0), CHAN5G(102, 0),
179 CHAN5G(104, 0), CHAN5G(106, 0),
180 CHAN5G(108, 0), CHAN5G(110, 0),
181 CHAN5G(112, 0), CHAN5G(114, 0),
182 CHAN5G(116, 0), CHAN5G(118, 0),
183 CHAN5G(120, 0), CHAN5G(122, 0),
184 CHAN5G(124, 0), CHAN5G(126, 0),
185 CHAN5G(128, 0), CHAN5G(130, 0),
186 CHAN5G(132, 0), CHAN5G(134, 0),
187 CHAN5G(136, 0), CHAN5G(138, 0),
188 CHAN5G(140, 0), CHAN5G(142, 0),
189 CHAN5G(144, 0), CHAN5G(145, 0),
190 CHAN5G(146, 0), CHAN5G(147, 0),
191 CHAN5G(148, 0), CHAN5G(149, 0),
192 CHAN5G(150, 0), CHAN5G(151, 0),
193 CHAN5G(152, 0), CHAN5G(153, 0),
194 CHAN5G(154, 0), CHAN5G(155, 0),
195 CHAN5G(156, 0), CHAN5G(157, 0),
196 CHAN5G(158, 0), CHAN5G(159, 0),
197 CHAN5G(160, 0), CHAN5G(161, 0),
198 CHAN5G(162, 0), CHAN5G(163, 0),
199 CHAN5G(164, 0), CHAN5G(165, 0),
200 CHAN5G(166, 0), CHAN5G(168, 0),
201 CHAN5G(170, 0), CHAN5G(172, 0),
202 CHAN5G(174, 0), CHAN5G(176, 0),
203 CHAN5G(178, 0), CHAN5G(180, 0),
204 CHAN5G(182, 0), CHAN5G(184, 0),
205 CHAN5G(186, 0), CHAN5G(188, 0),
206 CHAN5G(190, 0), CHAN5G(192, 0),
207 CHAN5G(194, 0), CHAN5G(196, 0),
208 CHAN5G(198, 0), CHAN5G(200, 0),
209 CHAN5G(202, 0), CHAN5G(204, 0),
210 CHAN5G(206, 0), CHAN5G(208, 0),
211 CHAN5G(210, 0), CHAN5G(212, 0),
212 CHAN5G(214, 0), CHAN5G(216, 0),
213 CHAN5G(218, 0), CHAN5G(220, 0),
214 CHAN5G(222, 0), CHAN5G(224, 0),
215 CHAN5G(226, 0), CHAN5G(228, 0),
218 static struct ieee80211_supported_band __wl_band_2ghz = {
219 .band = IEEE80211_BAND_2GHZ,
220 .channels = __wl_2ghz_channels,
221 .n_channels = ARRAY_SIZE(__wl_2ghz_channels),
222 .bitrates = wl_g_rates,
223 .n_bitrates = wl_g_rates_size,
226 static struct ieee80211_supported_band __wl_band_5ghz_a = {
227 .band = IEEE80211_BAND_5GHZ,
228 .channels = __wl_5ghz_a_channels,
229 .n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
230 .bitrates = wl_a_rates,
231 .n_bitrates = wl_a_rates_size,
234 static struct ieee80211_supported_band __wl_band_5ghz_n = {
235 .band = IEEE80211_BAND_5GHZ,
236 .channels = __wl_5ghz_n_channels,
237 .n_channels = ARRAY_SIZE(__wl_5ghz_n_channels),
238 .bitrates = wl_a_rates,
239 .n_bitrates = wl_a_rates_size,
242 static const u32 __wl_cipher_suites[] = {
243 WLAN_CIPHER_SUITE_WEP40,
244 WLAN_CIPHER_SUITE_WEP104,
245 WLAN_CIPHER_SUITE_TKIP,
246 WLAN_CIPHER_SUITE_CCMP,
247 WLAN_CIPHER_SUITE_AES_CMAC,
250 /* tag_ID/length/value_buffer tuple */
257 /* Quarter dBm units to mW
258 * Table starts at QDBM_OFFSET, so the first entry is mW for qdBm=153
259 * Table is offset so the last entry is largest mW value that fits in
263 #define QDBM_OFFSET 153 /* Offset for first entry */
264 #define QDBM_TABLE_LEN 40 /* Table size */
266 /* Smallest mW value that will round up to the first table entry, QDBM_OFFSET.
267 * Value is ( mW(QDBM_OFFSET - 1) + mW(QDBM_OFFSET) ) / 2
269 #define QDBM_TABLE_LOW_BOUND 6493 /* Low bound */
271 /* Largest mW value that will round down to the last table entry,
272 * QDBM_OFFSET + QDBM_TABLE_LEN-1.
273 * Value is ( mW(QDBM_OFFSET + QDBM_TABLE_LEN - 1) +
274 * mW(QDBM_OFFSET + QDBM_TABLE_LEN) ) / 2.
276 #define QDBM_TABLE_HIGH_BOUND 64938 /* High bound */
278 static const u16 nqdBm_to_mW_map[QDBM_TABLE_LEN] = {
279 /* qdBm: +0 +1 +2 +3 +4 +5 +6 +7 */
280 /* 153: */ 6683, 7079, 7499, 7943, 8414, 8913, 9441, 10000,
281 /* 161: */ 10593, 11220, 11885, 12589, 13335, 14125, 14962, 15849,
282 /* 169: */ 16788, 17783, 18836, 19953, 21135, 22387, 23714, 25119,
283 /* 177: */ 26607, 28184, 29854, 31623, 33497, 35481, 37584, 39811,
284 /* 185: */ 42170, 44668, 47315, 50119, 53088, 56234, 59566, 63096
287 static u16 brcmf_qdbm_to_mw(u8 qdbm)
290 int idx = qdbm - QDBM_OFFSET;
292 if (idx >= QDBM_TABLE_LEN)
293 /* clamp to max u16 mW value */
296 /* scale the qdBm index up to the range of the table 0-40
297 * where an offset of 40 qdBm equals a factor of 10 mW.
304 /* return the mW value scaled down to the correct factor of 10,
305 * adding in factor/2 to get proper rounding.
307 return (nqdBm_to_mW_map[idx] + factor / 2) / factor;
310 static u8 brcmf_mw_to_qdbm(u16 mw)
317 /* handle boundary case */
321 offset = QDBM_OFFSET;
323 /* move mw into the range of the table */
324 while (mw_uint < QDBM_TABLE_LOW_BOUND) {
329 for (qdbm = 0; qdbm < QDBM_TABLE_LEN - 1; qdbm++) {
330 boundary = nqdBm_to_mW_map[qdbm] + (nqdBm_to_mW_map[qdbm + 1] -
331 nqdBm_to_mW_map[qdbm]) / 2;
332 if (mw_uint < boundary)
341 /* function for reading/writing a single u32 from/to the dongle */
343 brcmf_exec_dcmd_u32(struct net_device *ndev, u32 cmd, u32 *par)
346 __le32 par_le = cpu_to_le32(*par);
348 err = brcmf_exec_dcmd(ndev, cmd, &par_le, sizeof(__le32));
349 *par = le32_to_cpu(par_le);
354 static void convert_key_from_CPU(struct brcmf_wsec_key *key,
355 struct brcmf_wsec_key_le *key_le)
357 key_le->index = cpu_to_le32(key->index);
358 key_le->len = cpu_to_le32(key->len);
359 key_le->algo = cpu_to_le32(key->algo);
360 key_le->flags = cpu_to_le32(key->flags);
361 key_le->rxiv.hi = cpu_to_le32(key->rxiv.hi);
362 key_le->rxiv.lo = cpu_to_le16(key->rxiv.lo);
363 key_le->iv_initialized = cpu_to_le32(key->iv_initialized);
364 memcpy(key_le->data, key->data, sizeof(key->data));
365 memcpy(key_le->ea, key->ea, sizeof(key->ea));
368 static int send_key_to_dongle(struct net_device *ndev,
369 struct brcmf_wsec_key *key)
372 struct brcmf_wsec_key_le key_le;
374 convert_key_from_CPU(key, &key_le);
375 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_KEY, &key_le, sizeof(key_le));
377 WL_ERR("WLC_SET_KEY error (%d)\n", err);
382 brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
383 enum nl80211_iftype type, u32 *flags,
384 struct vif_params *params)
386 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
387 struct wireless_dev *wdev;
392 if (!check_sys_up(wiphy))
396 case NL80211_IFTYPE_MONITOR:
397 case NL80211_IFTYPE_WDS:
398 WL_ERR("type (%d) : currently we do not support this type\n",
401 case NL80211_IFTYPE_ADHOC:
402 cfg_priv->conf->mode = WL_MODE_IBSS;
405 case NL80211_IFTYPE_STATION:
406 cfg_priv->conf->mode = WL_MODE_BSS;
414 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_INFRA, &infra);
416 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
419 wdev = ndev->ieee80211_ptr;
423 WL_INFO("IF Type = %s\n",
424 (cfg_priv->conf->mode == WL_MODE_IBSS) ? "Adhoc" : "Infra");
432 static s32 brcmf_dev_intvar_set(struct net_device *ndev, s8 *name, s32 val)
434 s8 buf[BRCMF_DCMD_SMLEN];
439 val_le = cpu_to_le32(val);
440 len = brcmf_c_mkiovar(name, (char *)(&val_le), sizeof(val_le), buf,
444 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, buf, len);
446 WL_ERR("error (%d)\n", err);
452 brcmf_dev_intvar_get(struct net_device *ndev, s8 *name, s32 *retval)
455 s8 buf[BRCMF_DCMD_SMLEN];
463 brcmf_c_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
466 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, &var, len);
468 WL_ERR("error (%d)\n", err);
470 *retval = le32_to_cpu(var.val);
475 static void brcmf_set_mpc(struct net_device *ndev, int mpc)
478 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
480 if (test_bit(WL_STATUS_READY, &cfg_priv->status)) {
481 err = brcmf_dev_intvar_set(ndev, "mpc", mpc);
483 WL_ERR("fail to set mpc\n");
486 WL_INFO("MPC : %d\n", mpc);
490 static void wl_iscan_prep(struct brcmf_scan_params_le *params_le,
491 struct brcmf_ssid *ssid)
493 memcpy(params_le->bssid, ether_bcast, ETH_ALEN);
494 params_le->bss_type = DOT11_BSSTYPE_ANY;
495 params_le->scan_type = 0;
496 params_le->channel_num = 0;
497 params_le->nprobes = cpu_to_le32(-1);
498 params_le->active_time = cpu_to_le32(-1);
499 params_le->passive_time = cpu_to_le32(-1);
500 params_le->home_time = cpu_to_le32(-1);
501 if (ssid && ssid->SSID_len) {
502 params_le->ssid_le.SSID_len = cpu_to_le32(ssid->SSID_len);
503 memcpy(¶ms_le->ssid_le.SSID, ssid->SSID, ssid->SSID_len);
508 brcmf_dev_iovar_setbuf(struct net_device *ndev, s8 * iovar, void *param,
509 s32 paramlen, void *bufptr, s32 buflen)
513 iolen = brcmf_c_mkiovar(iovar, param, paramlen, bufptr, buflen);
516 return brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, bufptr, iolen);
520 brcmf_dev_iovar_getbuf(struct net_device *ndev, s8 * iovar, void *param,
521 s32 paramlen, void *bufptr, s32 buflen)
525 iolen = brcmf_c_mkiovar(iovar, param, paramlen, bufptr, buflen);
528 return brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, bufptr, buflen);
532 brcmf_run_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan,
533 struct brcmf_ssid *ssid, u16 action)
535 s32 params_size = BRCMF_SCAN_PARAMS_FIXED_SIZE +
536 offsetof(struct brcmf_iscan_params_le, params_le);
537 struct brcmf_iscan_params_le *params;
540 if (ssid && ssid->SSID_len)
541 params_size += sizeof(struct brcmf_ssid);
542 params = kzalloc(params_size, GFP_KERNEL);
545 BUG_ON(params_size >= BRCMF_DCMD_SMLEN);
547 wl_iscan_prep(¶ms->params_le, ssid);
549 params->version = cpu_to_le32(BRCMF_ISCAN_REQ_VERSION);
550 params->action = cpu_to_le16(action);
551 params->scan_duration = cpu_to_le16(0);
553 err = brcmf_dev_iovar_setbuf(iscan->ndev, "iscan", params, params_size,
554 iscan->dcmd_buf, BRCMF_DCMD_SMLEN);
557 WL_INFO("system busy : iscan canceled\n");
559 WL_ERR("error (%d)\n", err);
566 static s32 brcmf_do_iscan(struct brcmf_cfg80211_priv *cfg_priv)
568 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
569 struct net_device *ndev = cfg_to_ndev(cfg_priv);
570 struct brcmf_ssid ssid;
574 /* Broadcast scan by default */
575 memset(&ssid, 0, sizeof(ssid));
577 iscan->state = WL_ISCAN_STATE_SCANING;
579 passive_scan = cfg_priv->active_scan ? 0 : cpu_to_le32(1);
580 err = brcmf_exec_dcmd(cfg_to_ndev(cfg_priv), BRCMF_C_SET_PASSIVE_SCAN,
581 &passive_scan, sizeof(passive_scan));
583 WL_ERR("error (%d)\n", err);
586 brcmf_set_mpc(ndev, 0);
587 cfg_priv->iscan_kickstart = true;
588 err = brcmf_run_iscan(iscan, &ssid, BRCMF_SCAN_ACTION_START);
590 brcmf_set_mpc(ndev, 1);
591 cfg_priv->iscan_kickstart = false;
594 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
600 __brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
601 struct cfg80211_scan_request *request,
602 struct cfg80211_ssid *this_ssid)
604 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
605 struct cfg80211_ssid *ssids;
606 struct brcmf_cfg80211_scan_req *sr = cfg_priv->scan_req_int;
613 if (test_bit(WL_STATUS_SCANNING, &cfg_priv->status)) {
614 WL_ERR("Scanning already : status (%lu)\n", cfg_priv->status);
617 if (test_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status)) {
618 WL_ERR("Scanning being aborted : status (%lu)\n",
622 if (test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) {
623 WL_ERR("Connecting : status (%lu)\n",
632 ssids = request->ssids;
633 if (cfg_priv->iscan_on && (!ssids || !ssids->ssid_len))
637 /* we don't do iscan in ibss */
641 cfg_priv->scan_request = request;
642 set_bit(WL_STATUS_SCANNING, &cfg_priv->status);
644 err = brcmf_do_iscan(cfg_priv);
650 WL_SCAN("ssid \"%s\", ssid_len (%d)\n",
651 ssids->ssid, ssids->ssid_len);
652 memset(&sr->ssid_le, 0, sizeof(sr->ssid_le));
653 SSID_len = min_t(u8, sizeof(sr->ssid_le.SSID), ssids->ssid_len);
654 sr->ssid_le.SSID_len = cpu_to_le32(0);
656 memcpy(sr->ssid_le.SSID, ssids->ssid, SSID_len);
657 sr->ssid_le.SSID_len = cpu_to_le32(SSID_len);
660 WL_SCAN("Broadcast scan\n");
663 passive_scan = cfg_priv->active_scan ? 0 : cpu_to_le32(1);
664 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_PASSIVE_SCAN,
665 &passive_scan, sizeof(passive_scan));
667 WL_ERR("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
670 brcmf_set_mpc(ndev, 0);
671 err = brcmf_exec_dcmd(ndev, BRCMF_C_SCAN, &sr->ssid_le,
672 sizeof(sr->ssid_le));
675 WL_INFO("system busy : scan for \"%s\" "
676 "canceled\n", sr->ssid_le.SSID);
678 WL_ERR("WLC_SCAN error (%d)\n", err);
680 brcmf_set_mpc(ndev, 1);
688 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
689 cfg_priv->scan_request = NULL;
694 brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
695 struct cfg80211_scan_request *request)
701 if (!check_sys_up(wiphy))
704 err = __brcmf_cfg80211_scan(wiphy, ndev, request, NULL);
706 WL_ERR("scan error (%d)\n", err);
712 static s32 brcmf_set_rts(struct net_device *ndev, u32 rts_threshold)
716 err = brcmf_dev_intvar_set(ndev, "rtsthresh", rts_threshold);
718 WL_ERR("Error (%d)\n", err);
723 static s32 brcmf_set_frag(struct net_device *ndev, u32 frag_threshold)
727 err = brcmf_dev_intvar_set(ndev, "fragthresh", frag_threshold);
729 WL_ERR("Error (%d)\n", err);
734 static s32 brcmf_set_retry(struct net_device *ndev, u32 retry, bool l)
737 u32 cmd = (l ? BRCM_SET_LRL : BRCM_SET_SRL);
739 err = brcmf_exec_dcmd_u32(ndev, cmd, &retry);
741 WL_ERR("cmd (%d) , error (%d)\n", cmd, err);
747 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
749 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
750 struct net_device *ndev = cfg_to_ndev(cfg_priv);
754 if (!check_sys_up(wiphy))
757 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
758 (cfg_priv->conf->rts_threshold != wiphy->rts_threshold)) {
759 cfg_priv->conf->rts_threshold = wiphy->rts_threshold;
760 err = brcmf_set_rts(ndev, cfg_priv->conf->rts_threshold);
764 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
765 (cfg_priv->conf->frag_threshold != wiphy->frag_threshold)) {
766 cfg_priv->conf->frag_threshold = wiphy->frag_threshold;
767 err = brcmf_set_frag(ndev, cfg_priv->conf->frag_threshold);
771 if (changed & WIPHY_PARAM_RETRY_LONG
772 && (cfg_priv->conf->retry_long != wiphy->retry_long)) {
773 cfg_priv->conf->retry_long = wiphy->retry_long;
774 err = brcmf_set_retry(ndev, cfg_priv->conf->retry_long, true);
778 if (changed & WIPHY_PARAM_RETRY_SHORT
779 && (cfg_priv->conf->retry_short != wiphy->retry_short)) {
780 cfg_priv->conf->retry_short = wiphy->retry_short;
781 err = brcmf_set_retry(ndev, cfg_priv->conf->retry_short, false);
791 static void *brcmf_read_prof(struct brcmf_cfg80211_priv *cfg_priv, s32 item)
795 return &cfg_priv->profile->sec;
797 return &cfg_priv->profile->bssid;
799 return &cfg_priv->profile->ssid;
801 WL_ERR("invalid item (%d)\n", item);
806 brcmf_update_prof(struct brcmf_cfg80211_priv *cfg_priv,
807 const struct brcmf_event_msg *e, void *data, s32 item)
810 struct brcmf_ssid *ssid;
814 ssid = (struct brcmf_ssid *) data;
815 memset(cfg_priv->profile->ssid.SSID, 0,
816 sizeof(cfg_priv->profile->ssid.SSID));
817 memcpy(cfg_priv->profile->ssid.SSID,
818 ssid->SSID, ssid->SSID_len);
819 cfg_priv->profile->ssid.SSID_len = ssid->SSID_len;
823 memcpy(cfg_priv->profile->bssid, data, ETH_ALEN);
825 memset(cfg_priv->profile->bssid, 0, ETH_ALEN);
828 memcpy(&cfg_priv->profile->sec, data,
829 sizeof(cfg_priv->profile->sec));
831 case WL_PROF_BEACONINT:
832 cfg_priv->profile->beacon_interval = *(u16 *)data;
834 case WL_PROF_DTIMPERIOD:
835 cfg_priv->profile->dtim_period = *(u8 *)data;
838 WL_ERR("unsupported item (%d)\n", item);
846 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
848 memset(prof, 0, sizeof(*prof));
851 static void brcmf_ch_to_chanspec(int ch, struct brcmf_join_params *join_params,
852 size_t *join_params_size)
857 if (ch <= CH_MAX_2G_CHANNEL)
858 chanspec |= WL_CHANSPEC_BAND_2G;
860 chanspec |= WL_CHANSPEC_BAND_5G;
862 chanspec |= WL_CHANSPEC_BW_20;
863 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
865 *join_params_size += BRCMF_ASSOC_PARAMS_FIXED_SIZE +
868 chanspec |= (ch & WL_CHANSPEC_CHAN_MASK);
869 join_params->params_le.chanspec_list[0] = cpu_to_le16(chanspec);
870 join_params->params_le.chanspec_num = cpu_to_le32(1);
872 WL_CONN("join_params->params.chanspec_list[0]= %#X,"
873 "channel %d, chanspec %#X\n",
874 chanspec, ch, chanspec);
878 static void brcmf_link_down(struct brcmf_cfg80211_priv *cfg_priv)
880 struct net_device *ndev = NULL;
885 if (cfg_priv->link_up) {
886 ndev = cfg_to_ndev(cfg_priv);
887 WL_INFO("Call WLC_DISASSOC to stop excess roaming\n ");
888 err = brcmf_exec_dcmd(ndev, BRCMF_C_DISASSOC, NULL, 0);
890 WL_ERR("WLC_DISASSOC failed (%d)\n", err);
891 cfg_priv->link_up = false;
897 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
898 struct cfg80211_ibss_params *params)
900 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
901 struct brcmf_join_params join_params;
902 size_t join_params_size = 0;
906 struct brcmf_ssid ssid;
909 if (!check_sys_up(wiphy))
913 WL_CONN("SSID: %s\n", params->ssid);
915 WL_CONN("SSID: NULL, Not supported\n");
919 set_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
922 WL_CONN("BSSID: %02X %02X %02X %02X %02X %02X\n",
923 params->bssid[0], params->bssid[1], params->bssid[2],
924 params->bssid[3], params->bssid[4], params->bssid[5]);
926 WL_CONN("No BSSID specified\n");
929 WL_CONN("channel: %d\n", params->channel->center_freq);
931 WL_CONN("no channel specified\n");
933 if (params->channel_fixed)
934 WL_CONN("fixed channel required\n");
936 WL_CONN("no fixed channel required\n");
938 if (params->ie && params->ie_len)
939 WL_CONN("ie len: %d\n", params->ie_len);
941 WL_CONN("no ie specified\n");
943 if (params->beacon_interval)
944 WL_CONN("beacon interval: %d\n", params->beacon_interval);
946 WL_CONN("no beacon interval specified\n");
948 if (params->basic_rates)
949 WL_CONN("basic rates: %08X\n", params->basic_rates);
951 WL_CONN("no basic rates specified\n");
954 WL_CONN("privacy required\n");
956 WL_CONN("no privacy required\n");
958 /* Configure Privacy for starter */
962 err = brcmf_dev_intvar_set(ndev, "wsec", wsec);
964 WL_ERR("wsec failed (%d)\n", err);
968 /* Configure Beacon Interval for starter */
969 if (params->beacon_interval)
970 bcnprd = params->beacon_interval;
974 err = brcmf_exec_dcmd_u32(ndev, BRCM_SET_BCNPRD, &bcnprd);
976 WL_ERR("WLC_SET_BCNPRD failed (%d)\n", err);
980 /* Configure required join parameter */
981 memset(&join_params, 0, sizeof(struct brcmf_join_params));
984 ssid.SSID_len = min_t(u32, params->ssid_len, 32);
985 memcpy(ssid.SSID, params->ssid, ssid.SSID_len);
986 memcpy(join_params.ssid_le.SSID, params->ssid, ssid.SSID_len);
987 join_params.ssid_le.SSID_len = cpu_to_le32(ssid.SSID_len);
988 join_params_size = sizeof(join_params.ssid_le);
989 brcmf_update_prof(cfg_priv, NULL, &ssid, WL_PROF_SSID);
993 memcpy(join_params.params_le.bssid, params->bssid, ETH_ALEN);
994 join_params_size = sizeof(join_params.ssid_le) +
995 BRCMF_ASSOC_PARAMS_FIXED_SIZE;
997 memcpy(join_params.params_le.bssid, ether_bcast, ETH_ALEN);
1000 brcmf_update_prof(cfg_priv, NULL,
1001 &join_params.params_le.bssid, WL_PROF_BSSID);
1004 if (params->channel) {
1008 ieee80211_frequency_to_channel(
1009 params->channel->center_freq);
1010 if (params->channel_fixed) {
1011 /* adding chanspec */
1012 brcmf_ch_to_chanspec(cfg_priv->channel,
1013 &join_params, &join_params_size);
1016 /* set channel for starter */
1017 target_channel = cfg_priv->channel;
1018 err = brcmf_exec_dcmd_u32(ndev, BRCM_SET_CHANNEL,
1021 WL_ERR("WLC_SET_CHANNEL failed (%d)\n", err);
1025 cfg_priv->channel = 0;
1027 cfg_priv->ibss_starter = false;
1030 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SSID,
1031 &join_params, join_params_size);
1033 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1039 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1045 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
1047 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1050 WL_TRACE("Enter\n");
1051 if (!check_sys_up(wiphy))
1054 brcmf_link_down(cfg_priv);
1061 static s32 brcmf_set_wpa_version(struct net_device *ndev,
1062 struct cfg80211_connect_params *sme)
1064 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1065 struct brcmf_cfg80211_security *sec;
1069 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1070 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1071 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1072 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1074 val = WPA_AUTH_DISABLED;
1075 WL_CONN("setting wpa_auth to 0x%0x\n", val);
1076 err = brcmf_dev_intvar_set(ndev, "wpa_auth", val);
1078 WL_ERR("set wpa_auth failed (%d)\n", err);
1081 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1082 sec->wpa_versions = sme->crypto.wpa_versions;
1086 static s32 brcmf_set_auth_type(struct net_device *ndev,
1087 struct cfg80211_connect_params *sme)
1089 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1090 struct brcmf_cfg80211_security *sec;
1094 switch (sme->auth_type) {
1095 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1097 WL_CONN("open system\n");
1099 case NL80211_AUTHTYPE_SHARED_KEY:
1101 WL_CONN("shared key\n");
1103 case NL80211_AUTHTYPE_AUTOMATIC:
1105 WL_CONN("automatic\n");
1107 case NL80211_AUTHTYPE_NETWORK_EAP:
1108 WL_CONN("network eap\n");
1111 WL_ERR("invalid auth type (%d)\n", sme->auth_type);
1115 err = brcmf_dev_intvar_set(ndev, "auth", val);
1117 WL_ERR("set auth failed (%d)\n", err);
1120 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1121 sec->auth_type = sme->auth_type;
1126 brcmf_set_set_cipher(struct net_device *ndev,
1127 struct cfg80211_connect_params *sme)
1129 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1130 struct brcmf_cfg80211_security *sec;
1135 if (sme->crypto.n_ciphers_pairwise) {
1136 switch (sme->crypto.ciphers_pairwise[0]) {
1137 case WLAN_CIPHER_SUITE_WEP40:
1138 case WLAN_CIPHER_SUITE_WEP104:
1141 case WLAN_CIPHER_SUITE_TKIP:
1142 pval = TKIP_ENABLED;
1144 case WLAN_CIPHER_SUITE_CCMP:
1147 case WLAN_CIPHER_SUITE_AES_CMAC:
1151 WL_ERR("invalid cipher pairwise (%d)\n",
1152 sme->crypto.ciphers_pairwise[0]);
1156 if (sme->crypto.cipher_group) {
1157 switch (sme->crypto.cipher_group) {
1158 case WLAN_CIPHER_SUITE_WEP40:
1159 case WLAN_CIPHER_SUITE_WEP104:
1162 case WLAN_CIPHER_SUITE_TKIP:
1163 gval = TKIP_ENABLED;
1165 case WLAN_CIPHER_SUITE_CCMP:
1168 case WLAN_CIPHER_SUITE_AES_CMAC:
1172 WL_ERR("invalid cipher group (%d)\n",
1173 sme->crypto.cipher_group);
1178 WL_CONN("pval (%d) gval (%d)\n", pval, gval);
1179 err = brcmf_dev_intvar_set(ndev, "wsec", pval | gval);
1181 WL_ERR("error (%d)\n", err);
1185 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1186 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1187 sec->cipher_group = sme->crypto.cipher_group;
1193 brcmf_set_key_mgmt(struct net_device *ndev, struct cfg80211_connect_params *sme)
1195 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1196 struct brcmf_cfg80211_security *sec;
1200 if (sme->crypto.n_akm_suites) {
1201 err = brcmf_dev_intvar_get(ndev, "wpa_auth", &val);
1203 WL_ERR("could not get wpa_auth (%d)\n", err);
1206 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1207 switch (sme->crypto.akm_suites[0]) {
1208 case WLAN_AKM_SUITE_8021X:
1209 val = WPA_AUTH_UNSPECIFIED;
1211 case WLAN_AKM_SUITE_PSK:
1215 WL_ERR("invalid cipher group (%d)\n",
1216 sme->crypto.cipher_group);
1219 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1220 switch (sme->crypto.akm_suites[0]) {
1221 case WLAN_AKM_SUITE_8021X:
1222 val = WPA2_AUTH_UNSPECIFIED;
1224 case WLAN_AKM_SUITE_PSK:
1225 val = WPA2_AUTH_PSK;
1228 WL_ERR("invalid cipher group (%d)\n",
1229 sme->crypto.cipher_group);
1234 WL_CONN("setting wpa_auth to %d\n", val);
1235 err = brcmf_dev_intvar_set(ndev, "wpa_auth", val);
1237 WL_ERR("could not set wpa_auth (%d)\n", err);
1241 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1242 sec->wpa_auth = sme->crypto.akm_suites[0];
1248 brcmf_set_wep_sharedkey(struct net_device *ndev,
1249 struct cfg80211_connect_params *sme)
1251 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1252 struct brcmf_cfg80211_security *sec;
1253 struct brcmf_wsec_key key;
1257 WL_CONN("key len (%d)\n", sme->key_len);
1259 if (sme->key_len == 0)
1262 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1263 WL_CONN("wpa_versions 0x%x cipher_pairwise 0x%x\n",
1264 sec->wpa_versions, sec->cipher_pairwise);
1266 if (sec->wpa_versions & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2))
1269 if (sec->cipher_pairwise &
1270 (WLAN_CIPHER_SUITE_WEP40 | WLAN_CIPHER_SUITE_WEP104)) {
1271 memset(&key, 0, sizeof(key));
1272 key.len = (u32) sme->key_len;
1273 key.index = (u32) sme->key_idx;
1274 if (key.len > sizeof(key.data)) {
1275 WL_ERR("Too long key length (%u)\n", key.len);
1278 memcpy(key.data, sme->key, key.len);
1279 key.flags = BRCMF_PRIMARY_KEY;
1280 switch (sec->cipher_pairwise) {
1281 case WLAN_CIPHER_SUITE_WEP40:
1282 key.algo = CRYPTO_ALGO_WEP1;
1284 case WLAN_CIPHER_SUITE_WEP104:
1285 key.algo = CRYPTO_ALGO_WEP128;
1288 WL_ERR("Invalid algorithm (%d)\n",
1289 sme->crypto.ciphers_pairwise[0]);
1292 /* Set the new key/index */
1293 WL_CONN("key length (%d) key index (%d) algo (%d)\n",
1294 key.len, key.index, key.algo);
1295 WL_CONN("key \"%s\"\n", key.data);
1296 err = send_key_to_dongle(ndev, &key);
1300 if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
1301 WL_CONN("set auth_type to shared key\n");
1302 val = 1; /* shared key */
1303 err = brcmf_dev_intvar_set(ndev, "auth", val);
1305 WL_ERR("set auth failed (%d)\n", err);
1314 brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *ndev,
1315 struct cfg80211_connect_params *sme)
1317 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1318 struct ieee80211_channel *chan = sme->channel;
1319 struct brcmf_join_params join_params;
1320 size_t join_params_size;
1321 struct brcmf_ssid ssid;
1325 WL_TRACE("Enter\n");
1326 if (!check_sys_up(wiphy))
1330 WL_ERR("Invalid ssid\n");
1334 set_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1338 ieee80211_frequency_to_channel(chan->center_freq);
1339 WL_CONN("channel (%d), center_req (%d)\n",
1340 cfg_priv->channel, chan->center_freq);
1342 cfg_priv->channel = 0;
1344 WL_INFO("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1346 err = brcmf_set_wpa_version(ndev, sme);
1348 WL_ERR("wl_set_wpa_version failed (%d)\n", err);
1352 err = brcmf_set_auth_type(ndev, sme);
1354 WL_ERR("wl_set_auth_type failed (%d)\n", err);
1358 err = brcmf_set_set_cipher(ndev, sme);
1360 WL_ERR("wl_set_set_cipher failed (%d)\n", err);
1364 err = brcmf_set_key_mgmt(ndev, sme);
1366 WL_ERR("wl_set_key_mgmt failed (%d)\n", err);
1370 err = brcmf_set_wep_sharedkey(ndev, sme);
1372 WL_ERR("brcmf_set_wep_sharedkey failed (%d)\n", err);
1376 memset(&join_params, 0, sizeof(join_params));
1377 join_params_size = sizeof(join_params.ssid_le);
1379 ssid.SSID_len = min_t(u32, sizeof(ssid.SSID), sme->ssid_len);
1380 memcpy(&join_params.ssid_le.SSID, sme->ssid, ssid.SSID_len);
1381 memcpy(&ssid.SSID, sme->ssid, ssid.SSID_len);
1382 join_params.ssid_le.SSID_len = cpu_to_le32(ssid.SSID_len);
1383 brcmf_update_prof(cfg_priv, NULL, &ssid, WL_PROF_SSID);
1385 memcpy(join_params.params_le.bssid, ether_bcast, ETH_ALEN);
1387 if (ssid.SSID_len < IEEE80211_MAX_SSID_LEN)
1388 WL_CONN("ssid \"%s\", len (%d)\n",
1389 ssid.SSID, ssid.SSID_len);
1391 brcmf_ch_to_chanspec(cfg_priv->channel,
1392 &join_params, &join_params_size);
1393 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SSID,
1394 &join_params, join_params_size);
1396 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1400 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1406 brcmf_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *ndev,
1409 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1410 struct brcmf_scb_val_le scbval;
1413 WL_TRACE("Enter. Reason code = %d\n", reason_code);
1414 if (!check_sys_up(wiphy))
1417 clear_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
1419 memcpy(&scbval.ea, brcmf_read_prof(cfg_priv, WL_PROF_BSSID), ETH_ALEN);
1420 scbval.val = cpu_to_le32(reason_code);
1421 err = brcmf_exec_dcmd(ndev, BRCMF_C_DISASSOC, &scbval,
1422 sizeof(struct brcmf_scb_val_le));
1424 WL_ERR("error (%d)\n", err);
1426 cfg_priv->link_up = false;
1433 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy,
1434 enum nl80211_tx_power_setting type, s32 dbm)
1437 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1438 struct net_device *ndev = cfg_to_ndev(cfg_priv);
1443 WL_TRACE("Enter\n");
1444 if (!check_sys_up(wiphy))
1448 case NL80211_TX_POWER_AUTOMATIC:
1450 case NL80211_TX_POWER_LIMITED:
1452 WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
1457 case NL80211_TX_POWER_FIXED:
1459 WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1465 /* Make sure radio is off or on as far as software is concerned */
1466 disable = WL_RADIO_SW_DISABLE << 16;
1467 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_RADIO, &disable);
1469 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1474 txpwrmw = (u16) dbm;
1475 err = brcmf_dev_intvar_set(ndev, "qtxpower",
1476 (s32) (brcmf_mw_to_qdbm(txpwrmw)));
1478 WL_ERR("qtxpower error (%d)\n", err);
1479 cfg_priv->conf->tx_power = dbm;
1486 static s32 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1488 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1489 struct net_device *ndev = cfg_to_ndev(cfg_priv);
1494 WL_TRACE("Enter\n");
1495 if (!check_sys_up(wiphy))
1498 err = brcmf_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1500 WL_ERR("error (%d)\n", err);
1504 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1505 *dbm = (s32) brcmf_qdbm_to_mw(result);
1513 brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *ndev,
1514 u8 key_idx, bool unicast, bool multicast)
1520 WL_TRACE("Enter\n");
1521 WL_CONN("key index (%d)\n", key_idx);
1522 if (!check_sys_up(wiphy))
1525 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_GET_WSEC, &wsec);
1527 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1531 if (wsec & WEP_ENABLED) {
1532 /* Just select a new current key */
1534 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_KEY_PRIMARY,
1537 WL_ERR("error (%d)\n", err);
1545 brcmf_add_keyext(struct wiphy *wiphy, struct net_device *ndev,
1546 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1548 struct brcmf_wsec_key key;
1549 struct brcmf_wsec_key_le key_le;
1552 memset(&key, 0, sizeof(key));
1553 key.index = (u32) key_idx;
1554 /* Instead of bcast for ea address for default wep keys,
1555 driver needs it to be Null */
1556 if (!is_multicast_ether_addr(mac_addr))
1557 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1558 key.len = (u32) params->key_len;
1559 /* check for key index change */
1562 err = send_key_to_dongle(ndev, &key);
1566 if (key.len > sizeof(key.data)) {
1567 WL_ERR("Invalid key length (%d)\n", key.len);
1571 WL_CONN("Setting the key index %d\n", key.index);
1572 memcpy(key.data, params->key, key.len);
1574 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1576 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1577 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1578 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1581 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1582 if (params->seq && params->seq_len == 6) {
1585 ivptr = (u8 *) params->seq;
1586 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1587 (ivptr[3] << 8) | ivptr[2];
1588 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1589 key.iv_initialized = true;
1592 switch (params->cipher) {
1593 case WLAN_CIPHER_SUITE_WEP40:
1594 key.algo = CRYPTO_ALGO_WEP1;
1595 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1597 case WLAN_CIPHER_SUITE_WEP104:
1598 key.algo = CRYPTO_ALGO_WEP128;
1599 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1601 case WLAN_CIPHER_SUITE_TKIP:
1602 key.algo = CRYPTO_ALGO_TKIP;
1603 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1605 case WLAN_CIPHER_SUITE_AES_CMAC:
1606 key.algo = CRYPTO_ALGO_AES_CCM;
1607 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1609 case WLAN_CIPHER_SUITE_CCMP:
1610 key.algo = CRYPTO_ALGO_AES_CCM;
1611 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1614 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1617 convert_key_from_CPU(&key, &key_le);
1619 brcmf_netdev_wait_pend8021x(ndev);
1620 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_KEY, &key_le,
1623 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1631 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
1632 u8 key_idx, bool pairwise, const u8 *mac_addr,
1633 struct key_params *params)
1635 struct brcmf_wsec_key key;
1641 WL_TRACE("Enter\n");
1642 WL_CONN("key index (%d)\n", key_idx);
1643 if (!check_sys_up(wiphy))
1648 return brcmf_add_keyext(wiphy, ndev, key_idx, mac_addr, params);
1650 memset(&key, 0, sizeof(key));
1652 key.len = (u32) params->key_len;
1653 key.index = (u32) key_idx;
1655 if (key.len > sizeof(key.data)) {
1656 WL_ERR("Too long key length (%u)\n", key.len);
1660 memcpy(key.data, params->key, key.len);
1662 key.flags = BRCMF_PRIMARY_KEY;
1663 switch (params->cipher) {
1664 case WLAN_CIPHER_SUITE_WEP40:
1665 key.algo = CRYPTO_ALGO_WEP1;
1666 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1668 case WLAN_CIPHER_SUITE_WEP104:
1669 key.algo = CRYPTO_ALGO_WEP128;
1670 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1672 case WLAN_CIPHER_SUITE_TKIP:
1673 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1674 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1675 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1676 key.algo = CRYPTO_ALGO_TKIP;
1677 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1679 case WLAN_CIPHER_SUITE_AES_CMAC:
1680 key.algo = CRYPTO_ALGO_AES_CCM;
1681 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1683 case WLAN_CIPHER_SUITE_CCMP:
1684 key.algo = CRYPTO_ALGO_AES_CCM;
1685 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1688 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1693 err = send_key_to_dongle(ndev, &key); /* Set the new key/index */
1698 err = brcmf_dev_intvar_get(ndev, "wsec", &wsec);
1700 WL_ERR("get wsec error (%d)\n", err);
1703 wsec &= ~(WEP_ENABLED);
1705 err = brcmf_dev_intvar_set(ndev, "wsec", wsec);
1707 WL_ERR("set wsec error (%d)\n", err);
1711 val = 1; /* assume shared key. otherwise 0 */
1712 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_AUTH, &val);
1714 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1721 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
1722 u8 key_idx, bool pairwise, const u8 *mac_addr)
1724 struct brcmf_wsec_key key;
1729 WL_TRACE("Enter\n");
1730 if (!check_sys_up(wiphy))
1733 memset(&key, 0, sizeof(key));
1735 key.index = (u32) key_idx;
1736 key.flags = BRCMF_PRIMARY_KEY;
1737 key.algo = CRYPTO_ALGO_OFF;
1739 WL_CONN("key index (%d)\n", key_idx);
1741 /* Set the new key/index */
1742 err = send_key_to_dongle(ndev, &key);
1744 if (err == -EINVAL) {
1745 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
1746 /* we ignore this key index in this case */
1747 WL_ERR("invalid key index (%d)\n", key_idx);
1749 /* Ignore this error, may happen during DISASSOC */
1755 err = brcmf_dev_intvar_get(ndev, "wsec", &wsec);
1757 WL_ERR("get wsec error (%d)\n", err);
1758 /* Ignore this error, may happen during DISASSOC */
1762 wsec &= ~(WEP_ENABLED);
1764 err = brcmf_dev_intvar_set(ndev, "wsec", wsec);
1766 WL_ERR("set wsec error (%d)\n", err);
1767 /* Ignore this error, may happen during DISASSOC */
1772 val = 0; /* assume open key. otherwise 1 */
1773 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_AUTH, &val);
1775 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1776 /* Ignore this error, may happen during DISASSOC */
1785 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
1786 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1787 void (*callback) (void *cookie, struct key_params * params))
1789 struct key_params params;
1790 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1791 struct brcmf_cfg80211_security *sec;
1795 WL_TRACE("Enter\n");
1796 WL_CONN("key index (%d)\n", key_idx);
1797 if (!check_sys_up(wiphy))
1800 memset(¶ms, 0, sizeof(params));
1802 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_GET_WSEC, &wsec);
1804 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1805 /* Ignore this error, may happen during DISASSOC */
1811 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1812 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1813 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1814 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1815 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1816 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1817 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1821 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1822 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1825 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1826 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1829 WL_ERR("Invalid algo (0x%x)\n", wsec);
1833 callback(cookie, ¶ms);
1841 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1842 struct net_device *ndev, u8 key_idx)
1844 WL_INFO("Not supported\n");
1850 brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *ndev,
1851 u8 *mac, struct station_info *sinfo)
1853 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1854 struct brcmf_scb_val_le scb_val;
1858 u8 *bssid = brcmf_read_prof(cfg_priv, WL_PROF_BSSID);
1860 WL_TRACE("Enter\n");
1861 if (!check_sys_up(wiphy))
1864 if (memcmp(mac, bssid, ETH_ALEN)) {
1865 WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
1866 "wl_bssid-%X:%X:%X:%X:%X:%X\n",
1867 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
1868 bssid[0], bssid[1], bssid[2], bssid[3],
1869 bssid[4], bssid[5]);
1874 /* Report the current tx rate */
1875 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_GET_RATE, &rate);
1877 WL_ERR("Could not get rate (%d)\n", err);
1879 sinfo->filled |= STATION_INFO_TX_BITRATE;
1880 sinfo->txrate.legacy = rate * 5;
1881 WL_CONN("Rate %d Mbps\n", rate / 2);
1884 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status)) {
1885 scb_val.val = cpu_to_le32(0);
1886 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_RSSI, &scb_val,
1887 sizeof(struct brcmf_scb_val_le));
1889 WL_ERR("Could not get rssi (%d)\n", err);
1891 rssi = le32_to_cpu(scb_val.val);
1892 sinfo->filled |= STATION_INFO_SIGNAL;
1893 sinfo->signal = rssi;
1894 WL_CONN("RSSI %d dBm\n", rssi);
1903 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *ndev,
1904 bool enabled, s32 timeout)
1908 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1910 WL_TRACE("Enter\n");
1913 * Powersave enable/disable request is coming from the
1914 * cfg80211 even before the interface is up. In that
1915 * scenario, driver will be storing the power save
1916 * preference in cfg_priv struct to apply this to
1917 * FW later while initializing the dongle
1919 cfg_priv->pwr_save = enabled;
1920 if (!test_bit(WL_STATUS_READY, &cfg_priv->status)) {
1922 WL_INFO("Device is not ready,"
1923 "storing the value in cfg_priv struct\n");
1927 pm = enabled ? PM_FAST : PM_OFF;
1928 WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
1930 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_PM, &pm);
1933 WL_ERR("net_device is not ready yet\n");
1935 WL_ERR("error (%d)\n", err);
1943 brcmf_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *ndev,
1945 const struct cfg80211_bitrate_mask *mask)
1947 struct brcm_rateset_le rateset_le;
1955 WL_TRACE("Enter\n");
1956 if (!check_sys_up(wiphy))
1959 /* addr param is always NULL. ignore it */
1960 /* Get current rateset */
1961 err = brcmf_exec_dcmd(ndev, BRCM_GET_CURR_RATESET, &rateset_le,
1962 sizeof(rateset_le));
1964 WL_ERR("could not get current rateset (%d)\n", err);
1968 legacy = ffs(mask->control[IEEE80211_BAND_2GHZ].legacy & 0xFFFF);
1970 legacy = ffs(mask->control[IEEE80211_BAND_5GHZ].legacy &
1973 val = wl_g_rates[legacy - 1].bitrate * 100000;
1975 if (val < le32_to_cpu(rateset_le.count))
1976 /* Select rate by rateset index */
1977 rate = rateset_le.rates[val] & 0x7f;
1979 /* Specified rate in bps */
1980 rate = val / 500000;
1982 WL_CONN("rate %d mbps\n", rate / 2);
1986 * Set rate override,
1987 * Since the is a/b/g-blind, both a/bg_rate are enforced.
1989 err_bg = brcmf_dev_intvar_set(ndev, "bg_rate", rate);
1990 err_a = brcmf_dev_intvar_set(ndev, "a_rate", rate);
1991 if (err_bg && err_a) {
1992 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
1993 err = err_bg | err_a;
2001 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_priv *cfg_priv,
2002 struct brcmf_bss_info *bi)
2004 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2005 struct ieee80211_channel *notify_channel;
2006 struct cfg80211_bss *bss;
2007 struct ieee80211_supported_band *band;
2011 u64 notify_timestamp;
2012 u16 notify_capability;
2013 u16 notify_interval;
2015 size_t notify_ielen;
2018 if (le32_to_cpu(bi->length) > WL_BSS_INFO_MAX) {
2019 WL_ERR("Bss info is larger than buffer. Discarding\n");
2023 channel = bi->ctl_ch ? bi->ctl_ch :
2024 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2026 if (channel <= CH_MAX_2G_CHANNEL)
2027 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2029 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2031 freq = ieee80211_channel_to_frequency(channel, band->band);
2032 notify_channel = ieee80211_get_channel(wiphy, freq);
2034 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2035 notify_capability = le16_to_cpu(bi->capability);
2036 notify_interval = le16_to_cpu(bi->beacon_period);
2037 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2038 notify_ielen = le32_to_cpu(bi->ie_length);
2039 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2041 WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2042 bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
2043 bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
2044 WL_CONN("Channel: %d(%d)\n", channel, freq);
2045 WL_CONN("Capability: %X\n", notify_capability);
2046 WL_CONN("Beacon interval: %d\n", notify_interval);
2047 WL_CONN("Signal: %d\n", notify_signal);
2048 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2050 bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2051 notify_timestamp, notify_capability, notify_interval, notify_ie,
2052 notify_ielen, notify_signal, GFP_KERNEL);
2055 WL_ERR("cfg80211_inform_bss_frame error\n");
2062 static s32 brcmf_inform_bss(struct brcmf_cfg80211_priv *cfg_priv)
2064 struct brcmf_scan_results *bss_list;
2065 struct brcmf_bss_info *bi = NULL; /* must be initialized */
2069 bss_list = cfg_priv->bss_list;
2070 if (bss_list->version != BRCMF_BSS_INFO_VERSION) {
2071 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2075 WL_SCAN("scanned AP count (%d)\n", bss_list->count);
2076 for (i = 0; i < bss_list->count && i < WL_AP_MAX; i++) {
2077 bi = next_bss(bss_list, bi);
2078 err = brcmf_inform_single_bss(cfg_priv, bi);
2085 static s32 wl_inform_ibss(struct brcmf_cfg80211_priv *cfg_priv,
2086 struct net_device *ndev, const u8 *bssid)
2088 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2089 struct ieee80211_channel *notify_channel;
2090 struct brcmf_bss_info *bi = NULL;
2091 struct ieee80211_supported_band *band;
2096 u64 notify_timestamp;
2097 u16 notify_capability;
2098 u16 notify_interval;
2100 size_t notify_ielen;
2103 WL_TRACE("Enter\n");
2105 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2111 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2113 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
2115 WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
2119 bi = (struct brcmf_bss_info *)(buf + 4);
2121 channel = bi->ctl_ch ? bi->ctl_ch :
2122 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2124 if (channel <= CH_MAX_2G_CHANNEL)
2125 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2127 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2129 freq = ieee80211_channel_to_frequency(channel, band->band);
2130 notify_channel = ieee80211_get_channel(wiphy, freq);
2132 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2133 notify_capability = le16_to_cpu(bi->capability);
2134 notify_interval = le16_to_cpu(bi->beacon_period);
2135 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2136 notify_ielen = le32_to_cpu(bi->ie_length);
2137 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2139 WL_CONN("channel: %d(%d)\n", channel, freq);
2140 WL_CONN("capability: %X\n", notify_capability);
2141 WL_CONN("beacon interval: %d\n", notify_interval);
2142 WL_CONN("signal: %d\n", notify_signal);
2143 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2145 cfg80211_inform_bss(wiphy, notify_channel, bssid,
2146 notify_timestamp, notify_capability, notify_interval,
2147 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2158 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_priv *cfg_priv)
2160 return cfg_priv->conf->mode == WL_MODE_IBSS;
2164 * Traverse a string of 1-byte tag/1-byte length/variable-length value
2165 * triples, returning a pointer to the substring whose first element
2168 static struct brcmf_tlv *brcmf_parse_tlvs(void *buf, int buflen, uint key)
2170 struct brcmf_tlv *elt;
2173 elt = (struct brcmf_tlv *) buf;
2176 /* find tagged parameter */
2177 while (totlen >= 2) {
2180 /* validate remaining totlen */
2181 if ((elt->id == key) && (totlen >= (len + 2)))
2184 elt = (struct brcmf_tlv *) ((u8 *) elt + (len + 2));
2185 totlen -= (len + 2);
2191 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_priv *cfg_priv)
2193 struct brcmf_bss_info *bi;
2194 struct brcmf_ssid *ssid;
2195 struct brcmf_tlv *tim;
2196 u16 beacon_interval;
2202 WL_TRACE("Enter\n");
2203 if (brcmf_is_ibssmode(cfg_priv))
2206 ssid = (struct brcmf_ssid *)brcmf_read_prof(cfg_priv, WL_PROF_SSID);
2208 *(__le32 *)cfg_priv->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2209 err = brcmf_exec_dcmd(cfg_to_ndev(cfg_priv), BRCMF_C_GET_BSS_INFO,
2210 cfg_priv->extra_buf, WL_EXTRA_BUF_MAX);
2212 WL_ERR("Could not get bss info %d\n", err);
2213 goto update_bss_info_out;
2216 bi = (struct brcmf_bss_info *)(cfg_priv->extra_buf + 4);
2217 err = brcmf_inform_single_bss(cfg_priv, bi);
2219 goto update_bss_info_out;
2221 ie = ((u8 *)bi) + le16_to_cpu(bi->ie_offset);
2222 ie_len = le32_to_cpu(bi->ie_length);
2223 beacon_interval = le16_to_cpu(bi->beacon_period);
2225 tim = brcmf_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2227 dtim_period = tim->data[1];
2230 * active scan was done so we could not get dtim
2231 * information out of probe response.
2232 * so we speficially query dtim information to dongle.
2235 err = brcmf_dev_intvar_get(cfg_to_ndev(cfg_priv),
2236 "dtim_assoc", &var);
2238 WL_ERR("wl dtim_assoc failed (%d)\n", err);
2239 goto update_bss_info_out;
2241 dtim_period = (u8)var;
2244 brcmf_update_prof(cfg_priv, NULL, &beacon_interval, WL_PROF_BEACONINT);
2245 brcmf_update_prof(cfg_priv, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2247 update_bss_info_out:
2252 static void brcmf_term_iscan(struct brcmf_cfg80211_priv *cfg_priv)
2254 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
2255 struct brcmf_ssid ssid;
2257 if (cfg_priv->iscan_on) {
2258 iscan->state = WL_ISCAN_STATE_IDLE;
2260 if (iscan->timer_on) {
2261 del_timer_sync(&iscan->timer);
2262 iscan->timer_on = 0;
2265 cancel_work_sync(&iscan->work);
2267 /* Abort iscan running in FW */
2268 memset(&ssid, 0, sizeof(ssid));
2269 brcmf_run_iscan(iscan, &ssid, WL_SCAN_ACTION_ABORT);
2273 static void brcmf_notify_iscan_complete(struct brcmf_cfg80211_iscan_ctrl *iscan,
2276 struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
2277 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2279 if (!test_and_clear_bit(WL_STATUS_SCANNING, &cfg_priv->status)) {
2280 WL_ERR("Scan complete while device not scanning\n");
2283 if (cfg_priv->scan_request) {
2284 WL_SCAN("ISCAN Completed scan: %s\n",
2285 aborted ? "Aborted" : "Done");
2286 cfg80211_scan_done(cfg_priv->scan_request, aborted);
2287 brcmf_set_mpc(ndev, 1);
2288 cfg_priv->scan_request = NULL;
2290 cfg_priv->iscan_kickstart = false;
2293 static s32 brcmf_wakeup_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan)
2295 if (iscan->state != WL_ISCAN_STATE_IDLE) {
2296 WL_SCAN("wake up iscan\n");
2297 schedule_work(&iscan->work);
2305 brcmf_get_iscan_results(struct brcmf_cfg80211_iscan_ctrl *iscan, u32 *status,
2306 struct brcmf_scan_results **bss_list)
2308 struct brcmf_iscan_results list;
2309 struct brcmf_scan_results *results;
2310 struct brcmf_scan_results_le *results_le;
2311 struct brcmf_iscan_results *list_buf;
2314 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
2315 list_buf = (struct brcmf_iscan_results *)iscan->scan_buf;
2316 results = &list_buf->results;
2317 results_le = &list_buf->results_le;
2318 results->buflen = BRCMF_ISCAN_RESULTS_FIXED_SIZE;
2319 results->version = 0;
2322 memset(&list, 0, sizeof(list));
2323 list.results_le.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
2324 err = brcmf_dev_iovar_getbuf(iscan->ndev, "iscanresults", &list,
2325 BRCMF_ISCAN_RESULTS_FIXED_SIZE,
2326 iscan->scan_buf, WL_ISCAN_BUF_MAX);
2328 WL_ERR("error (%d)\n", err);
2331 results->buflen = le32_to_cpu(results_le->buflen);
2332 results->version = le32_to_cpu(results_le->version);
2333 results->count = le32_to_cpu(results_le->count);
2334 WL_SCAN("results->count = %d\n", results_le->count);
2335 WL_SCAN("results->buflen = %d\n", results_le->buflen);
2336 *status = le32_to_cpu(list_buf->status_le);
2337 WL_SCAN("status = %d\n", *status);
2338 *bss_list = results;
2343 static s32 brcmf_iscan_done(struct brcmf_cfg80211_priv *cfg_priv)
2345 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2348 iscan->state = WL_ISCAN_STATE_IDLE;
2349 brcmf_inform_bss(cfg_priv);
2350 brcmf_notify_iscan_complete(iscan, false);
2355 static s32 brcmf_iscan_pending(struct brcmf_cfg80211_priv *cfg_priv)
2357 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2360 /* Reschedule the timer */
2361 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
2362 iscan->timer_on = 1;
2367 static s32 brcmf_iscan_inprogress(struct brcmf_cfg80211_priv *cfg_priv)
2369 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2372 brcmf_inform_bss(cfg_priv);
2373 brcmf_run_iscan(iscan, NULL, BRCMF_SCAN_ACTION_CONTINUE);
2374 /* Reschedule the timer */
2375 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
2376 iscan->timer_on = 1;
2381 static s32 brcmf_iscan_aborted(struct brcmf_cfg80211_priv *cfg_priv)
2383 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2386 iscan->state = WL_ISCAN_STATE_IDLE;
2387 brcmf_notify_iscan_complete(iscan, true);
2392 static void brcmf_cfg80211_iscan_handler(struct work_struct *work)
2394 struct brcmf_cfg80211_iscan_ctrl *iscan =
2395 container_of(work, struct brcmf_cfg80211_iscan_ctrl,
2397 struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
2398 struct brcmf_cfg80211_iscan_eloop *el = &iscan->el;
2399 u32 status = BRCMF_SCAN_RESULTS_PARTIAL;
2401 if (iscan->timer_on) {
2402 del_timer_sync(&iscan->timer);
2403 iscan->timer_on = 0;
2406 if (brcmf_get_iscan_results(iscan, &status, &cfg_priv->bss_list)) {
2407 status = BRCMF_SCAN_RESULTS_ABORTED;
2408 WL_ERR("Abort iscan\n");
2411 el->handler[status](cfg_priv);
2414 static void brcmf_iscan_timer(unsigned long data)
2416 struct brcmf_cfg80211_iscan_ctrl *iscan =
2417 (struct brcmf_cfg80211_iscan_ctrl *)data;
2420 iscan->timer_on = 0;
2421 WL_SCAN("timer expired\n");
2422 brcmf_wakeup_iscan(iscan);
2426 static s32 brcmf_invoke_iscan(struct brcmf_cfg80211_priv *cfg_priv)
2428 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
2430 if (cfg_priv->iscan_on) {
2431 iscan->state = WL_ISCAN_STATE_IDLE;
2432 INIT_WORK(&iscan->work, brcmf_cfg80211_iscan_handler);
2438 static void brcmf_init_iscan_eloop(struct brcmf_cfg80211_iscan_eloop *el)
2440 memset(el, 0, sizeof(*el));
2441 el->handler[BRCMF_SCAN_RESULTS_SUCCESS] = brcmf_iscan_done;
2442 el->handler[BRCMF_SCAN_RESULTS_PARTIAL] = brcmf_iscan_inprogress;
2443 el->handler[BRCMF_SCAN_RESULTS_PENDING] = brcmf_iscan_pending;
2444 el->handler[BRCMF_SCAN_RESULTS_ABORTED] = brcmf_iscan_aborted;
2445 el->handler[BRCMF_SCAN_RESULTS_NO_MEM] = brcmf_iscan_aborted;
2448 static s32 brcmf_init_iscan(struct brcmf_cfg80211_priv *cfg_priv)
2450 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
2453 if (cfg_priv->iscan_on) {
2454 iscan->ndev = cfg_to_ndev(cfg_priv);
2455 brcmf_init_iscan_eloop(&iscan->el);
2456 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
2457 init_timer(&iscan->timer);
2458 iscan->timer.data = (unsigned long) iscan;
2459 iscan->timer.function = brcmf_iscan_timer;
2460 err = brcmf_invoke_iscan(cfg_priv);
2462 iscan->data = cfg_priv;
2468 static void brcmf_delay(u32 ms)
2470 if (ms < 1000 / HZ) {
2478 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
2480 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2483 * Check for WL_STATUS_READY before any function call which
2484 * could result is bus access. Don't block the resume for
2485 * any driver error conditions
2487 WL_TRACE("Enter\n");
2489 if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2490 brcmf_invoke_iscan(wiphy_to_cfg(wiphy));
2496 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
2497 struct cfg80211_wowlan *wow)
2499 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2500 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2502 WL_TRACE("Enter\n");
2505 * Check for WL_STATUS_READY before any function call which
2506 * could result is bus access. Don't block the suspend for
2507 * any driver error conditions
2511 * While going to suspend if associated with AP disassociate
2512 * from AP to save power while system is in suspended state
2514 if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
2515 test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
2516 test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2517 WL_INFO("Disassociating from AP"
2518 " while entering suspend state\n");
2519 brcmf_link_down(cfg_priv);
2522 * Make sure WPA_Supplicant receives all the event
2523 * generated due to DISASSOC call to the fw to keep
2524 * the state fw and WPA_Supplicant state consistent
2529 set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2530 if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2531 brcmf_term_iscan(cfg_priv);
2533 if (cfg_priv->scan_request) {
2534 /* Indidate scan abort to cfg80211 layer */
2535 WL_INFO("Terminating scan in progress\n");
2536 cfg80211_scan_done(cfg_priv->scan_request, true);
2537 cfg_priv->scan_request = NULL;
2539 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
2540 clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2542 /* Turn off watchdog timer */
2543 if (test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2544 WL_INFO("Enable MPC\n");
2545 brcmf_set_mpc(ndev, 1);
2554 brcmf_dev_bufvar_set(struct net_device *ndev, s8 *name, s8 *buf, s32 len)
2556 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
2559 buflen = brcmf_c_mkiovar(name, buf, len, cfg_priv->dcmd_buf,
2563 return brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, cfg_priv->dcmd_buf,
2568 brcmf_dev_bufvar_get(struct net_device *ndev, s8 *name, s8 *buf,
2571 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
2575 len = brcmf_c_mkiovar(name, NULL, 0, cfg_priv->dcmd_buf,
2578 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, cfg_priv->dcmd_buf,
2581 WL_ERR("error (%d)\n", err);
2584 memcpy(buf, cfg_priv->dcmd_buf, buf_len);
2590 brcmf_update_pmklist(struct net_device *ndev,
2591 struct brcmf_cfg80211_pmk_list *pmk_list, s32 err)
2596 pmkid_len = le32_to_cpu(pmk_list->pmkids.npmkid);
2598 WL_CONN("No of elements %d\n", pmkid_len);
2599 for (i = 0; i < pmkid_len; i++) {
2600 WL_CONN("PMKID[%d]: %pM =\n", i,
2601 &pmk_list->pmkids.pmkid[i].BSSID);
2602 for (j = 0; j < WLAN_PMKID_LEN; j++)
2603 WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2607 brcmf_dev_bufvar_set(ndev, "pmkid_info", (char *)pmk_list,
2614 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev,
2615 struct cfg80211_pmksa *pmksa)
2617 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2618 struct pmkid_list *pmkids = &cfg_priv->pmk_list->pmkids;
2623 WL_TRACE("Enter\n");
2624 if (!check_sys_up(wiphy))
2627 pmkid_len = le32_to_cpu(pmkids->npmkid);
2628 for (i = 0; i < pmkid_len; i++)
2629 if (!memcmp(pmksa->bssid, pmkids->pmkid[i].BSSID, ETH_ALEN))
2631 if (i < WL_NUM_PMKIDS_MAX) {
2632 memcpy(pmkids->pmkid[i].BSSID, pmksa->bssid, ETH_ALEN);
2633 memcpy(pmkids->pmkid[i].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2634 if (i == pmkid_len) {
2636 pmkids->npmkid = cpu_to_le32(pmkid_len);
2641 WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2642 pmkids->pmkid[pmkid_len].BSSID);
2643 for (i = 0; i < WLAN_PMKID_LEN; i++)
2644 WL_CONN("%02x\n", pmkids->pmkid[pmkid_len].PMKID[i]);
2646 err = brcmf_update_pmklist(ndev, cfg_priv->pmk_list, err);
2653 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *ndev,
2654 struct cfg80211_pmksa *pmksa)
2656 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2657 struct pmkid_list pmkid;
2661 WL_TRACE("Enter\n");
2662 if (!check_sys_up(wiphy))
2665 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2666 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2668 WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2669 &pmkid.pmkid[0].BSSID);
2670 for (i = 0; i < WLAN_PMKID_LEN; i++)
2671 WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
2673 pmkid_len = le32_to_cpu(cfg_priv->pmk_list->pmkids.npmkid);
2674 for (i = 0; i < pmkid_len; i++)
2676 (pmksa->bssid, &cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2681 && (i < pmkid_len)) {
2682 memset(&cfg_priv->pmk_list->pmkids.pmkid[i], 0,
2683 sizeof(struct pmkid));
2684 for (; i < (pmkid_len - 1); i++) {
2685 memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2686 &cfg_priv->pmk_list->pmkids.pmkid[i + 1].BSSID,
2688 memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].PMKID,
2689 &cfg_priv->pmk_list->pmkids.pmkid[i + 1].PMKID,
2692 cfg_priv->pmk_list->pmkids.npmkid = cpu_to_le32(pmkid_len - 1);
2696 err = brcmf_update_pmklist(ndev, cfg_priv->pmk_list, err);
2704 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev)
2706 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2709 WL_TRACE("Enter\n");
2710 if (!check_sys_up(wiphy))
2713 memset(cfg_priv->pmk_list, 0, sizeof(*cfg_priv->pmk_list));
2714 err = brcmf_update_pmklist(ndev, cfg_priv->pmk_list, err);
2721 static struct cfg80211_ops wl_cfg80211_ops = {
2722 .change_virtual_intf = brcmf_cfg80211_change_iface,
2723 .scan = brcmf_cfg80211_scan,
2724 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
2725 .join_ibss = brcmf_cfg80211_join_ibss,
2726 .leave_ibss = brcmf_cfg80211_leave_ibss,
2727 .get_station = brcmf_cfg80211_get_station,
2728 .set_tx_power = brcmf_cfg80211_set_tx_power,
2729 .get_tx_power = brcmf_cfg80211_get_tx_power,
2730 .add_key = brcmf_cfg80211_add_key,
2731 .del_key = brcmf_cfg80211_del_key,
2732 .get_key = brcmf_cfg80211_get_key,
2733 .set_default_key = brcmf_cfg80211_config_default_key,
2734 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
2735 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
2736 .set_bitrate_mask = brcmf_cfg80211_set_bitrate_mask,
2737 .connect = brcmf_cfg80211_connect,
2738 .disconnect = brcmf_cfg80211_disconnect,
2739 .suspend = brcmf_cfg80211_suspend,
2740 .resume = brcmf_cfg80211_resume,
2741 .set_pmksa = brcmf_cfg80211_set_pmksa,
2742 .del_pmksa = brcmf_cfg80211_del_pmksa,
2743 .flush_pmksa = brcmf_cfg80211_flush_pmksa
2746 static s32 brcmf_mode_to_nl80211_iftype(s32 mode)
2752 return NL80211_IFTYPE_STATION;
2754 return NL80211_IFTYPE_ADHOC;
2756 return NL80211_IFTYPE_UNSPECIFIED;
2762 static struct wireless_dev *brcmf_alloc_wdev(s32 sizeof_iface,
2763 struct device *ndev)
2765 struct wireless_dev *wdev;
2768 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2770 return ERR_PTR(-ENOMEM);
2773 wiphy_new(&wl_cfg80211_ops,
2774 sizeof(struct brcmf_cfg80211_priv) + sizeof_iface);
2776 WL_ERR("Couldn not allocate wiphy device\n");
2780 set_wiphy_dev(wdev->wiphy, ndev);
2781 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2782 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2783 wdev->wiphy->interface_modes =
2784 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2785 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2786 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2787 * it as 11a by default.
2788 * This will be updated with
2791 * if phy has 11n capability
2793 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2794 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2795 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2796 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2800 err = wiphy_register(wdev->wiphy);
2802 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2803 goto wiphy_register_out;
2808 wiphy_free(wdev->wiphy);
2813 return ERR_PTR(err);
2816 static void brcmf_free_wdev(struct brcmf_cfg80211_priv *cfg_priv)
2818 struct wireless_dev *wdev = cfg_priv->wdev;
2821 WL_ERR("wdev is invalid\n");
2824 wiphy_unregister(wdev->wiphy);
2825 wiphy_free(wdev->wiphy);
2827 cfg_priv->wdev = NULL;
2830 static bool brcmf_is_linkup(struct brcmf_cfg80211_priv *cfg_priv,
2831 const struct brcmf_event_msg *e)
2833 u32 event = be32_to_cpu(e->event_type);
2834 u32 status = be32_to_cpu(e->status);
2836 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
2837 WL_CONN("Processing set ssid\n");
2838 cfg_priv->link_up = true;
2845 static bool brcmf_is_linkdown(struct brcmf_cfg80211_priv *cfg_priv,
2846 const struct brcmf_event_msg *e)
2848 u32 event = be32_to_cpu(e->event_type);
2849 u16 flags = be16_to_cpu(e->flags);
2851 if (event == BRCMF_E_LINK && (!(flags & BRCMF_EVENT_MSG_LINK))) {
2852 WL_CONN("Processing link down\n");
2858 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_priv *cfg_priv,
2859 const struct brcmf_event_msg *e)
2861 u32 event = be32_to_cpu(e->event_type);
2862 u32 status = be32_to_cpu(e->status);
2864 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
2865 WL_CONN("Processing Link %s & no network found\n",
2866 be16_to_cpu(e->flags) & BRCMF_EVENT_MSG_LINK ?
2871 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
2872 WL_CONN("Processing connecting & no network found\n");
2879 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2881 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2883 kfree(conn_info->req_ie);
2884 conn_info->req_ie = NULL;
2885 conn_info->req_ie_len = 0;
2886 kfree(conn_info->resp_ie);
2887 conn_info->resp_ie = NULL;
2888 conn_info->resp_ie_len = 0;
2891 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2893 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2894 struct brcmf_cfg80211_assoc_ielen_le *assoc_info;
2895 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2900 brcmf_clear_assoc_ies(cfg_priv);
2902 err = brcmf_dev_bufvar_get(ndev, "assoc_info", cfg_priv->extra_buf,
2905 WL_ERR("could not get assoc info (%d)\n", err);
2909 (struct brcmf_cfg80211_assoc_ielen_le *)cfg_priv->extra_buf;
2910 req_len = le32_to_cpu(assoc_info->req_len);
2911 resp_len = le32_to_cpu(assoc_info->resp_len);
2913 err = brcmf_dev_bufvar_get(ndev, "assoc_req_ies",
2914 cfg_priv->extra_buf,
2917 WL_ERR("could not get assoc req (%d)\n", err);
2920 conn_info->req_ie_len = req_len;
2922 kmemdup(cfg_priv->extra_buf, conn_info->req_ie_len,
2925 conn_info->req_ie_len = 0;
2926 conn_info->req_ie = NULL;
2929 err = brcmf_dev_bufvar_get(ndev, "assoc_resp_ies",
2930 cfg_priv->extra_buf,
2933 WL_ERR("could not get assoc resp (%d)\n", err);
2936 conn_info->resp_ie_len = resp_len;
2937 conn_info->resp_ie =
2938 kmemdup(cfg_priv->extra_buf, conn_info->resp_ie_len,
2941 conn_info->resp_ie_len = 0;
2942 conn_info->resp_ie = NULL;
2944 WL_CONN("req len (%d) resp len (%d)\n",
2945 conn_info->req_ie_len, conn_info->resp_ie_len);
2951 brcmf_bss_roaming_done(struct brcmf_cfg80211_priv *cfg_priv,
2952 struct net_device *ndev,
2953 const struct brcmf_event_msg *e)
2955 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2956 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2957 struct brcmf_channel_info_le channel_le;
2958 struct ieee80211_channel *notify_channel;
2959 struct ieee80211_supported_band *band;
2964 WL_TRACE("Enter\n");
2966 brcmf_get_assoc_ies(cfg_priv);
2967 brcmf_update_prof(cfg_priv, NULL, &e->addr, WL_PROF_BSSID);
2968 brcmf_update_bss_info(cfg_priv);
2970 brcmf_exec_dcmd(ndev, BRCMF_C_GET_CHANNEL, &channel_le,
2971 sizeof(channel_le));
2973 target_channel = le32_to_cpu(channel_le.target_channel);
2974 WL_CONN("Roamed to channel %d\n", target_channel);
2976 if (target_channel <= CH_MAX_2G_CHANNEL)
2977 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2979 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2981 freq = ieee80211_channel_to_frequency(target_channel, band->band);
2982 notify_channel = ieee80211_get_channel(wiphy, freq);
2984 cfg80211_roamed(ndev, notify_channel,
2985 (u8 *)brcmf_read_prof(cfg_priv, WL_PROF_BSSID),
2986 conn_info->req_ie, conn_info->req_ie_len,
2987 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2988 WL_CONN("Report roaming result\n");
2990 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
2996 brcmf_bss_connect_done(struct brcmf_cfg80211_priv *cfg_priv,
2997 struct net_device *ndev, const struct brcmf_event_msg *e,
3000 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
3003 WL_TRACE("Enter\n");
3005 if (test_and_clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) {
3007 brcmf_get_assoc_ies(cfg_priv);
3008 brcmf_update_prof(cfg_priv, NULL, &e->addr,
3010 brcmf_update_bss_info(cfg_priv);
3012 cfg80211_connect_result(ndev,
3013 (u8 *)brcmf_read_prof(cfg_priv,
3016 conn_info->req_ie_len,
3018 conn_info->resp_ie_len,
3019 completed ? WLAN_STATUS_SUCCESS :
3020 WLAN_STATUS_AUTH_TIMEOUT,
3023 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
3024 WL_CONN("Report connect result - connection %s\n",
3025 completed ? "succeeded" : "failed");
3032 brcmf_notify_connect_status(struct brcmf_cfg80211_priv *cfg_priv,
3033 struct net_device *ndev,
3034 const struct brcmf_event_msg *e, void *data)
3038 if (brcmf_is_linkup(cfg_priv, e)) {
3039 WL_CONN("Linkup\n");
3040 if (brcmf_is_ibssmode(cfg_priv)) {
3041 brcmf_update_prof(cfg_priv, NULL, (void *)e->addr,
3043 wl_inform_ibss(cfg_priv, ndev, e->addr);
3044 cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
3045 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
3046 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
3048 brcmf_bss_connect_done(cfg_priv, ndev, e, true);
3049 } else if (brcmf_is_linkdown(cfg_priv, e)) {
3050 WL_CONN("Linkdown\n");
3051 if (brcmf_is_ibssmode(cfg_priv)) {
3052 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
3053 if (test_and_clear_bit(WL_STATUS_CONNECTED,
3055 brcmf_link_down(cfg_priv);
3057 brcmf_bss_connect_done(cfg_priv, ndev, e, false);
3058 if (test_and_clear_bit(WL_STATUS_CONNECTED,
3059 &cfg_priv->status)) {
3060 cfg80211_disconnected(ndev, 0, NULL, 0,
3062 brcmf_link_down(cfg_priv);
3065 brcmf_init_prof(cfg_priv->profile);
3066 } else if (brcmf_is_nonetwork(cfg_priv, e)) {
3067 if (brcmf_is_ibssmode(cfg_priv))
3068 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
3070 brcmf_bss_connect_done(cfg_priv, ndev, e, false);
3077 brcmf_notify_roaming_status(struct brcmf_cfg80211_priv *cfg_priv,
3078 struct net_device *ndev,
3079 const struct brcmf_event_msg *e, void *data)
3082 u32 event = be32_to_cpu(e->event_type);
3083 u32 status = be32_to_cpu(e->status);
3085 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
3086 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status))
3087 brcmf_bss_roaming_done(cfg_priv, ndev, e);
3089 brcmf_bss_connect_done(cfg_priv, ndev, e, true);
3096 brcmf_notify_mic_status(struct brcmf_cfg80211_priv *cfg_priv,
3097 struct net_device *ndev,
3098 const struct brcmf_event_msg *e, void *data)
3100 u16 flags = be16_to_cpu(e->flags);
3101 enum nl80211_key_type key_type;
3103 if (flags & BRCMF_EVENT_MSG_GROUP)
3104 key_type = NL80211_KEYTYPE_GROUP;
3106 key_type = NL80211_KEYTYPE_PAIRWISE;
3108 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
3115 brcmf_notify_scan_status(struct brcmf_cfg80211_priv *cfg_priv,
3116 struct net_device *ndev,
3117 const struct brcmf_event_msg *e, void *data)
3119 struct brcmf_channel_info_le channel_inform_le;
3120 struct brcmf_scan_results_le *bss_list_le;
3121 u32 len = WL_SCAN_BUF_MAX;
3123 bool scan_abort = false;
3126 WL_TRACE("Enter\n");
3128 if (cfg_priv->iscan_on && cfg_priv->iscan_kickstart) {
3130 return brcmf_wakeup_iscan(cfg_to_iscan(cfg_priv));
3133 if (!test_and_clear_bit(WL_STATUS_SCANNING, &cfg_priv->status)) {
3134 WL_ERR("Scan complete while device not scanning\n");
3140 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_CHANNEL, &channel_inform_le,
3141 sizeof(channel_inform_le));
3143 WL_ERR("scan busy (%d)\n", err);
3147 scan_channel = le32_to_cpu(channel_inform_le.scan_channel);
3149 WL_CONN("channel_inform.scan_channel (%d)\n", scan_channel);
3150 cfg_priv->bss_list = cfg_priv->scan_results;
3151 bss_list_le = (struct brcmf_scan_results_le *) cfg_priv->bss_list;
3153 memset(cfg_priv->scan_results, 0, len);
3154 bss_list_le->buflen = cpu_to_le32(len);
3155 err = brcmf_exec_dcmd(ndev, BRCMF_C_SCAN_RESULTS,
3156 cfg_priv->scan_results, len);
3158 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
3163 cfg_priv->scan_results->buflen = le32_to_cpu(bss_list_le->buflen);
3164 cfg_priv->scan_results->version = le32_to_cpu(bss_list_le->version);
3165 cfg_priv->scan_results->count = le32_to_cpu(bss_list_le->count);
3167 err = brcmf_inform_bss(cfg_priv);
3174 if (cfg_priv->scan_request) {
3175 WL_SCAN("calling cfg80211_scan_done\n");
3176 cfg80211_scan_done(cfg_priv->scan_request, scan_abort);
3177 brcmf_set_mpc(ndev, 1);
3178 cfg_priv->scan_request = NULL;
3186 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
3188 conf->mode = (u32)-1;
3189 conf->frag_threshold = (u32)-1;
3190 conf->rts_threshold = (u32)-1;
3191 conf->retry_short = (u32)-1;
3192 conf->retry_long = (u32)-1;
3193 conf->tx_power = -1;
3196 static void brcmf_init_eloop_handler(struct brcmf_cfg80211_event_loop *el)
3198 memset(el, 0, sizeof(*el));
3199 el->handler[BRCMF_E_SCAN_COMPLETE] = brcmf_notify_scan_status;
3200 el->handler[BRCMF_E_LINK] = brcmf_notify_connect_status;
3201 el->handler[BRCMF_E_ROAM] = brcmf_notify_roaming_status;
3202 el->handler[BRCMF_E_MIC_ERROR] = brcmf_notify_mic_status;
3203 el->handler[BRCMF_E_SET_SSID] = brcmf_notify_connect_status;
3206 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3208 kfree(cfg_priv->scan_results);
3209 cfg_priv->scan_results = NULL;
3210 kfree(cfg_priv->bss_info);
3211 cfg_priv->bss_info = NULL;
3212 kfree(cfg_priv->conf);
3213 cfg_priv->conf = NULL;
3214 kfree(cfg_priv->profile);
3215 cfg_priv->profile = NULL;
3216 kfree(cfg_priv->scan_req_int);
3217 cfg_priv->scan_req_int = NULL;
3218 kfree(cfg_priv->dcmd_buf);
3219 cfg_priv->dcmd_buf = NULL;
3220 kfree(cfg_priv->extra_buf);
3221 cfg_priv->extra_buf = NULL;
3222 kfree(cfg_priv->iscan);
3223 cfg_priv->iscan = NULL;
3224 kfree(cfg_priv->pmk_list);
3225 cfg_priv->pmk_list = NULL;
3228 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3230 cfg_priv->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
3231 if (!cfg_priv->scan_results)
3232 goto init_priv_mem_out;
3233 cfg_priv->conf = kzalloc(sizeof(*cfg_priv->conf), GFP_KERNEL);
3234 if (!cfg_priv->conf)
3235 goto init_priv_mem_out;
3236 cfg_priv->profile = kzalloc(sizeof(*cfg_priv->profile), GFP_KERNEL);
3237 if (!cfg_priv->profile)
3238 goto init_priv_mem_out;
3239 cfg_priv->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
3240 if (!cfg_priv->bss_info)
3241 goto init_priv_mem_out;
3242 cfg_priv->scan_req_int = kzalloc(sizeof(*cfg_priv->scan_req_int),
3244 if (!cfg_priv->scan_req_int)
3245 goto init_priv_mem_out;
3246 cfg_priv->dcmd_buf = kzalloc(WL_DCMD_LEN_MAX, GFP_KERNEL);
3247 if (!cfg_priv->dcmd_buf)
3248 goto init_priv_mem_out;
3249 cfg_priv->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3250 if (!cfg_priv->extra_buf)
3251 goto init_priv_mem_out;
3252 cfg_priv->iscan = kzalloc(sizeof(*cfg_priv->iscan), GFP_KERNEL);
3253 if (!cfg_priv->iscan)
3254 goto init_priv_mem_out;
3255 cfg_priv->pmk_list = kzalloc(sizeof(*cfg_priv->pmk_list), GFP_KERNEL);
3256 if (!cfg_priv->pmk_list)
3257 goto init_priv_mem_out;
3262 brcmf_deinit_priv_mem(cfg_priv);
3268 * retrieve first queued event from head
3271 static struct brcmf_cfg80211_event_q *brcmf_deq_event(
3272 struct brcmf_cfg80211_priv *cfg_priv)
3274 struct brcmf_cfg80211_event_q *e = NULL;
3276 spin_lock_irq(&cfg_priv->evt_q_lock);
3277 if (!list_empty(&cfg_priv->evt_q_list)) {
3278 e = list_first_entry(&cfg_priv->evt_q_list,
3279 struct brcmf_cfg80211_event_q, evt_q_list);
3280 list_del(&e->evt_q_list);
3282 spin_unlock_irq(&cfg_priv->evt_q_lock);
3288 ** push event to tail of the queue
3292 brcmf_enq_event(struct brcmf_cfg80211_priv *cfg_priv, u32 event,
3293 const struct brcmf_event_msg *msg)
3295 struct brcmf_cfg80211_event_q *e;
3298 e = kzalloc(sizeof(struct brcmf_cfg80211_event_q), GFP_KERNEL);
3303 memcpy(&e->emsg, msg, sizeof(struct brcmf_event_msg));
3305 spin_lock_irq(&cfg_priv->evt_q_lock);
3306 list_add_tail(&e->evt_q_list, &cfg_priv->evt_q_list);
3307 spin_unlock_irq(&cfg_priv->evt_q_lock);
3312 static void brcmf_put_event(struct brcmf_cfg80211_event_q *e)
3317 static void brcmf_cfg80211_event_handler(struct work_struct *work)
3319 struct brcmf_cfg80211_priv *cfg_priv =
3320 container_of(work, struct brcmf_cfg80211_priv,
3322 struct brcmf_cfg80211_event_q *e;
3324 e = brcmf_deq_event(cfg_priv);
3326 WL_ERR("event queue empty...\n");
3331 WL_INFO("event type (%d)\n", e->etype);
3332 if (cfg_priv->el.handler[e->etype])
3333 cfg_priv->el.handler[e->etype](cfg_priv,
3334 cfg_to_ndev(cfg_priv),
3335 &e->emsg, e->edata);
3337 WL_INFO("Unknown Event (%d): ignoring\n", e->etype);
3339 } while ((e = brcmf_deq_event(cfg_priv)));
3343 static void brcmf_init_eq(struct brcmf_cfg80211_priv *cfg_priv)
3345 spin_lock_init(&cfg_priv->evt_q_lock);
3346 INIT_LIST_HEAD(&cfg_priv->evt_q_list);
3349 static void brcmf_flush_eq(struct brcmf_cfg80211_priv *cfg_priv)
3351 struct brcmf_cfg80211_event_q *e;
3353 spin_lock_irq(&cfg_priv->evt_q_lock);
3354 while (!list_empty(&cfg_priv->evt_q_list)) {
3355 e = list_first_entry(&cfg_priv->evt_q_list,
3356 struct brcmf_cfg80211_event_q, evt_q_list);
3357 list_del(&e->evt_q_list);
3360 spin_unlock_irq(&cfg_priv->evt_q_lock);
3363 static s32 wl_init_priv(struct brcmf_cfg80211_priv *cfg_priv)
3367 cfg_priv->scan_request = NULL;
3368 cfg_priv->pwr_save = true;
3369 cfg_priv->iscan_on = true; /* iscan on & off switch.
3370 we enable iscan per default */
3371 cfg_priv->roam_on = true; /* roam on & off switch.
3372 we enable roam per default */
3374 cfg_priv->iscan_kickstart = false;
3375 cfg_priv->active_scan = true; /* we do active scan for
3376 specific scan per default */
3377 cfg_priv->dongle_up = false; /* dongle is not up yet */
3378 brcmf_init_eq(cfg_priv);
3379 err = brcmf_init_priv_mem(cfg_priv);
3382 INIT_WORK(&cfg_priv->event_work, brcmf_cfg80211_event_handler);
3383 brcmf_init_eloop_handler(&cfg_priv->el);
3384 mutex_init(&cfg_priv->usr_sync);
3385 err = brcmf_init_iscan(cfg_priv);
3388 brcmf_init_conf(cfg_priv->conf);
3389 brcmf_init_prof(cfg_priv->profile);
3390 brcmf_link_down(cfg_priv);
3395 static void wl_deinit_priv(struct brcmf_cfg80211_priv *cfg_priv)
3397 cancel_work_sync(&cfg_priv->event_work);
3398 cfg_priv->dongle_up = false; /* dongle down */
3399 brcmf_flush_eq(cfg_priv);
3400 brcmf_link_down(cfg_priv);
3401 brcmf_term_iscan(cfg_priv);
3402 brcmf_deinit_priv_mem(cfg_priv);
3405 struct brcmf_cfg80211_dev *brcmf_cfg80211_attach(struct net_device *ndev,
3406 struct device *busdev,
3409 struct wireless_dev *wdev;
3410 struct brcmf_cfg80211_priv *cfg_priv;
3411 struct brcmf_cfg80211_iface *ci;
3412 struct brcmf_cfg80211_dev *cfg_dev;
3416 WL_ERR("ndev is invalid\n");
3419 cfg_dev = kzalloc(sizeof(struct brcmf_cfg80211_dev), GFP_KERNEL);
3423 wdev = brcmf_alloc_wdev(sizeof(struct brcmf_cfg80211_iface), busdev);
3429 wdev->iftype = brcmf_mode_to_nl80211_iftype(WL_MODE_BSS);
3430 cfg_priv = wdev_to_cfg(wdev);
3431 cfg_priv->wdev = wdev;
3432 cfg_priv->pub = data;
3433 ci = (struct brcmf_cfg80211_iface *)&cfg_priv->ci;
3434 ci->cfg_priv = cfg_priv;
3435 ndev->ieee80211_ptr = wdev;
3436 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3437 wdev->netdev = ndev;
3438 err = wl_init_priv(cfg_priv);
3440 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3441 goto cfg80211_attach_out;
3443 brcmf_set_drvdata(cfg_dev, ci);
3447 cfg80211_attach_out:
3448 brcmf_free_wdev(cfg_priv);
3453 void brcmf_cfg80211_detach(struct brcmf_cfg80211_dev *cfg_dev)
3455 struct brcmf_cfg80211_priv *cfg_priv;
3457 cfg_priv = brcmf_priv_get(cfg_dev);
3459 wl_deinit_priv(cfg_priv);
3460 brcmf_free_wdev(cfg_priv);
3461 brcmf_set_drvdata(cfg_dev, NULL);
3466 brcmf_cfg80211_event(struct net_device *ndev,
3467 const struct brcmf_event_msg *e, void *data)
3469 u32 event_type = be32_to_cpu(e->event_type);
3470 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
3472 if (!brcmf_enq_event(cfg_priv, event_type, e))
3473 schedule_work(&cfg_priv->event_work);
3476 static s32 brcmf_dongle_mode(struct net_device *ndev, s32 iftype)
3482 case NL80211_IFTYPE_MONITOR:
3483 case NL80211_IFTYPE_WDS:
3484 WL_ERR("type (%d) : currently we do not support this mode\n",
3488 case NL80211_IFTYPE_ADHOC:
3491 case NL80211_IFTYPE_STATION:
3496 WL_ERR("invalid type (%d)\n", iftype);
3499 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_INFRA, &infra);
3501 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
3508 static s32 brcmf_dongle_eventmsg(struct net_device *ndev)
3510 /* Room for "event_msgs" + '\0' + bitvec */
3511 s8 iovbuf[BRCMF_EVENTING_MASK_LEN + 12];
3512 s8 eventmask[BRCMF_EVENTING_MASK_LEN];
3515 WL_TRACE("Enter\n");
3517 /* Setup event_msgs */
3518 brcmf_c_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN,
3519 iovbuf, sizeof(iovbuf));
3520 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, iovbuf, sizeof(iovbuf));
3522 WL_ERR("Get event_msgs error (%d)\n", err);
3523 goto dongle_eventmsg_out;
3525 memcpy(eventmask, iovbuf, BRCMF_EVENTING_MASK_LEN);
3527 setbit(eventmask, BRCMF_E_SET_SSID);
3528 setbit(eventmask, BRCMF_E_ROAM);
3529 setbit(eventmask, BRCMF_E_PRUNE);
3530 setbit(eventmask, BRCMF_E_AUTH);
3531 setbit(eventmask, BRCMF_E_REASSOC);
3532 setbit(eventmask, BRCMF_E_REASSOC_IND);
3533 setbit(eventmask, BRCMF_E_DEAUTH_IND);
3534 setbit(eventmask, BRCMF_E_DISASSOC_IND);
3535 setbit(eventmask, BRCMF_E_DISASSOC);
3536 setbit(eventmask, BRCMF_E_JOIN);
3537 setbit(eventmask, BRCMF_E_ASSOC_IND);
3538 setbit(eventmask, BRCMF_E_PSK_SUP);
3539 setbit(eventmask, BRCMF_E_LINK);
3540 setbit(eventmask, BRCMF_E_NDIS_LINK);
3541 setbit(eventmask, BRCMF_E_MIC_ERROR);
3542 setbit(eventmask, BRCMF_E_PMKID_CACHE);
3543 setbit(eventmask, BRCMF_E_TXFAIL);
3544 setbit(eventmask, BRCMF_E_JOIN_START);
3545 setbit(eventmask, BRCMF_E_SCAN_COMPLETE);
3547 brcmf_c_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN,
3548 iovbuf, sizeof(iovbuf));
3549 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3551 WL_ERR("Set event_msgs error (%d)\n", err);
3552 goto dongle_eventmsg_out;
3555 dongle_eventmsg_out:
3561 brcmf_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3565 __le32 roamtrigger[2];
3566 __le32 roam_delta[2];
3571 * Setup timeout if Beacons are lost and roam is
3572 * off to report link down
3575 bcn_to_le = cpu_to_le32(bcn_timeout);
3576 brcmf_c_mkiovar("bcn_timeout", (char *)&bcn_to_le,
3577 sizeof(bcn_to_le), iovbuf, sizeof(iovbuf));
3578 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR,
3579 iovbuf, sizeof(iovbuf));
3581 WL_ERR("bcn_timeout error (%d)\n", err);
3582 goto dongle_rom_out;
3587 * Enable/Disable built-in roaming to allow supplicant
3588 * to take care of roaming
3590 WL_INFO("Internal Roaming = %s\n", roamvar ? "Off" : "On");
3591 roamvar_le = cpu_to_le32(roamvar);
3592 brcmf_c_mkiovar("roam_off", (char *)&roamvar_le,
3593 sizeof(roamvar_le), iovbuf, sizeof(iovbuf));
3594 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3596 WL_ERR("roam_off error (%d)\n", err);
3597 goto dongle_rom_out;
3600 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL);
3601 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL);
3602 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_ROAM_TRIGGER,
3603 (void *)roamtrigger, sizeof(roamtrigger));
3605 WL_ERR("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
3606 goto dongle_rom_out;
3609 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA);
3610 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL);
3611 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_ROAM_DELTA,
3612 (void *)roam_delta, sizeof(roam_delta));
3614 WL_ERR("WLC_SET_ROAM_DELTA error (%d)\n", err);
3615 goto dongle_rom_out;
3623 brcmf_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
3624 s32 scan_unassoc_time, s32 scan_passive_time)
3627 __le32 scan_assoc_tm_le = cpu_to_le32(scan_assoc_time);
3628 __le32 scan_unassoc_tm_le = cpu_to_le32(scan_unassoc_time);
3629 __le32 scan_passive_tm_le = cpu_to_le32(scan_passive_time);
3631 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SCAN_CHANNEL_TIME,
3632 &scan_assoc_tm_le, sizeof(scan_assoc_tm_le));
3634 if (err == -EOPNOTSUPP)
3635 WL_INFO("Scan assoc time is not supported\n");
3637 WL_ERR("Scan assoc time error (%d)\n", err);
3638 goto dongle_scantime_out;
3640 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SCAN_UNASSOC_TIME,
3641 &scan_unassoc_tm_le, sizeof(scan_unassoc_tm_le));
3643 if (err == -EOPNOTSUPP)
3644 WL_INFO("Scan unassoc time is not supported\n");
3646 WL_ERR("Scan unassoc time error (%d)\n", err);
3647 goto dongle_scantime_out;
3650 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SCAN_PASSIVE_TIME,
3651 &scan_passive_tm_le, sizeof(scan_passive_tm_le));
3653 if (err == -EOPNOTSUPP)
3654 WL_INFO("Scan passive time is not supported\n");
3656 WL_ERR("Scan passive time error (%d)\n", err);
3657 goto dongle_scantime_out;
3660 dongle_scantime_out:
3664 static s32 wl_update_wiphybands(struct brcmf_cfg80211_priv *cfg_priv)
3666 struct wiphy *wiphy;
3671 err = brcmf_exec_dcmd(cfg_to_ndev(cfg_priv), BRCM_GET_PHYLIST,
3672 &phy_list, sizeof(phy_list));
3674 WL_ERR("error (%d)\n", err);
3678 phy = ((char *)&phy_list)[1];
3679 WL_INFO("%c phy\n", phy);
3680 if (phy == 'n' || phy == 'a') {
3681 wiphy = cfg_to_wiphy(cfg_priv);
3682 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
3688 static s32 brcmf_dongle_probecap(struct brcmf_cfg80211_priv *cfg_priv)
3690 return wl_update_wiphybands(cfg_priv);
3693 static s32 brcmf_config_dongle(struct brcmf_cfg80211_priv *cfg_priv)
3695 struct net_device *ndev;
3696 struct wireless_dev *wdev;
3700 if (cfg_priv->dongle_up)
3703 ndev = cfg_to_ndev(cfg_priv);
3704 wdev = ndev->ieee80211_ptr;
3706 brcmf_dongle_scantime(ndev, WL_SCAN_CHANNEL_TIME,
3707 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
3709 err = brcmf_dongle_eventmsg(ndev);
3711 goto default_conf_out;
3713 power_mode = cfg_priv->pwr_save ? PM_FAST : PM_OFF;
3714 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_PM, &power_mode);
3716 goto default_conf_out;
3717 WL_INFO("power save set to %s\n",
3718 (power_mode ? "enabled" : "disabled"));
3720 err = brcmf_dongle_roam(ndev, (cfg_priv->roam_on ? 0 : 1),
3723 goto default_conf_out;
3724 err = brcmf_dongle_mode(ndev, wdev->iftype);
3725 if (err && err != -EINPROGRESS)
3726 goto default_conf_out;
3727 err = brcmf_dongle_probecap(cfg_priv);
3729 goto default_conf_out;
3731 /* -EINPROGRESS: Call commit handler */
3735 cfg_priv->dongle_up = true;
3741 static int brcmf_debugfs_add_netdev_params(struct brcmf_cfg80211_priv *cfg_priv)
3743 char buf[10+IFNAMSIZ];
3747 sprintf(buf, "netdev:%s", cfg_to_ndev(cfg_priv)->name);
3748 cfg_priv->debugfsdir = debugfs_create_dir(buf,
3749 cfg_to_wiphy(cfg_priv)->debugfsdir);
3751 fd = debugfs_create_u16("beacon_int", S_IRUGO, cfg_priv->debugfsdir,
3752 (u16 *)&cfg_priv->profile->beacon_interval);
3758 fd = debugfs_create_u8("dtim_period", S_IRUGO, cfg_priv->debugfsdir,
3759 (u8 *)&cfg_priv->profile->dtim_period);
3769 static void brcmf_debugfs_remove_netdev(struct brcmf_cfg80211_priv *cfg_priv)
3771 debugfs_remove_recursive(cfg_priv->debugfsdir);
3772 cfg_priv->debugfsdir = NULL;
3775 static s32 __brcmf_cfg80211_up(struct brcmf_cfg80211_priv *cfg_priv)
3779 set_bit(WL_STATUS_READY, &cfg_priv->status);
3781 brcmf_debugfs_add_netdev_params(cfg_priv);
3783 err = brcmf_config_dongle(cfg_priv);
3787 brcmf_invoke_iscan(cfg_priv);
3792 static s32 __brcmf_cfg80211_down(struct brcmf_cfg80211_priv *cfg_priv)
3795 * While going down, if associated with AP disassociate
3796 * from AP to save power
3798 if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
3799 test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
3800 test_bit(WL_STATUS_READY, &cfg_priv->status)) {
3801 WL_INFO("Disassociating from AP");
3802 brcmf_link_down(cfg_priv);
3804 /* Make sure WPA_Supplicant receives all the event
3805 generated due to DISASSOC call to the fw to keep
3806 the state fw and WPA_Supplicant state consistent
3811 set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3812 brcmf_term_iscan(cfg_priv);
3813 if (cfg_priv->scan_request) {
3814 cfg80211_scan_done(cfg_priv->scan_request, true);
3815 /* May need to perform this to cover rmmod */
3816 /* wl_set_mpc(cfg_to_ndev(wl), 1); */
3817 cfg_priv->scan_request = NULL;
3819 clear_bit(WL_STATUS_READY, &cfg_priv->status);
3820 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
3821 clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3823 brcmf_debugfs_remove_netdev(cfg_priv);
3828 s32 brcmf_cfg80211_up(struct brcmf_cfg80211_dev *cfg_dev)
3830 struct brcmf_cfg80211_priv *cfg_priv;
3833 cfg_priv = brcmf_priv_get(cfg_dev);
3834 mutex_lock(&cfg_priv->usr_sync);
3835 err = __brcmf_cfg80211_up(cfg_priv);
3836 mutex_unlock(&cfg_priv->usr_sync);
3841 s32 brcmf_cfg80211_down(struct brcmf_cfg80211_dev *cfg_dev)
3843 struct brcmf_cfg80211_priv *cfg_priv;
3846 cfg_priv = brcmf_priv_get(cfg_dev);
3847 mutex_lock(&cfg_priv->usr_sync);
3848 err = __brcmf_cfg80211_down(cfg_priv);
3849 mutex_unlock(&cfg_priv->usr_sync);
3854 static __used s32 brcmf_add_ie(struct brcmf_cfg80211_priv *cfg_priv,
3857 struct brcmf_cfg80211_ie *ie = &cfg_priv->ie;
3860 if (ie->offset + l + 2 > WL_TLV_INFO_MAX) {
3861 WL_ERR("ei crosses buffer boundary\n");
3864 ie->buf[ie->offset] = t;
3865 ie->buf[ie->offset + 1] = l;
3866 memcpy(&ie->buf[ie->offset + 2], v, l);
3867 ie->offset += l + 2;