?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'v3.3.7' into 3.3/master
[zen-stable.git] / drivers / net / wireless / brcm80211 / brcmfmac / wl_cfg80211.c
blobbf11850a20f11b1201179c7c7659a16397f2d4cc
1 /*
2 * Copyright (c) 2010 Broadcom Corporation
3 *
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.
7 *
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.
15 */
16
17 /* Toplevel file. Relies on dhd_linux.c to send commands to the dongle. */
18
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>
29
30 #include <brcmu_utils.h>
31 #include <defs.h>
32 #include <brcmu_wifi.h>
33 #include "dhd.h"
34 #include "wl_cfg80211.h"
35
36 #define BRCMF_ASSOC_PARAMS_FIXED_SIZE \
37 (sizeof(struct brcmf_assoc_params_le) - sizeof(u16))
38
39 static const u8 ether_bcast[ETH_ALEN] = {255, 255, 255, 255, 255, 255};
40
41 static u32 brcmf_dbg_level = WL_DBG_ERR;
42
43 static void brcmf_set_drvdata(struct brcmf_cfg80211_dev *dev, void *data)
44 {
45 dev->driver_data = data;
46 }
47
48 static void *brcmf_get_drvdata(struct brcmf_cfg80211_dev *dev)
49 {
50 void *data = NULL;
51
52 if (dev)
53 data = dev->driver_data;
54 return data;
55 }
56
57 static
58 struct brcmf_cfg80211_priv *brcmf_priv_get(struct brcmf_cfg80211_dev *cfg_dev)
59 {
60 struct brcmf_cfg80211_iface *ci = brcmf_get_drvdata(cfg_dev);
61 return ci->cfg_priv;
62 }
63
64 static bool check_sys_up(struct wiphy *wiphy)
65 {
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);
70 return false;
71 }
72 return true;
73 }
74
75 #define CHAN2G(_channel, _freq, _flags) { \
76 .band = IEEE80211_BAND_2GHZ, \
77 .center_freq = (_freq), \
78 .hw_value = (_channel), \
79 .flags = (_flags), \
80 .max_antenna_gain = 0, \
81 .max_power = 30, \
82 }
83
84 #define CHAN5G(_channel, _flags) { \
85 .band = IEEE80211_BAND_5GHZ, \
86 .center_freq = 5000 + (5 * (_channel)), \
87 .hw_value = (_channel), \
88 .flags = (_flags), \
89 .max_antenna_gain = 0, \
90 .max_power = 30, \
91 }
92
93 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
94 #define RATETAB_ENT(_rateid, _flags) \
95 { \
96 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
97 .hw_value = (_rateid), \
98 .flags = (_flags), \
99 }
100
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),
114 };
115
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
120
121 static struct ieee80211_channel __wl_2ghz_channels[] = {
122 CHAN2G(1, 2412, 0),
123 CHAN2G(2, 2417, 0),
124 CHAN2G(3, 2422, 0),
125 CHAN2G(4, 2427, 0),
126 CHAN2G(5, 2432, 0),
127 CHAN2G(6, 2437, 0),
128 CHAN2G(7, 2442, 0),
129 CHAN2G(8, 2447, 0),
130 CHAN2G(9, 2452, 0),
131 CHAN2G(10, 2457, 0),
132 CHAN2G(11, 2462, 0),
133 CHAN2G(12, 2467, 0),
134 CHAN2G(13, 2472, 0),
135 CHAN2G(14, 2484, 0),
136 };
137
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),
157 CHAN5G(216, 0),
158 };
159
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),
216 };
217
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,
224 };
225
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,
232 };
233
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,
240 };
241
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,
248 };
249
250 /* tag_ID/length/value_buffer tuple */
251 struct brcmf_tlv {
252 u8 id;
253 u8 len;
254 u8 data[1];
255 };
256
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
260 * a u16.
261 */
262
263 #define QDBM_OFFSET 153 /* Offset for first entry */
264 #define QDBM_TABLE_LEN 40 /* Table size */
265
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
268 */
269 #define QDBM_TABLE_LOW_BOUND 6493 /* Low bound */
270
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.
275 */
276 #define QDBM_TABLE_HIGH_BOUND 64938 /* High bound */
277
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
285 };
286
287 static u16 brcmf_qdbm_to_mw(u8 qdbm)
288 {
289 uint factor = 1;
290 int idx = qdbm - QDBM_OFFSET;
291
292 if (idx >= QDBM_TABLE_LEN)
293 /* clamp to max u16 mW value */
294 return 0xFFFF;
295
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.
298 */
299 while (idx < 0) {
300 idx += 40;
301 factor *= 10;
302 }
303
304 /* return the mW value scaled down to the correct factor of 10,
305 * adding in factor/2 to get proper rounding.
306 */
307 return (nqdBm_to_mW_map[idx] + factor / 2) / factor;
308 }
309
310 static u8 brcmf_mw_to_qdbm(u16 mw)
311 {
312 u8 qdbm;
313 int offset;
314 uint mw_uint = mw;
315 uint boundary;
316
317 /* handle boundary case */
318 if (mw_uint <= 1)
319 return 0;
320
321 offset = QDBM_OFFSET;
322
323 /* move mw into the range of the table */
324 while (mw_uint < QDBM_TABLE_LOW_BOUND) {
325 mw_uint *= 10;
326 offset -= 40;
327 }
328
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)
333 break;
334 }
335
336 qdbm += (u8) offset;
337
338 return qdbm;
339 }
340
341 /* function for reading/writing a single u32 from/to the dongle */
342 static int
343 brcmf_exec_dcmd_u32(struct net_device *ndev, u32 cmd, u32 *par)
344 {
345 int err;
346 __le32 par_le = cpu_to_le32(*par);
347
348 err = brcmf_exec_dcmd(ndev, cmd, &par_le, sizeof(__le32));
349 *par = le32_to_cpu(par_le);
350
351 return err;
352 }
353
354 static void convert_key_from_CPU(struct brcmf_wsec_key *key,
355 struct brcmf_wsec_key_le *key_le)
356 {
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));
366 }
367
368 static int send_key_to_dongle(struct net_device *ndev,
369 struct brcmf_wsec_key *key)
370 {
371 int err;
372 struct brcmf_wsec_key_le key_le;
373
374 convert_key_from_CPU(key, &key_le);
375 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_KEY, &key_le, sizeof(key_le));
376 if (err)
377 WL_ERR("WLC_SET_KEY error (%d)\n", err);
378 return err;
379 }
380
381 static s32
382 brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
383 enum nl80211_iftype type, u32 *flags,
384 struct vif_params *params)
385 {
386 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
387 struct wireless_dev *wdev;
388 s32 infra = 0;
389 s32 err = 0;
390
391 WL_TRACE("Enter\n");
392 if (!check_sys_up(wiphy))
393 return -EIO;
394
395 switch (type) {
396 case NL80211_IFTYPE_MONITOR:
397 case NL80211_IFTYPE_WDS:
398 WL_ERR("type (%d) : currently we do not support this type\n",
399 type);
400 return -EOPNOTSUPP;
401 case NL80211_IFTYPE_ADHOC:
402 cfg_priv->conf->mode = WL_MODE_IBSS;
403 infra = 0;
404 break;
405 case NL80211_IFTYPE_STATION:
406 cfg_priv->conf->mode = WL_MODE_BSS;
407 infra = 1;
408 break;
409 default:
410 err = -EINVAL;
411 goto done;
412 }
413
414 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_INFRA, &infra);
415 if (err) {
416 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
417 err = -EAGAIN;
418 } else {
419 wdev = ndev->ieee80211_ptr;
420 wdev->iftype = type;
421 }
422
423 WL_INFO("IF Type = %s\n",
424 (cfg_priv->conf->mode == WL_MODE_IBSS) ? "Adhoc" : "Infra");
425
426 done:
427 WL_TRACE("Exit\n");
428
429 return err;
430 }
431
432 static s32 brcmf_dev_intvar_set(struct net_device *ndev, s8 *name, s32 val)
433 {
434 s8 buf[BRCMF_DCMD_SMLEN];
435 u32 len;
436 s32 err = 0;
437 __le32 val_le;
438
439 val_le = cpu_to_le32(val);
440 len = brcmf_c_mkiovar(name, (char *)(&val_le), sizeof(val_le), buf,
441 sizeof(buf));
442 BUG_ON(!len);
443
444 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, buf, len);
445 if (err)
446 WL_ERR("error (%d)\n", err);
447
448 return err;
449 }
450
451 static s32
452 brcmf_dev_intvar_get(struct net_device *ndev, s8 *name, s32 *retval)
453 {
454 union {
455 s8 buf[BRCMF_DCMD_SMLEN];
456 __le32 val;
457 } var;
458 u32 len;
459 u32 data_null;
460 s32 err = 0;
461
462 len =
463 brcmf_c_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
464 sizeof(var.buf));
465 BUG_ON(!len);
466 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, &var, len);
467 if (err)
468 WL_ERR("error (%d)\n", err);
469
470 *retval = le32_to_cpu(var.val);
471
472 return err;
473 }
474
475 static void brcmf_set_mpc(struct net_device *ndev, int mpc)
476 {
477 s32 err = 0;
478 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
479
480 if (test_bit(WL_STATUS_READY, &cfg_priv->status)) {
481 err = brcmf_dev_intvar_set(ndev, "mpc", mpc);
482 if (err) {
483 WL_ERR("fail to set mpc\n");
484 return;
485 }
486 WL_INFO("MPC : %d\n", mpc);
487 }
488 }
489
490 static void wl_iscan_prep(struct brcmf_scan_params_le *params_le,
491 struct brcmf_ssid *ssid)
492 {
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 memcpy(&params_le->ssid_le, ssid, sizeof(struct brcmf_ssid));
503 }
504
505 static s32
506 brcmf_dev_iovar_setbuf(struct net_device *ndev, s8 * iovar, void *param,
507 s32 paramlen, void *bufptr, s32 buflen)
508 {
509 s32 iolen;
510
511 iolen = brcmf_c_mkiovar(iovar, param, paramlen, bufptr, buflen);
512 BUG_ON(!iolen);
513
514 return brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, bufptr, iolen);
515 }
516
517 static s32
518 brcmf_dev_iovar_getbuf(struct net_device *ndev, s8 * iovar, void *param,
519 s32 paramlen, void *bufptr, s32 buflen)
520 {
521 s32 iolen;
522
523 iolen = brcmf_c_mkiovar(iovar, param, paramlen, bufptr, buflen);
524 BUG_ON(!iolen);
525
526 return brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, bufptr, buflen);
527 }
528
529 static s32
530 brcmf_run_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan,
531 struct brcmf_ssid *ssid, u16 action)
532 {
533 s32 params_size = BRCMF_SCAN_PARAMS_FIXED_SIZE +
534 offsetof(struct brcmf_iscan_params_le, params_le);
535 struct brcmf_iscan_params_le *params;
536 s32 err = 0;
537
538 if (ssid && ssid->SSID_len)
539 params_size += sizeof(struct brcmf_ssid);
540 params = kzalloc(params_size, GFP_KERNEL);
541 if (!params)
542 return -ENOMEM;
543 BUG_ON(params_size >= BRCMF_DCMD_SMLEN);
544
545 wl_iscan_prep(&params->params_le, ssid);
546
547 params->version = cpu_to_le32(BRCMF_ISCAN_REQ_VERSION);
548 params->action = cpu_to_le16(action);
549 params->scan_duration = cpu_to_le16(0);
550
551 err = brcmf_dev_iovar_setbuf(iscan->ndev, "iscan", params, params_size,
552 iscan->dcmd_buf, BRCMF_DCMD_SMLEN);
553 if (err) {
554 if (err == -EBUSY)
555 WL_INFO("system busy : iscan canceled\n");
556 else
557 WL_ERR("error (%d)\n", err);
558 }
559
560 kfree(params);
561 return err;
562 }
563
564 static s32 brcmf_do_iscan(struct brcmf_cfg80211_priv *cfg_priv)
565 {
566 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
567 struct net_device *ndev = cfg_to_ndev(cfg_priv);
568 struct brcmf_ssid ssid;
569 __le32 passive_scan;
570 s32 err = 0;
571
572 /* Broadcast scan by default */
573 memset(&ssid, 0, sizeof(ssid));
574
575 iscan->state = WL_ISCAN_STATE_SCANING;
576
577 passive_scan = cfg_priv->active_scan ? 0 : cpu_to_le32(1);
578 err = brcmf_exec_dcmd(cfg_to_ndev(cfg_priv), BRCMF_C_SET_PASSIVE_SCAN,
579 &passive_scan, sizeof(passive_scan));
580 if (err) {
581 WL_ERR("error (%d)\n", err);
582 return err;
583 }
584 brcmf_set_mpc(ndev, 0);
585 cfg_priv->iscan_kickstart = true;
586 err = brcmf_run_iscan(iscan, &ssid, BRCMF_SCAN_ACTION_START);
587 if (err) {
588 brcmf_set_mpc(ndev, 1);
589 cfg_priv->iscan_kickstart = false;
590 return err;
591 }
592 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
593 iscan->timer_on = 1;
594 return err;
595 }
596
597 static s32
598 __brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
599 struct cfg80211_scan_request *request,
600 struct cfg80211_ssid *this_ssid)
601 {
602 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
603 struct cfg80211_ssid *ssids;
604 struct brcmf_cfg80211_scan_req *sr = cfg_priv->scan_req_int;
605 __le32 passive_scan;
606 bool iscan_req;
607 bool spec_scan;
608 s32 err = 0;
609 u32 SSID_len;
610
611 if (test_bit(WL_STATUS_SCANNING, &cfg_priv->status)) {
612 WL_ERR("Scanning already : status (%lu)\n", cfg_priv->status);
613 return -EAGAIN;
614 }
615 if (test_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status)) {
616 WL_ERR("Scanning being aborted : status (%lu)\n",
617 cfg_priv->status);
618 return -EAGAIN;
619 }
620 if (test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) {
621 WL_ERR("Connecting : status (%lu)\n",
622 cfg_priv->status);
623 return -EAGAIN;
624 }
625
626 iscan_req = false;
627 spec_scan = false;
628 if (request) {
629 /* scan bss */
630 ssids = request->ssids;
631 if (cfg_priv->iscan_on && (!ssids || !ssids->ssid_len))
632 iscan_req = true;
633 } else {
634 /* scan in ibss */
635 /* we don't do iscan in ibss */
636 ssids = this_ssid;
637 }
638
639 cfg_priv->scan_request = request;
640 set_bit(WL_STATUS_SCANNING, &cfg_priv->status);
641 if (iscan_req) {
642 err = brcmf_do_iscan(cfg_priv);
643 if (!err)
644 return err;
645 else
646 goto scan_out;
647 } else {
648 WL_SCAN("ssid \"%s\", ssid_len (%d)\n",
649 ssids->ssid, ssids->ssid_len);
650 memset(&sr->ssid_le, 0, sizeof(sr->ssid_le));
651 SSID_len = min_t(u8, sizeof(sr->ssid_le.SSID), ssids->ssid_len);
652 sr->ssid_le.SSID_len = cpu_to_le32(0);
653 if (SSID_len) {
654 memcpy(sr->ssid_le.SSID, ssids->ssid, SSID_len);
655 sr->ssid_le.SSID_len = cpu_to_le32(SSID_len);
656 spec_scan = true;
657 } else {
658 WL_SCAN("Broadcast scan\n");
659 }
660
661 passive_scan = cfg_priv->active_scan ? 0 : cpu_to_le32(1);
662 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_PASSIVE_SCAN,
663 &passive_scan, sizeof(passive_scan));
664 if (err) {
665 WL_ERR("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
666 goto scan_out;
667 }
668 brcmf_set_mpc(ndev, 0);
669 err = brcmf_exec_dcmd(ndev, BRCMF_C_SCAN, &sr->ssid_le,
670 sizeof(sr->ssid_le));
671 if (err) {
672 if (err == -EBUSY)
673 WL_INFO("system busy : scan for \"%s\" "
674 "canceled\n", sr->ssid_le.SSID);
675 else
676 WL_ERR("WLC_SCAN error (%d)\n", err);
677
678 brcmf_set_mpc(ndev, 1);
679 goto scan_out;
680 }
681 }
682
683 return 0;
684
685 scan_out:
686 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
687 cfg_priv->scan_request = NULL;
688 return err;
689 }
690
691 static s32
692 brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
693 struct cfg80211_scan_request *request)
694 {
695 s32 err = 0;
696
697 WL_TRACE("Enter\n");
698
699 if (!check_sys_up(wiphy))
700 return -EIO;
701
702 err = __brcmf_cfg80211_scan(wiphy, ndev, request, NULL);
703 if (err)
704 WL_ERR("scan error (%d)\n", err);
705
706 WL_TRACE("Exit\n");
707 return err;
708 }
709
710 static s32 brcmf_set_rts(struct net_device *ndev, u32 rts_threshold)
711 {
712 s32 err = 0;
713
714 err = brcmf_dev_intvar_set(ndev, "rtsthresh", rts_threshold);
715 if (err)
716 WL_ERR("Error (%d)\n", err);
717
718 return err;
719 }
720
721 static s32 brcmf_set_frag(struct net_device *ndev, u32 frag_threshold)
722 {
723 s32 err = 0;
724
725 err = brcmf_dev_intvar_set(ndev, "fragthresh", frag_threshold);
726 if (err)
727 WL_ERR("Error (%d)\n", err);
728
729 return err;
730 }
731
732 static s32 brcmf_set_retry(struct net_device *ndev, u32 retry, bool l)
733 {
734 s32 err = 0;
735 u32 cmd = (l ? BRCM_SET_LRL : BRCM_SET_SRL);
736
737 err = brcmf_exec_dcmd_u32(ndev, cmd, &retry);
738 if (err) {
739 WL_ERR("cmd (%d) , error (%d)\n", cmd, err);
740 return err;
741 }
742 return err;
743 }
744
745 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
746 {
747 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
748 struct net_device *ndev = cfg_to_ndev(cfg_priv);
749 s32 err = 0;
750
751 WL_TRACE("Enter\n");
752 if (!check_sys_up(wiphy))
753 return -EIO;
754
755 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
756 (cfg_priv->conf->rts_threshold != wiphy->rts_threshold)) {
757 cfg_priv->conf->rts_threshold = wiphy->rts_threshold;
758 err = brcmf_set_rts(ndev, cfg_priv->conf->rts_threshold);
759 if (!err)
760 goto done;
761 }
762 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
763 (cfg_priv->conf->frag_threshold != wiphy->frag_threshold)) {
764 cfg_priv->conf->frag_threshold = wiphy->frag_threshold;
765 err = brcmf_set_frag(ndev, cfg_priv->conf->frag_threshold);
766 if (!err)
767 goto done;
768 }
769 if (changed & WIPHY_PARAM_RETRY_LONG
770 && (cfg_priv->conf->retry_long != wiphy->retry_long)) {
771 cfg_priv->conf->retry_long = wiphy->retry_long;
772 err = brcmf_set_retry(ndev, cfg_priv->conf->retry_long, true);
773 if (!err)
774 goto done;
775 }
776 if (changed & WIPHY_PARAM_RETRY_SHORT
777 && (cfg_priv->conf->retry_short != wiphy->retry_short)) {
778 cfg_priv->conf->retry_short = wiphy->retry_short;
779 err = brcmf_set_retry(ndev, cfg_priv->conf->retry_short, false);
780 if (!err)
781 goto done;
782 }
783
784 done:
785 WL_TRACE("Exit\n");
786 return err;
787 }
788
789 static void *brcmf_read_prof(struct brcmf_cfg80211_priv *cfg_priv, s32 item)
790 {
791 switch (item) {
792 case WL_PROF_SEC:
793 return &cfg_priv->profile->sec;
794 case WL_PROF_BSSID:
795 return &cfg_priv->profile->bssid;
796 case WL_PROF_SSID:
797 return &cfg_priv->profile->ssid;
798 }
799 WL_ERR("invalid item (%d)\n", item);
800 return NULL;
801 }
802
803 static s32
804 brcmf_update_prof(struct brcmf_cfg80211_priv *cfg_priv,
805 const struct brcmf_event_msg *e, void *data, s32 item)
806 {
807 s32 err = 0;
808 struct brcmf_ssid *ssid;
809
810 switch (item) {
811 case WL_PROF_SSID:
812 ssid = (struct brcmf_ssid *) data;
813 memset(cfg_priv->profile->ssid.SSID, 0,
814 sizeof(cfg_priv->profile->ssid.SSID));
815 memcpy(cfg_priv->profile->ssid.SSID,
816 ssid->SSID, ssid->SSID_len);
817 cfg_priv->profile->ssid.SSID_len = ssid->SSID_len;
818 break;
819 case WL_PROF_BSSID:
820 if (data)
821 memcpy(cfg_priv->profile->bssid, data, ETH_ALEN);
822 else
823 memset(cfg_priv->profile->bssid, 0, ETH_ALEN);
824 break;
825 case WL_PROF_SEC:
826 memcpy(&cfg_priv->profile->sec, data,
827 sizeof(cfg_priv->profile->sec));
828 break;
829 case WL_PROF_BEACONINT:
830 cfg_priv->profile->beacon_interval = *(u16 *)data;
831 break;
832 case WL_PROF_DTIMPERIOD:
833 cfg_priv->profile->dtim_period = *(u8 *)data;
834 break;
835 default:
836 WL_ERR("unsupported item (%d)\n", item);
837 err = -EOPNOTSUPP;
838 break;
839 }
840
841 return err;
842 }
843
844 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
845 {
846 memset(prof, 0, sizeof(*prof));
847 }
848
849 static void brcmf_ch_to_chanspec(int ch, struct brcmf_join_params *join_params,
850 size_t *join_params_size)
851 {
852 u16 chanspec = 0;
853
854 if (ch != 0) {
855 if (ch <= CH_MAX_2G_CHANNEL)
856 chanspec |= WL_CHANSPEC_BAND_2G;
857 else
858 chanspec |= WL_CHANSPEC_BAND_5G;
859
860 chanspec |= WL_CHANSPEC_BW_20;
861 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
862
863 *join_params_size += BRCMF_ASSOC_PARAMS_FIXED_SIZE +
864 sizeof(u16);
865
866 chanspec |= (ch & WL_CHANSPEC_CHAN_MASK);
867 join_params->params_le.chanspec_list[0] = cpu_to_le16(chanspec);
868 join_params->params_le.chanspec_num = cpu_to_le32(1);
869
870 WL_CONN("join_params->params.chanspec_list[0]= %#X,"
871 "channel %d, chanspec %#X\n",
872 chanspec, ch, chanspec);
873 }
874 }
875
876 static void brcmf_link_down(struct brcmf_cfg80211_priv *cfg_priv)
877 {
878 struct net_device *ndev = NULL;
879 s32 err = 0;
880
881 WL_TRACE("Enter\n");
882
883 if (cfg_priv->link_up) {
884 ndev = cfg_to_ndev(cfg_priv);
885 WL_INFO("Call WLC_DISASSOC to stop excess roaming\n ");
886 err = brcmf_exec_dcmd(ndev, BRCMF_C_DISASSOC, NULL, 0);
887 if (err)
888 WL_ERR("WLC_DISASSOC failed (%d)\n", err);
889 cfg_priv->link_up = false;
890 }
891 WL_TRACE("Exit\n");
892 }
893
894 static s32
895 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
896 struct cfg80211_ibss_params *params)
897 {
898 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
899 struct brcmf_join_params join_params;
900 size_t join_params_size = 0;
901 s32 err = 0;
902 s32 wsec = 0;
903 s32 bcnprd;
904 struct brcmf_ssid ssid;
905
906 WL_TRACE("Enter\n");
907 if (!check_sys_up(wiphy))
908 return -EIO;
909
910 if (params->ssid)
911 WL_CONN("SSID: %s\n", params->ssid);
912 else {
913 WL_CONN("SSID: NULL, Not supported\n");
914 return -EOPNOTSUPP;
915 }
916
917 set_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
918
919 if (params->bssid)
920 WL_CONN("BSSID: %02X %02X %02X %02X %02X %02X\n",
921 params->bssid[0], params->bssid[1], params->bssid[2],
922 params->bssid[3], params->bssid[4], params->bssid[5]);
923 else
924 WL_CONN("No BSSID specified\n");
925
926 if (params->channel)
927 WL_CONN("channel: %d\n", params->channel->center_freq);
928 else
929 WL_CONN("no channel specified\n");
930
931 if (params->channel_fixed)
932 WL_CONN("fixed channel required\n");
933 else
934 WL_CONN("no fixed channel required\n");
935
936 if (params->ie && params->ie_len)
937 WL_CONN("ie len: %d\n", params->ie_len);
938 else
939 WL_CONN("no ie specified\n");
940
941 if (params->beacon_interval)
942 WL_CONN("beacon interval: %d\n", params->beacon_interval);
943 else
944 WL_CONN("no beacon interval specified\n");
945
946 if (params->basic_rates)
947 WL_CONN("basic rates: %08X\n", params->basic_rates);
948 else
949 WL_CONN("no basic rates specified\n");
950
951 if (params->privacy)
952 WL_CONN("privacy required\n");
953 else
954 WL_CONN("no privacy required\n");
955
956 /* Configure Privacy for starter */
957 if (params->privacy)
958 wsec |= WEP_ENABLED;
959
960 err = brcmf_dev_intvar_set(ndev, "wsec", wsec);
961 if (err) {
962 WL_ERR("wsec failed (%d)\n", err);
963 goto done;
964 }
965
966 /* Configure Beacon Interval for starter */
967 if (params->beacon_interval)
968 bcnprd = params->beacon_interval;
969 else
970 bcnprd = 100;
971
972 err = brcmf_exec_dcmd_u32(ndev, BRCM_SET_BCNPRD, &bcnprd);
973 if (err) {
974 WL_ERR("WLC_SET_BCNPRD failed (%d)\n", err);
975 goto done;
976 }
977
978 /* Configure required join parameter */
979 memset(&join_params, 0, sizeof(struct brcmf_join_params));
980
981 /* SSID */
982 ssid.SSID_len = min_t(u32, params->ssid_len, 32);
983 memcpy(ssid.SSID, params->ssid, ssid.SSID_len);
984 memcpy(join_params.ssid_le.SSID, params->ssid, ssid.SSID_len);
985 join_params.ssid_le.SSID_len = cpu_to_le32(ssid.SSID_len);
986 join_params_size = sizeof(join_params.ssid_le);
987 brcmf_update_prof(cfg_priv, NULL, &ssid, WL_PROF_SSID);
988
989 /* BSSID */
990 if (params->bssid) {
991 memcpy(join_params.params_le.bssid, params->bssid, ETH_ALEN);
992 join_params_size = sizeof(join_params.ssid_le) +
993 BRCMF_ASSOC_PARAMS_FIXED_SIZE;
994 } else {
995 memcpy(join_params.params_le.bssid, ether_bcast, ETH_ALEN);
996 }
997
998 brcmf_update_prof(cfg_priv, NULL,
999 &join_params.params_le.bssid, WL_PROF_BSSID);
1000
1001 /* Channel */
1002 if (params->channel) {
1003 u32 target_channel;
1004
1005 cfg_priv->channel =
1006 ieee80211_frequency_to_channel(
1007 params->channel->center_freq);
1008 if (params->channel_fixed) {
1009 /* adding chanspec */
1010 brcmf_ch_to_chanspec(cfg_priv->channel,
1011 &join_params, &join_params_size);
1012 }
1013
1014 /* set channel for starter */
1015 target_channel = cfg_priv->channel;
1016 err = brcmf_exec_dcmd_u32(ndev, BRCM_SET_CHANNEL,
1017 &target_channel);
1018 if (err) {
1019 WL_ERR("WLC_SET_CHANNEL failed (%d)\n", err);
1020 goto done;
1021 }
1022 } else
1023 cfg_priv->channel = 0;
1024
1025 cfg_priv->ibss_starter = false;
1026
1027
1028 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SSID,
1029 &join_params, join_params_size);
1030 if (err) {
1031 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1032 goto done;
1033 }
1034
1035 done:
1036 if (err)
1037 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1038 WL_TRACE("Exit\n");
1039 return err;
1040 }
1041
1042 static s32
1043 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
1044 {
1045 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1046 s32 err = 0;
1047
1048 WL_TRACE("Enter\n");
1049 if (!check_sys_up(wiphy))
1050 return -EIO;
1051
1052 brcmf_link_down(cfg_priv);
1053
1054 WL_TRACE("Exit\n");
1055
1056 return err;
1057 }
1058
1059 static s32 brcmf_set_wpa_version(struct net_device *ndev,
1060 struct cfg80211_connect_params *sme)
1061 {
1062 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1063 struct brcmf_cfg80211_security *sec;
1064 s32 val = 0;
1065 s32 err = 0;
1066
1067 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1068 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1069 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1070 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1071 else
1072 val = WPA_AUTH_DISABLED;
1073 WL_CONN("setting wpa_auth to 0x%0x\n", val);
1074 err = brcmf_dev_intvar_set(ndev, "wpa_auth", val);
1075 if (err) {
1076 WL_ERR("set wpa_auth failed (%d)\n", err);
1077 return err;
1078 }
1079 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1080 sec->wpa_versions = sme->crypto.wpa_versions;
1081 return err;
1082 }
1083
1084 static s32 brcmf_set_auth_type(struct net_device *ndev,
1085 struct cfg80211_connect_params *sme)
1086 {
1087 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1088 struct brcmf_cfg80211_security *sec;
1089 s32 val = 0;
1090 s32 err = 0;
1091
1092 switch (sme->auth_type) {
1093 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1094 val = 0;
1095 WL_CONN("open system\n");
1096 break;
1097 case NL80211_AUTHTYPE_SHARED_KEY:
1098 val = 1;
1099 WL_CONN("shared key\n");
1100 break;
1101 case NL80211_AUTHTYPE_AUTOMATIC:
1102 val = 2;
1103 WL_CONN("automatic\n");
1104 break;
1105 case NL80211_AUTHTYPE_NETWORK_EAP:
1106 WL_CONN("network eap\n");
1107 default:
1108 val = 2;
1109 WL_ERR("invalid auth type (%d)\n", sme->auth_type);
1110 break;
1111 }
1112
1113 err = brcmf_dev_intvar_set(ndev, "auth", val);
1114 if (err) {
1115 WL_ERR("set auth failed (%d)\n", err);
1116 return err;
1117 }
1118 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1119 sec->auth_type = sme->auth_type;
1120 return err;
1121 }
1122
1123 static s32
1124 brcmf_set_set_cipher(struct net_device *ndev,
1125 struct cfg80211_connect_params *sme)
1126 {
1127 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1128 struct brcmf_cfg80211_security *sec;
1129 s32 pval = 0;
1130 s32 gval = 0;
1131 s32 err = 0;
1132
1133 if (sme->crypto.n_ciphers_pairwise) {
1134 switch (sme->crypto.ciphers_pairwise[0]) {
1135 case WLAN_CIPHER_SUITE_WEP40:
1136 case WLAN_CIPHER_SUITE_WEP104:
1137 pval = WEP_ENABLED;
1138 break;
1139 case WLAN_CIPHER_SUITE_TKIP:
1140 pval = TKIP_ENABLED;
1141 break;
1142 case WLAN_CIPHER_SUITE_CCMP:
1143 pval = AES_ENABLED;
1144 break;
1145 case WLAN_CIPHER_SUITE_AES_CMAC:
1146 pval = AES_ENABLED;
1147 break;
1148 default:
1149 WL_ERR("invalid cipher pairwise (%d)\n",
1150 sme->crypto.ciphers_pairwise[0]);
1151 return -EINVAL;
1152 }
1153 }
1154 if (sme->crypto.cipher_group) {
1155 switch (sme->crypto.cipher_group) {
1156 case WLAN_CIPHER_SUITE_WEP40:
1157 case WLAN_CIPHER_SUITE_WEP104:
1158 gval = WEP_ENABLED;
1159 break;
1160 case WLAN_CIPHER_SUITE_TKIP:
1161 gval = TKIP_ENABLED;
1162 break;
1163 case WLAN_CIPHER_SUITE_CCMP:
1164 gval = AES_ENABLED;
1165 break;
1166 case WLAN_CIPHER_SUITE_AES_CMAC:
1167 gval = AES_ENABLED;
1168 break;
1169 default:
1170 WL_ERR("invalid cipher group (%d)\n",
1171 sme->crypto.cipher_group);
1172 return -EINVAL;
1173 }
1174 }
1175
1176 WL_CONN("pval (%d) gval (%d)\n", pval, gval);
1177 err = brcmf_dev_intvar_set(ndev, "wsec", pval | gval);
1178 if (err) {
1179 WL_ERR("error (%d)\n", err);
1180 return err;
1181 }
1182
1183 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1184 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1185 sec->cipher_group = sme->crypto.cipher_group;
1186
1187 return err;
1188 }
1189
1190 static s32
1191 brcmf_set_key_mgmt(struct net_device *ndev, struct cfg80211_connect_params *sme)
1192 {
1193 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1194 struct brcmf_cfg80211_security *sec;
1195 s32 val = 0;
1196 s32 err = 0;
1197
1198 if (sme->crypto.n_akm_suites) {
1199 err = brcmf_dev_intvar_get(ndev, "wpa_auth", &val);
1200 if (err) {
1201 WL_ERR("could not get wpa_auth (%d)\n", err);
1202 return err;
1203 }
1204 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1205 switch (sme->crypto.akm_suites[0]) {
1206 case WLAN_AKM_SUITE_8021X:
1207 val = WPA_AUTH_UNSPECIFIED;
1208 break;
1209 case WLAN_AKM_SUITE_PSK:
1210 val = WPA_AUTH_PSK;
1211 break;
1212 default:
1213 WL_ERR("invalid cipher group (%d)\n",
1214 sme->crypto.cipher_group);
1215 return -EINVAL;
1216 }
1217 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1218 switch (sme->crypto.akm_suites[0]) {
1219 case WLAN_AKM_SUITE_8021X:
1220 val = WPA2_AUTH_UNSPECIFIED;
1221 break;
1222 case WLAN_AKM_SUITE_PSK:
1223 val = WPA2_AUTH_PSK;
1224 break;
1225 default:
1226 WL_ERR("invalid cipher group (%d)\n",
1227 sme->crypto.cipher_group);
1228 return -EINVAL;
1229 }
1230 }
1231
1232 WL_CONN("setting wpa_auth to %d\n", val);
1233 err = brcmf_dev_intvar_set(ndev, "wpa_auth", val);
1234 if (err) {
1235 WL_ERR("could not set wpa_auth (%d)\n", err);
1236 return err;
1237 }
1238 }
1239 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1240 sec->wpa_auth = sme->crypto.akm_suites[0];
1241
1242 return err;
1243 }
1244
1245 static s32
1246 brcmf_set_wep_sharedkey(struct net_device *ndev,
1247 struct cfg80211_connect_params *sme)
1248 {
1249 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
1250 struct brcmf_cfg80211_security *sec;
1251 struct brcmf_wsec_key key;
1252 s32 val;
1253 s32 err = 0;
1254
1255 WL_CONN("key len (%d)\n", sme->key_len);
1256
1257 if (sme->key_len == 0)
1258 return 0;
1259
1260 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1261 WL_CONN("wpa_versions 0x%x cipher_pairwise 0x%x\n",
1262 sec->wpa_versions, sec->cipher_pairwise);
1263
1264 if (sec->wpa_versions & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2))
1265 return 0;
1266
1267 if (sec->cipher_pairwise &
1268 (WLAN_CIPHER_SUITE_WEP40 | WLAN_CIPHER_SUITE_WEP104)) {
1269 memset(&key, 0, sizeof(key));
1270 key.len = (u32) sme->key_len;
1271 key.index = (u32) sme->key_idx;
1272 if (key.len > sizeof(key.data)) {
1273 WL_ERR("Too long key length (%u)\n", key.len);
1274 return -EINVAL;
1275 }
1276 memcpy(key.data, sme->key, key.len);
1277 key.flags = BRCMF_PRIMARY_KEY;
1278 switch (sec->cipher_pairwise) {
1279 case WLAN_CIPHER_SUITE_WEP40:
1280 key.algo = CRYPTO_ALGO_WEP1;
1281 break;
1282 case WLAN_CIPHER_SUITE_WEP104:
1283 key.algo = CRYPTO_ALGO_WEP128;
1284 break;
1285 default:
1286 WL_ERR("Invalid algorithm (%d)\n",
1287 sme->crypto.ciphers_pairwise[0]);
1288 return -EINVAL;
1289 }
1290 /* Set the new key/index */
1291 WL_CONN("key length (%d) key index (%d) algo (%d)\n",
1292 key.len, key.index, key.algo);
1293 WL_CONN("key \"%s\"\n", key.data);
1294 err = send_key_to_dongle(ndev, &key);
1295 if (err)
1296 return err;
1297
1298 if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
1299 WL_CONN("set auth_type to shared key\n");
1300 val = 1; /* shared key */
1301 err = brcmf_dev_intvar_set(ndev, "auth", val);
1302 if (err) {
1303 WL_ERR("set auth failed (%d)\n", err);
1304 return err;
1305 }
1306 }
1307 }
1308 return err;
1309 }
1310
1311 static s32
1312 brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *ndev,
1313 struct cfg80211_connect_params *sme)
1314 {
1315 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1316 struct ieee80211_channel *chan = sme->channel;
1317 struct brcmf_join_params join_params;
1318 size_t join_params_size;
1319 struct brcmf_ssid ssid;
1320
1321 s32 err = 0;
1322
1323 WL_TRACE("Enter\n");
1324 if (!check_sys_up(wiphy))
1325 return -EIO;
1326
1327 if (!sme->ssid) {
1328 WL_ERR("Invalid ssid\n");
1329 return -EOPNOTSUPP;
1330 }
1331
1332 set_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1333
1334 if (chan) {
1335 cfg_priv->channel =
1336 ieee80211_frequency_to_channel(chan->center_freq);
1337 WL_CONN("channel (%d), center_req (%d)\n",
1338 cfg_priv->channel, chan->center_freq);
1339 } else
1340 cfg_priv->channel = 0;
1341
1342 WL_INFO("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1343
1344 err = brcmf_set_wpa_version(ndev, sme);
1345 if (err) {
1346 WL_ERR("wl_set_wpa_version failed (%d)\n", err);
1347 goto done;
1348 }
1349
1350 err = brcmf_set_auth_type(ndev, sme);
1351 if (err) {
1352 WL_ERR("wl_set_auth_type failed (%d)\n", err);
1353 goto done;
1354 }
1355
1356 err = brcmf_set_set_cipher(ndev, sme);
1357 if (err) {
1358 WL_ERR("wl_set_set_cipher failed (%d)\n", err);
1359 goto done;
1360 }
1361
1362 err = brcmf_set_key_mgmt(ndev, sme);
1363 if (err) {
1364 WL_ERR("wl_set_key_mgmt failed (%d)\n", err);
1365 goto done;
1366 }
1367
1368 err = brcmf_set_wep_sharedkey(ndev, sme);
1369 if (err) {
1370 WL_ERR("brcmf_set_wep_sharedkey failed (%d)\n", err);
1371 goto done;
1372 }
1373
1374 memset(&join_params, 0, sizeof(join_params));
1375 join_params_size = sizeof(join_params.ssid_le);
1376
1377 ssid.SSID_len = min_t(u32, sizeof(ssid.SSID), sme->ssid_len);
1378 memcpy(&join_params.ssid_le.SSID, sme->ssid, ssid.SSID_len);
1379 memcpy(&ssid.SSID, sme->ssid, ssid.SSID_len);
1380 join_params.ssid_le.SSID_len = cpu_to_le32(ssid.SSID_len);
1381 brcmf_update_prof(cfg_priv, NULL, &ssid, WL_PROF_SSID);
1382
1383 memcpy(join_params.params_le.bssid, ether_bcast, ETH_ALEN);
1384
1385 if (ssid.SSID_len < IEEE80211_MAX_SSID_LEN)
1386 WL_CONN("ssid \"%s\", len (%d)\n",
1387 ssid.SSID, ssid.SSID_len);
1388
1389 brcmf_ch_to_chanspec(cfg_priv->channel,
1390 &join_params, &join_params_size);
1391 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SSID,
1392 &join_params, join_params_size);
1393 if (err)
1394 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1395
1396 done:
1397 if (err)
1398 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1399 WL_TRACE("Exit\n");
1400 return err;
1401 }
1402
1403 static s32
1404 brcmf_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *ndev,
1405 u16 reason_code)
1406 {
1407 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1408 struct brcmf_scb_val_le scbval;
1409 s32 err = 0;
1410
1411 WL_TRACE("Enter. Reason code = %d\n", reason_code);
1412 if (!check_sys_up(wiphy))
1413 return -EIO;
1414
1415 clear_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
1416
1417 memcpy(&scbval.ea, brcmf_read_prof(cfg_priv, WL_PROF_BSSID), ETH_ALEN);
1418 scbval.val = cpu_to_le32(reason_code);
1419 err = brcmf_exec_dcmd(ndev, BRCMF_C_DISASSOC, &scbval,
1420 sizeof(struct brcmf_scb_val_le));
1421 if (err)
1422 WL_ERR("error (%d)\n", err);
1423
1424 cfg_priv->link_up = false;
1425
1426 WL_TRACE("Exit\n");
1427 return err;
1428 }
1429
1430 static s32
1431 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy,
1432 enum nl80211_tx_power_setting type, s32 mbm)
1433 {
1434
1435 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1436 struct net_device *ndev = cfg_to_ndev(cfg_priv);
1437 u16 txpwrmw;
1438 s32 err = 0;
1439 s32 disable = 0;
1440 s32 dbm = MBM_TO_DBM(mbm);
1441
1442 WL_TRACE("Enter\n");
1443 if (!check_sys_up(wiphy))
1444 return -EIO;
1445
1446 switch (type) {
1447 case NL80211_TX_POWER_AUTOMATIC:
1448 break;
1449 case NL80211_TX_POWER_LIMITED:
1450 case NL80211_TX_POWER_FIXED:
1451 if (dbm < 0) {
1452 WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1453 err = -EINVAL;
1454 goto done;
1455 }
1456 break;
1457 }
1458 /* Make sure radio is off or on as far as software is concerned */
1459 disable = WL_RADIO_SW_DISABLE << 16;
1460 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_RADIO, &disable);
1461 if (err)
1462 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1463
1464 if (dbm > 0xffff)
1465 txpwrmw = 0xffff;
1466 else
1467 txpwrmw = (u16) dbm;
1468 err = brcmf_dev_intvar_set(ndev, "qtxpower",
1469 (s32) (brcmf_mw_to_qdbm(txpwrmw)));
1470 if (err)
1471 WL_ERR("qtxpower error (%d)\n", err);
1472 cfg_priv->conf->tx_power = dbm;
1473
1474 done:
1475 WL_TRACE("Exit\n");
1476 return err;
1477 }
1478
1479 static s32 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1480 {
1481 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1482 struct net_device *ndev = cfg_to_ndev(cfg_priv);
1483 s32 txpwrdbm;
1484 u8 result;
1485 s32 err = 0;
1486
1487 WL_TRACE("Enter\n");
1488 if (!check_sys_up(wiphy))
1489 return -EIO;
1490
1491 err = brcmf_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1492 if (err) {
1493 WL_ERR("error (%d)\n", err);
1494 goto done;
1495 }
1496
1497 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1498 *dbm = (s32) brcmf_qdbm_to_mw(result);
1499
1500 done:
1501 WL_TRACE("Exit\n");
1502 return err;
1503 }
1504
1505 static s32
1506 brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *ndev,
1507 u8 key_idx, bool unicast, bool multicast)
1508 {
1509 u32 index;
1510 u32 wsec;
1511 s32 err = 0;
1512
1513 WL_TRACE("Enter\n");
1514 WL_CONN("key index (%d)\n", key_idx);
1515 if (!check_sys_up(wiphy))
1516 return -EIO;
1517
1518 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_GET_WSEC, &wsec);
1519 if (err) {
1520 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1521 goto done;
1522 }
1523
1524 if (wsec & WEP_ENABLED) {
1525 /* Just select a new current key */
1526 index = key_idx;
1527 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_KEY_PRIMARY,
1528 &index);
1529 if (err)
1530 WL_ERR("error (%d)\n", err);
1531 }
1532 done:
1533 WL_TRACE("Exit\n");
1534 return err;
1535 }
1536
1537 static s32
1538 brcmf_add_keyext(struct wiphy *wiphy, struct net_device *ndev,
1539 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1540 {
1541 struct brcmf_wsec_key key;
1542 struct brcmf_wsec_key_le key_le;
1543 s32 err = 0;
1544
1545 memset(&key, 0, sizeof(key));
1546 key.index = (u32) key_idx;
1547 /* Instead of bcast for ea address for default wep keys,
1548 driver needs it to be Null */
1549 if (!is_multicast_ether_addr(mac_addr))
1550 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1551 key.len = (u32) params->key_len;
1552 /* check for key index change */
1553 if (key.len == 0) {
1554 /* key delete */
1555 err = send_key_to_dongle(ndev, &key);
1556 if (err)
1557 return err;
1558 } else {
1559 if (key.len > sizeof(key.data)) {
1560 WL_ERR("Invalid key length (%d)\n", key.len);
1561 return -EINVAL;
1562 }
1563
1564 WL_CONN("Setting the key index %d\n", key.index);
1565 memcpy(key.data, params->key, key.len);
1566
1567 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1568 u8 keybuf[8];
1569 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1570 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1571 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1572 }
1573
1574 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1575 if (params->seq && params->seq_len == 6) {
1576 /* rx iv */
1577 u8 *ivptr;
1578 ivptr = (u8 *) params->seq;
1579 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1580 (ivptr[3] << 8) | ivptr[2];
1581 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1582 key.iv_initialized = true;
1583 }
1584
1585 switch (params->cipher) {
1586 case WLAN_CIPHER_SUITE_WEP40:
1587 key.algo = CRYPTO_ALGO_WEP1;
1588 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1589 break;
1590 case WLAN_CIPHER_SUITE_WEP104:
1591 key.algo = CRYPTO_ALGO_WEP128;
1592 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1593 break;
1594 case WLAN_CIPHER_SUITE_TKIP:
1595 key.algo = CRYPTO_ALGO_TKIP;
1596 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1597 break;
1598 case WLAN_CIPHER_SUITE_AES_CMAC:
1599 key.algo = CRYPTO_ALGO_AES_CCM;
1600 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1601 break;
1602 case WLAN_CIPHER_SUITE_CCMP:
1603 key.algo = CRYPTO_ALGO_AES_CCM;
1604 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1605 break;
1606 default:
1607 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1608 return -EINVAL;
1609 }
1610 convert_key_from_CPU(&key, &key_le);
1611
1612 brcmf_netdev_wait_pend8021x(ndev);
1613 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_KEY, &key_le,
1614 sizeof(key_le));
1615 if (err) {
1616 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1617 return err;
1618 }
1619 }
1620 return err;
1621 }
1622
1623 static s32
1624 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
1625 u8 key_idx, bool pairwise, const u8 *mac_addr,
1626 struct key_params *params)
1627 {
1628 struct brcmf_wsec_key key;
1629 s32 val;
1630 s32 wsec;
1631 s32 err = 0;
1632 u8 keybuf[8];
1633
1634 WL_TRACE("Enter\n");
1635 WL_CONN("key index (%d)\n", key_idx);
1636 if (!check_sys_up(wiphy))
1637 return -EIO;
1638
1639 if (mac_addr) {
1640 WL_TRACE("Exit");
1641 return brcmf_add_keyext(wiphy, ndev, key_idx, mac_addr, params);
1642 }
1643 memset(&key, 0, sizeof(key));
1644
1645 key.len = (u32) params->key_len;
1646 key.index = (u32) key_idx;
1647
1648 if (key.len > sizeof(key.data)) {
1649 WL_ERR("Too long key length (%u)\n", key.len);
1650 err = -EINVAL;
1651 goto done;
1652 }
1653 memcpy(key.data, params->key, key.len);
1654
1655 key.flags = BRCMF_PRIMARY_KEY;
1656 switch (params->cipher) {
1657 case WLAN_CIPHER_SUITE_WEP40:
1658 key.algo = CRYPTO_ALGO_WEP1;
1659 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1660 break;
1661 case WLAN_CIPHER_SUITE_WEP104:
1662 key.algo = CRYPTO_ALGO_WEP128;
1663 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1664 break;
1665 case WLAN_CIPHER_SUITE_TKIP:
1666 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1667 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1668 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1669 key.algo = CRYPTO_ALGO_TKIP;
1670 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1671 break;
1672 case WLAN_CIPHER_SUITE_AES_CMAC:
1673 key.algo = CRYPTO_ALGO_AES_CCM;
1674 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1675 break;
1676 case WLAN_CIPHER_SUITE_CCMP:
1677 key.algo = CRYPTO_ALGO_AES_CCM;
1678 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1679 break;
1680 default:
1681 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1682 err = -EINVAL;
1683 goto done;
1684 }
1685
1686 err = send_key_to_dongle(ndev, &key); /* Set the new key/index */
1687 if (err)
1688 goto done;
1689
1690 val = WEP_ENABLED;
1691 err = brcmf_dev_intvar_get(ndev, "wsec", &wsec);
1692 if (err) {
1693 WL_ERR("get wsec error (%d)\n", err);
1694 goto done;
1695 }
1696 wsec &= ~(WEP_ENABLED);
1697 wsec |= val;
1698 err = brcmf_dev_intvar_set(ndev, "wsec", wsec);
1699 if (err) {
1700 WL_ERR("set wsec error (%d)\n", err);
1701 goto done;
1702 }
1703
1704 val = 1; /* assume shared key. otherwise 0 */
1705 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_AUTH, &val);
1706 if (err)
1707 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1708 done:
1709 WL_TRACE("Exit\n");
1710 return err;
1711 }
1712
1713 static s32
1714 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
1715 u8 key_idx, bool pairwise, const u8 *mac_addr)
1716 {
1717 struct brcmf_wsec_key key;
1718 s32 err = 0;
1719 s32 val;
1720 s32 wsec;
1721
1722 WL_TRACE("Enter\n");
1723 if (!check_sys_up(wiphy))
1724 return -EIO;
1725
1726 memset(&key, 0, sizeof(key));
1727
1728 key.index = (u32) key_idx;
1729 key.flags = BRCMF_PRIMARY_KEY;
1730 key.algo = CRYPTO_ALGO_OFF;
1731
1732 WL_CONN("key index (%d)\n", key_idx);
1733
1734 /* Set the new key/index */
1735 err = send_key_to_dongle(ndev, &key);
1736 if (err) {
1737 if (err == -EINVAL) {
1738 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
1739 /* we ignore this key index in this case */
1740 WL_ERR("invalid key index (%d)\n", key_idx);
1741 }
1742 /* Ignore this error, may happen during DISASSOC */
1743 err = -EAGAIN;
1744 goto done;
1745 }
1746
1747 val = 0;
1748 err = brcmf_dev_intvar_get(ndev, "wsec", &wsec);
1749 if (err) {
1750 WL_ERR("get wsec error (%d)\n", err);
1751 /* Ignore this error, may happen during DISASSOC */
1752 err = -EAGAIN;
1753 goto done;
1754 }
1755 wsec &= ~(WEP_ENABLED);
1756 wsec |= val;
1757 err = brcmf_dev_intvar_set(ndev, "wsec", wsec);
1758 if (err) {
1759 WL_ERR("set wsec error (%d)\n", err);
1760 /* Ignore this error, may happen during DISASSOC */
1761 err = -EAGAIN;
1762 goto done;
1763 }
1764
1765 val = 0; /* assume open key. otherwise 1 */
1766 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_AUTH, &val);
1767 if (err) {
1768 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1769 /* Ignore this error, may happen during DISASSOC */
1770 err = -EAGAIN;
1771 }
1772 done:
1773 WL_TRACE("Exit\n");
1774 return err;
1775 }
1776
1777 static s32
1778 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
1779 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1780 void (*callback) (void *cookie, struct key_params * params))
1781 {
1782 struct key_params params;
1783 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1784 struct brcmf_cfg80211_security *sec;
1785 s32 wsec;
1786 s32 err = 0;
1787
1788 WL_TRACE("Enter\n");
1789 WL_CONN("key index (%d)\n", key_idx);
1790 if (!check_sys_up(wiphy))
1791 return -EIO;
1792
1793 memset(&params, 0, sizeof(params));
1794
1795 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_GET_WSEC, &wsec);
1796 if (err) {
1797 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1798 /* Ignore this error, may happen during DISASSOC */
1799 err = -EAGAIN;
1800 goto done;
1801 }
1802 switch (wsec) {
1803 case WEP_ENABLED:
1804 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1805 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1806 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1807 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1808 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1809 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1810 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1811 }
1812 break;
1813 case TKIP_ENABLED:
1814 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1815 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1816 break;
1817 case AES_ENABLED:
1818 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1819 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1820 break;
1821 default:
1822 WL_ERR("Invalid algo (0x%x)\n", wsec);
1823 err = -EINVAL;
1824 goto done;
1825 }
1826 callback(cookie, &params);
1827
1828 done:
1829 WL_TRACE("Exit\n");
1830 return err;
1831 }
1832
1833 static s32
1834 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1835 struct net_device *ndev, u8 key_idx)
1836 {
1837 WL_INFO("Not supported\n");
1838
1839 return -EOPNOTSUPP;
1840 }
1841
1842 static s32
1843 brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *ndev,
1844 u8 *mac, struct station_info *sinfo)
1845 {
1846 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1847 struct brcmf_scb_val_le scb_val;
1848 int rssi;
1849 s32 rate;
1850 s32 err = 0;
1851 u8 *bssid = brcmf_read_prof(cfg_priv, WL_PROF_BSSID);
1852
1853 WL_TRACE("Enter\n");
1854 if (!check_sys_up(wiphy))
1855 return -EIO;
1856
1857 if (memcmp(mac, bssid, ETH_ALEN)) {
1858 WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
1859 "wl_bssid-%X:%X:%X:%X:%X:%X\n",
1860 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
1861 bssid[0], bssid[1], bssid[2], bssid[3],
1862 bssid[4], bssid[5]);
1863 err = -ENOENT;
1864 goto done;
1865 }
1866
1867 /* Report the current tx rate */
1868 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_GET_RATE, &rate);
1869 if (err) {
1870 WL_ERR("Could not get rate (%d)\n", err);
1871 } else {
1872 sinfo->filled |= STATION_INFO_TX_BITRATE;
1873 sinfo->txrate.legacy = rate * 5;
1874 WL_CONN("Rate %d Mbps\n", rate / 2);
1875 }
1876
1877 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status)) {
1878 scb_val.val = cpu_to_le32(0);
1879 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_RSSI, &scb_val,
1880 sizeof(struct brcmf_scb_val_le));
1881 if (err)
1882 WL_ERR("Could not get rssi (%d)\n", err);
1883
1884 rssi = le32_to_cpu(scb_val.val);
1885 sinfo->filled |= STATION_INFO_SIGNAL;
1886 sinfo->signal = rssi;
1887 WL_CONN("RSSI %d dBm\n", rssi);
1888 }
1889
1890 done:
1891 WL_TRACE("Exit\n");
1892 return err;
1893 }
1894
1895 static s32
1896 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *ndev,
1897 bool enabled, s32 timeout)
1898 {
1899 s32 pm;
1900 s32 err = 0;
1901 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1902
1903 WL_TRACE("Enter\n");
1904
1905 /*
1906 * Powersave enable/disable request is coming from the
1907 * cfg80211 even before the interface is up. In that
1908 * scenario, driver will be storing the power save
1909 * preference in cfg_priv struct to apply this to
1910 * FW later while initializing the dongle
1911 */
1912 cfg_priv->pwr_save = enabled;
1913 if (!test_bit(WL_STATUS_READY, &cfg_priv->status)) {
1914
1915 WL_INFO("Device is not ready,"
1916 "storing the value in cfg_priv struct\n");
1917 goto done;
1918 }
1919
1920 pm = enabled ? PM_FAST : PM_OFF;
1921 WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
1922
1923 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_PM, &pm);
1924 if (err) {
1925 if (err == -ENODEV)
1926 WL_ERR("net_device is not ready yet\n");
1927 else
1928 WL_ERR("error (%d)\n", err);
1929 }
1930 done:
1931 WL_TRACE("Exit\n");
1932 return err;
1933 }
1934
1935 static s32
1936 brcmf_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *ndev,
1937 const u8 *addr,
1938 const struct cfg80211_bitrate_mask *mask)
1939 {
1940 struct brcm_rateset_le rateset_le;
1941 s32 rate;
1942 s32 val;
1943 s32 err_bg;
1944 s32 err_a;
1945 u32 legacy;
1946 s32 err = 0;
1947
1948 WL_TRACE("Enter\n");
1949 if (!check_sys_up(wiphy))
1950 return -EIO;
1951
1952 /* addr param is always NULL. ignore it */
1953 /* Get current rateset */
1954 err = brcmf_exec_dcmd(ndev, BRCM_GET_CURR_RATESET, &rateset_le,
1955 sizeof(rateset_le));
1956 if (err) {
1957 WL_ERR("could not get current rateset (%d)\n", err);
1958 goto done;
1959 }
1960
1961 legacy = ffs(mask->control[IEEE80211_BAND_2GHZ].legacy & 0xFFFF);
1962 if (!legacy)
1963 legacy = ffs(mask->control[IEEE80211_BAND_5GHZ].legacy &
1964 0xFFFF);
1965
1966 val = wl_g_rates[legacy - 1].bitrate * 100000;
1967
1968 if (val < le32_to_cpu(rateset_le.count))
1969 /* Select rate by rateset index */
1970 rate = rateset_le.rates[val] & 0x7f;
1971 else
1972 /* Specified rate in bps */
1973 rate = val / 500000;
1974
1975 WL_CONN("rate %d mbps\n", rate / 2);
1976
1977 /*
1978 *
1979 * Set rate override,
1980 * Since the is a/b/g-blind, both a/bg_rate are enforced.
1981 */
1982 err_bg = brcmf_dev_intvar_set(ndev, "bg_rate", rate);
1983 err_a = brcmf_dev_intvar_set(ndev, "a_rate", rate);
1984 if (err_bg && err_a) {
1985 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
1986 err = err_bg | err_a;
1987 }
1988
1989 done:
1990 WL_TRACE("Exit\n");
1991 return err;
1992 }
1993
1994 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_priv *cfg_priv,
1995 struct brcmf_bss_info_le *bi)
1996 {
1997 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
1998 struct ieee80211_channel *notify_channel;
1999 struct cfg80211_bss *bss;
2000 struct ieee80211_supported_band *band;
2001 s32 err = 0;
2002 u16 channel;
2003 u32 freq;
2004 u64 notify_timestamp;
2005 u16 notify_capability;
2006 u16 notify_interval;
2007 u8 *notify_ie;
2008 size_t notify_ielen;
2009 s32 notify_signal;
2010
2011 if (le32_to_cpu(bi->length) > WL_BSS_INFO_MAX) {
2012 WL_ERR("Bss info is larger than buffer. Discarding\n");
2013 return 0;
2014 }
2015
2016 channel = bi->ctl_ch ? bi->ctl_ch :
2017 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2018
2019 if (channel <= CH_MAX_2G_CHANNEL)
2020 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2021 else
2022 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2023
2024 freq = ieee80211_channel_to_frequency(channel, band->band);
2025 notify_channel = ieee80211_get_channel(wiphy, freq);
2026
2027 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2028 notify_capability = le16_to_cpu(bi->capability);
2029 notify_interval = le16_to_cpu(bi->beacon_period);
2030 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2031 notify_ielen = le32_to_cpu(bi->ie_length);
2032 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2033
2034 WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2035 bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
2036 bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
2037 WL_CONN("Channel: %d(%d)\n", channel, freq);
2038 WL_CONN("Capability: %X\n", notify_capability);
2039 WL_CONN("Beacon interval: %d\n", notify_interval);
2040 WL_CONN("Signal: %d\n", notify_signal);
2041 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2042
2043 bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2044 notify_timestamp, notify_capability, notify_interval, notify_ie,
2045 notify_ielen, notify_signal, GFP_KERNEL);
2046
2047 if (!bss)
2048 return -ENOMEM;
2049
2050 cfg80211_put_bss(bss);
2051
2052 return err;
2053 }
2054
2055 static struct brcmf_bss_info_le *
2056 next_bss_le(struct brcmf_scan_results *list, struct brcmf_bss_info_le *bss)
2057 {
2058 if (bss == NULL)
2059 return list->bss_info_le;
2060 return (struct brcmf_bss_info_le *)((unsigned long)bss +
2061 le32_to_cpu(bss->length));
2062 }
2063
2064 static s32 brcmf_inform_bss(struct brcmf_cfg80211_priv *cfg_priv)
2065 {
2066 struct brcmf_scan_results *bss_list;
2067 struct brcmf_bss_info_le *bi = NULL; /* must be initialized */
2068 s32 err = 0;
2069 int i;
2070
2071 bss_list = cfg_priv->bss_list;
2072 if (bss_list->version != BRCMF_BSS_INFO_VERSION) {
2073 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2074 bss_list->version);
2075 return -EOPNOTSUPP;
2076 }
2077 WL_SCAN("scanned AP count (%d)\n", bss_list->count);
2078 for (i = 0; i < bss_list->count && i < WL_AP_MAX; i++) {
2079 bi = next_bss_le(bss_list, bi);
2080 err = brcmf_inform_single_bss(cfg_priv, bi);
2081 if (err)
2082 break;
2083 }
2084 return err;
2085 }
2086
2087 static s32 wl_inform_ibss(struct brcmf_cfg80211_priv *cfg_priv,
2088 struct net_device *ndev, const u8 *bssid)
2089 {
2090 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2091 struct ieee80211_channel *notify_channel;
2092 struct brcmf_bss_info_le *bi = NULL;
2093 struct ieee80211_supported_band *band;
2094 struct cfg80211_bss *bss;
2095 u8 *buf = NULL;
2096 s32 err = 0;
2097 u16 channel;
2098 u32 freq;
2099 u64 notify_timestamp;
2100 u16 notify_capability;
2101 u16 notify_interval;
2102 u8 *notify_ie;
2103 size_t notify_ielen;
2104 s32 notify_signal;
2105
2106 WL_TRACE("Enter\n");
2107
2108 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2109 if (buf == NULL) {
2110 err = -ENOMEM;
2111 goto CleanUp;
2112 }
2113
2114 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2115
2116 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
2117 if (err) {
2118 WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
2119 goto CleanUp;
2120 }
2121
2122 bi = (struct brcmf_bss_info_le *)(buf + 4);
2123
2124 channel = bi->ctl_ch ? bi->ctl_ch :
2125 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2126
2127 if (channel <= CH_MAX_2G_CHANNEL)
2128 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2129 else
2130 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2131
2132 freq = ieee80211_channel_to_frequency(channel, band->band);
2133 notify_channel = ieee80211_get_channel(wiphy, freq);
2134
2135 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2136 notify_capability = le16_to_cpu(bi->capability);
2137 notify_interval = le16_to_cpu(bi->beacon_period);
2138 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2139 notify_ielen = le32_to_cpu(bi->ie_length);
2140 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2141
2142 WL_CONN("channel: %d(%d)\n", channel, freq);
2143 WL_CONN("capability: %X\n", notify_capability);
2144 WL_CONN("beacon interval: %d\n", notify_interval);
2145 WL_CONN("signal: %d\n", notify_signal);
2146 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2147
2148 bss = cfg80211_inform_bss(wiphy, notify_channel, bssid,
2149 notify_timestamp, notify_capability, notify_interval,
2150 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2151
2152 if (!bss) {
2153 err = -ENOMEM;
2154 goto CleanUp;
2155 }
2156
2157 cfg80211_put_bss(bss);
2158
2159 CleanUp:
2160
2161 kfree(buf);
2162
2163 WL_TRACE("Exit\n");
2164
2165 return err;
2166 }
2167
2168 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_priv *cfg_priv)
2169 {
2170 return cfg_priv->conf->mode == WL_MODE_IBSS;
2171 }
2172
2173 /*
2174 * Traverse a string of 1-byte tag/1-byte length/variable-length value
2175 * triples, returning a pointer to the substring whose first element
2176 * matches tag
2177 */
2178 static struct brcmf_tlv *brcmf_parse_tlvs(void *buf, int buflen, uint key)
2179 {
2180 struct brcmf_tlv *elt;
2181 int totlen;
2182
2183 elt = (struct brcmf_tlv *) buf;
2184 totlen = buflen;
2185
2186 /* find tagged parameter */
2187 while (totlen >= 2) {
2188 int len = elt->len;
2189
2190 /* validate remaining totlen */
2191 if ((elt->id == key) && (totlen >= (len + 2)))
2192 return elt;
2193
2194 elt = (struct brcmf_tlv *) ((u8 *) elt + (len + 2));
2195 totlen -= (len + 2);
2196 }
2197
2198 return NULL;
2199 }
2200
2201 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_priv *cfg_priv)
2202 {
2203 struct brcmf_bss_info_le *bi;
2204 struct brcmf_ssid *ssid;
2205 struct brcmf_tlv *tim;
2206 u16 beacon_interval;
2207 u8 dtim_period;
2208 size_t ie_len;
2209 u8 *ie;
2210 s32 err = 0;
2211
2212 WL_TRACE("Enter\n");
2213 if (brcmf_is_ibssmode(cfg_priv))
2214 return err;
2215
2216 ssid = (struct brcmf_ssid *)brcmf_read_prof(cfg_priv, WL_PROF_SSID);
2217
2218 *(__le32 *)cfg_priv->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2219 err = brcmf_exec_dcmd(cfg_to_ndev(cfg_priv), BRCMF_C_GET_BSS_INFO,
2220 cfg_priv->extra_buf, WL_EXTRA_BUF_MAX);
2221 if (err) {
2222 WL_ERR("Could not get bss info %d\n", err);
2223 goto update_bss_info_out;
2224 }
2225
2226 bi = (struct brcmf_bss_info_le *)(cfg_priv->extra_buf + 4);
2227 err = brcmf_inform_single_bss(cfg_priv, bi);
2228 if (err)
2229 goto update_bss_info_out;
2230
2231 ie = ((u8 *)bi) + le16_to_cpu(bi->ie_offset);
2232 ie_len = le32_to_cpu(bi->ie_length);
2233 beacon_interval = le16_to_cpu(bi->beacon_period);
2234
2235 tim = brcmf_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2236 if (tim)
2237 dtim_period = tim->data[1];
2238 else {
2239 /*
2240 * active scan was done so we could not get dtim
2241 * information out of probe response.
2242 * so we speficially query dtim information to dongle.
2243 */
2244 u32 var;
2245 err = brcmf_dev_intvar_get(cfg_to_ndev(cfg_priv),
2246 "dtim_assoc", &var);
2247 if (err) {
2248 WL_ERR("wl dtim_assoc failed (%d)\n", err);
2249 goto update_bss_info_out;
2250 }
2251 dtim_period = (u8)var;
2252 }
2253
2254 brcmf_update_prof(cfg_priv, NULL, &beacon_interval, WL_PROF_BEACONINT);
2255 brcmf_update_prof(cfg_priv, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2256
2257 update_bss_info_out:
2258 WL_TRACE("Exit");
2259 return err;
2260 }
2261
2262 static void brcmf_term_iscan(struct brcmf_cfg80211_priv *cfg_priv)
2263 {
2264 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
2265 struct brcmf_ssid ssid;
2266
2267 if (cfg_priv->iscan_on) {
2268 iscan->state = WL_ISCAN_STATE_IDLE;
2269
2270 if (iscan->timer_on) {
2271 del_timer_sync(&iscan->timer);
2272 iscan->timer_on = 0;
2273 }
2274
2275 cancel_work_sync(&iscan->work);
2276
2277 /* Abort iscan running in FW */
2278 memset(&ssid, 0, sizeof(ssid));
2279 brcmf_run_iscan(iscan, &ssid, WL_SCAN_ACTION_ABORT);
2280 }
2281 }
2282
2283 static void brcmf_notify_iscan_complete(struct brcmf_cfg80211_iscan_ctrl *iscan,
2284 bool aborted)
2285 {
2286 struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
2287 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2288
2289 if (!test_and_clear_bit(WL_STATUS_SCANNING, &cfg_priv->status)) {
2290 WL_ERR("Scan complete while device not scanning\n");
2291 return;
2292 }
2293 if (cfg_priv->scan_request) {
2294 WL_SCAN("ISCAN Completed scan: %s\n",
2295 aborted ? "Aborted" : "Done");
2296 cfg80211_scan_done(cfg_priv->scan_request, aborted);
2297 brcmf_set_mpc(ndev, 1);
2298 cfg_priv->scan_request = NULL;
2299 }
2300 cfg_priv->iscan_kickstart = false;
2301 }
2302
2303 static s32 brcmf_wakeup_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan)
2304 {
2305 if (iscan->state != WL_ISCAN_STATE_IDLE) {
2306 WL_SCAN("wake up iscan\n");
2307 schedule_work(&iscan->work);
2308 return 0;
2309 }
2310
2311 return -EIO;
2312 }
2313
2314 static s32
2315 brcmf_get_iscan_results(struct brcmf_cfg80211_iscan_ctrl *iscan, u32 *status,
2316 struct brcmf_scan_results **bss_list)
2317 {
2318 struct brcmf_iscan_results list;
2319 struct brcmf_scan_results *results;
2320 struct brcmf_scan_results_le *results_le;
2321 struct brcmf_iscan_results *list_buf;
2322 s32 err = 0;
2323
2324 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
2325 list_buf = (struct brcmf_iscan_results *)iscan->scan_buf;
2326 results = &list_buf->results;
2327 results_le = &list_buf->results_le;
2328 results->buflen = BRCMF_ISCAN_RESULTS_FIXED_SIZE;
2329 results->version = 0;
2330 results->count = 0;
2331
2332 memset(&list, 0, sizeof(list));
2333 list.results_le.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
2334 err = brcmf_dev_iovar_getbuf(iscan->ndev, "iscanresults", &list,
2335 BRCMF_ISCAN_RESULTS_FIXED_SIZE,
2336 iscan->scan_buf, WL_ISCAN_BUF_MAX);
2337 if (err) {
2338 WL_ERR("error (%d)\n", err);
2339 return err;
2340 }
2341 results->buflen = le32_to_cpu(results_le->buflen);
2342 results->version = le32_to_cpu(results_le->version);
2343 results->count = le32_to_cpu(results_le->count);
2344 WL_SCAN("results->count = %d\n", results_le->count);
2345 WL_SCAN("results->buflen = %d\n", results_le->buflen);
2346 *status = le32_to_cpu(list_buf->status_le);
2347 WL_SCAN("status = %d\n", *status);
2348 *bss_list = results;
2349
2350 return err;
2351 }
2352
2353 static s32 brcmf_iscan_done(struct brcmf_cfg80211_priv *cfg_priv)
2354 {
2355 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2356 s32 err = 0;
2357
2358 iscan->state = WL_ISCAN_STATE_IDLE;
2359 brcmf_inform_bss(cfg_priv);
2360 brcmf_notify_iscan_complete(iscan, false);
2361
2362 return err;
2363 }
2364
2365 static s32 brcmf_iscan_pending(struct brcmf_cfg80211_priv *cfg_priv)
2366 {
2367 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2368 s32 err = 0;
2369
2370 /* Reschedule the timer */
2371 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
2372 iscan->timer_on = 1;
2373
2374 return err;
2375 }
2376
2377 static s32 brcmf_iscan_inprogress(struct brcmf_cfg80211_priv *cfg_priv)
2378 {
2379 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2380 s32 err = 0;
2381
2382 brcmf_inform_bss(cfg_priv);
2383 brcmf_run_iscan(iscan, NULL, BRCMF_SCAN_ACTION_CONTINUE);
2384 /* Reschedule the timer */
2385 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
2386 iscan->timer_on = 1;
2387
2388 return err;
2389 }
2390
2391 static s32 brcmf_iscan_aborted(struct brcmf_cfg80211_priv *cfg_priv)
2392 {
2393 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2394 s32 err = 0;
2395
2396 iscan->state = WL_ISCAN_STATE_IDLE;
2397 brcmf_notify_iscan_complete(iscan, true);
2398
2399 return err;
2400 }
2401
2402 static void brcmf_cfg80211_iscan_handler(struct work_struct *work)
2403 {
2404 struct brcmf_cfg80211_iscan_ctrl *iscan =
2405 container_of(work, struct brcmf_cfg80211_iscan_ctrl,
2406 work);
2407 struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
2408 struct brcmf_cfg80211_iscan_eloop *el = &iscan->el;
2409 u32 status = BRCMF_SCAN_RESULTS_PARTIAL;
2410
2411 if (iscan->timer_on) {
2412 del_timer_sync(&iscan->timer);
2413 iscan->timer_on = 0;
2414 }
2415
2416 if (brcmf_get_iscan_results(iscan, &status, &cfg_priv->bss_list)) {
2417 status = BRCMF_SCAN_RESULTS_ABORTED;
2418 WL_ERR("Abort iscan\n");
2419 }
2420
2421 el->handler[status](cfg_priv);
2422 }
2423
2424 static void brcmf_iscan_timer(unsigned long data)
2425 {
2426 struct brcmf_cfg80211_iscan_ctrl *iscan =
2427 (struct brcmf_cfg80211_iscan_ctrl *)data;
2428
2429 if (iscan) {
2430 iscan->timer_on = 0;
2431 WL_SCAN("timer expired\n");
2432 brcmf_wakeup_iscan(iscan);
2433 }
2434 }
2435
2436 static s32 brcmf_invoke_iscan(struct brcmf_cfg80211_priv *cfg_priv)
2437 {
2438 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
2439
2440 if (cfg_priv->iscan_on) {
2441 iscan->state = WL_ISCAN_STATE_IDLE;
2442 INIT_WORK(&iscan->work, brcmf_cfg80211_iscan_handler);
2443 }
2444
2445 return 0;
2446 }
2447
2448 static void brcmf_init_iscan_eloop(struct brcmf_cfg80211_iscan_eloop *el)
2449 {
2450 memset(el, 0, sizeof(*el));
2451 el->handler[BRCMF_SCAN_RESULTS_SUCCESS] = brcmf_iscan_done;
2452 el->handler[BRCMF_SCAN_RESULTS_PARTIAL] = brcmf_iscan_inprogress;
2453 el->handler[BRCMF_SCAN_RESULTS_PENDING] = brcmf_iscan_pending;
2454 el->handler[BRCMF_SCAN_RESULTS_ABORTED] = brcmf_iscan_aborted;
2455 el->handler[BRCMF_SCAN_RESULTS_NO_MEM] = brcmf_iscan_aborted;
2456 }
2457
2458 static s32 brcmf_init_iscan(struct brcmf_cfg80211_priv *cfg_priv)
2459 {
2460 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
2461 int err = 0;
2462
2463 if (cfg_priv->iscan_on) {
2464 iscan->ndev = cfg_to_ndev(cfg_priv);
2465 brcmf_init_iscan_eloop(&iscan->el);
2466 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
2467 init_timer(&iscan->timer);
2468 iscan->timer.data = (unsigned long) iscan;
2469 iscan->timer.function = brcmf_iscan_timer;
2470 err = brcmf_invoke_iscan(cfg_priv);
2471 if (!err)
2472 iscan->data = cfg_priv;
2473 }
2474
2475 return err;
2476 }
2477
2478 static __always_inline void brcmf_delay(u32 ms)
2479 {
2480 if (ms < 1000 / HZ) {
2481 cond_resched();
2482 mdelay(ms);
2483 } else {
2484 msleep(ms);
2485 }
2486 }
2487
2488 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
2489 {
2490 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2491
2492 /*
2493 * Check for WL_STATUS_READY before any function call which
2494 * could result is bus access. Don't block the resume for
2495 * any driver error conditions
2496 */
2497 WL_TRACE("Enter\n");
2498
2499 if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2500 brcmf_invoke_iscan(wiphy_to_cfg(wiphy));
2501
2502 WL_TRACE("Exit\n");
2503 return 0;
2504 }
2505
2506 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
2507 struct cfg80211_wowlan *wow)
2508 {
2509 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2510 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2511
2512 WL_TRACE("Enter\n");
2513
2514 /*
2515 * Check for WL_STATUS_READY before any function call which
2516 * could result is bus access. Don't block the suspend for
2517 * any driver error conditions
2518 */
2519
2520 /*
2521 * While going to suspend if associated with AP disassociate
2522 * from AP to save power while system is in suspended state
2523 */
2524 if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
2525 test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
2526 test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2527 WL_INFO("Disassociating from AP"
2528 " while entering suspend state\n");
2529 brcmf_link_down(cfg_priv);
2530
2531 /*
2532 * Make sure WPA_Supplicant receives all the event
2533 * generated due to DISASSOC call to the fw to keep
2534 * the state fw and WPA_Supplicant state consistent
2535 */
2536 brcmf_delay(500);
2537 }
2538
2539 set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2540 if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2541 brcmf_term_iscan(cfg_priv);
2542
2543 if (cfg_priv->scan_request) {
2544 /* Indidate scan abort to cfg80211 layer */
2545 WL_INFO("Terminating scan in progress\n");
2546 cfg80211_scan_done(cfg_priv->scan_request, true);
2547 cfg_priv->scan_request = NULL;
2548 }
2549 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
2550 clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2551
2552 /* Turn off watchdog timer */
2553 if (test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2554 WL_INFO("Enable MPC\n");
2555 brcmf_set_mpc(ndev, 1);
2556 }
2557
2558 WL_TRACE("Exit\n");
2559
2560 return 0;
2561 }
2562
2563 static __used s32
2564 brcmf_dev_bufvar_set(struct net_device *ndev, s8 *name, s8 *buf, s32 len)
2565 {
2566 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
2567 u32 buflen;
2568
2569 buflen = brcmf_c_mkiovar(name, buf, len, cfg_priv->dcmd_buf,
2570 WL_DCMD_LEN_MAX);
2571 BUG_ON(!buflen);
2572
2573 return brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, cfg_priv->dcmd_buf,
2574 buflen);
2575 }
2576
2577 static s32
2578 brcmf_dev_bufvar_get(struct net_device *ndev, s8 *name, s8 *buf,
2579 s32 buf_len)
2580 {
2581 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
2582 u32 len;
2583 s32 err = 0;
2584
2585 len = brcmf_c_mkiovar(name, NULL, 0, cfg_priv->dcmd_buf,
2586 WL_DCMD_LEN_MAX);
2587 BUG_ON(!len);
2588 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, cfg_priv->dcmd_buf,
2589 WL_DCMD_LEN_MAX);
2590 if (err) {
2591 WL_ERR("error (%d)\n", err);
2592 return err;
2593 }
2594 memcpy(buf, cfg_priv->dcmd_buf, buf_len);
2595
2596 return err;
2597 }
2598
2599 static __used s32
2600 brcmf_update_pmklist(struct net_device *ndev,
2601 struct brcmf_cfg80211_pmk_list *pmk_list, s32 err)
2602 {
2603 int i, j;
2604 int pmkid_len;
2605
2606 pmkid_len = le32_to_cpu(pmk_list->pmkids.npmkid);
2607
2608 WL_CONN("No of elements %d\n", pmkid_len);
2609 for (i = 0; i < pmkid_len; i++) {
2610 WL_CONN("PMKID[%d]: %pM =\n", i,
2611 &pmk_list->pmkids.pmkid[i].BSSID);
2612 for (j = 0; j < WLAN_PMKID_LEN; j++)
2613 WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2614 }
2615
2616 if (!err)
2617 brcmf_dev_bufvar_set(ndev, "pmkid_info", (char *)pmk_list,
2618 sizeof(*pmk_list));
2619
2620 return err;
2621 }
2622
2623 static s32
2624 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev,
2625 struct cfg80211_pmksa *pmksa)
2626 {
2627 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2628 struct pmkid_list *pmkids = &cfg_priv->pmk_list->pmkids;
2629 s32 err = 0;
2630 int i;
2631 int pmkid_len;
2632
2633 WL_TRACE("Enter\n");
2634 if (!check_sys_up(wiphy))
2635 return -EIO;
2636
2637 pmkid_len = le32_to_cpu(pmkids->npmkid);
2638 for (i = 0; i < pmkid_len; i++)
2639 if (!memcmp(pmksa->bssid, pmkids->pmkid[i].BSSID, ETH_ALEN))
2640 break;
2641 if (i < WL_NUM_PMKIDS_MAX) {
2642 memcpy(pmkids->pmkid[i].BSSID, pmksa->bssid, ETH_ALEN);
2643 memcpy(pmkids->pmkid[i].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2644 if (i == pmkid_len) {
2645 pmkid_len++;
2646 pmkids->npmkid = cpu_to_le32(pmkid_len);
2647 }
2648 } else
2649 err = -EINVAL;
2650
2651 WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2652 pmkids->pmkid[pmkid_len].BSSID);
2653 for (i = 0; i < WLAN_PMKID_LEN; i++)
2654 WL_CONN("%02x\n", pmkids->pmkid[pmkid_len].PMKID[i]);
2655
2656 err = brcmf_update_pmklist(ndev, cfg_priv->pmk_list, err);
2657
2658 WL_TRACE("Exit\n");
2659 return err;
2660 }
2661
2662 static s32
2663 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *ndev,
2664 struct cfg80211_pmksa *pmksa)
2665 {
2666 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2667 struct pmkid_list pmkid;
2668 s32 err = 0;
2669 int i, pmkid_len;
2670
2671 WL_TRACE("Enter\n");
2672 if (!check_sys_up(wiphy))
2673 return -EIO;
2674
2675 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2676 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2677
2678 WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2679 &pmkid.pmkid[0].BSSID);
2680 for (i = 0; i < WLAN_PMKID_LEN; i++)
2681 WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
2682
2683 pmkid_len = le32_to_cpu(cfg_priv->pmk_list->pmkids.npmkid);
2684 for (i = 0; i < pmkid_len; i++)
2685 if (!memcmp
2686 (pmksa->bssid, &cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2687 ETH_ALEN))
2688 break;
2689
2690 if ((pmkid_len > 0)
2691 && (i < pmkid_len)) {
2692 memset(&cfg_priv->pmk_list->pmkids.pmkid[i], 0,
2693 sizeof(struct pmkid));
2694 for (; i < (pmkid_len - 1); i++) {
2695 memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2696 &cfg_priv->pmk_list->pmkids.pmkid[i + 1].BSSID,
2697 ETH_ALEN);
2698 memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].PMKID,
2699 &cfg_priv->pmk_list->pmkids.pmkid[i + 1].PMKID,
2700 WLAN_PMKID_LEN);
2701 }
2702 cfg_priv->pmk_list->pmkids.npmkid = cpu_to_le32(pmkid_len - 1);
2703 } else
2704 err = -EINVAL;
2705
2706 err = brcmf_update_pmklist(ndev, cfg_priv->pmk_list, err);
2707
2708 WL_TRACE("Exit\n");
2709 return err;
2710
2711 }
2712
2713 static s32
2714 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev)
2715 {
2716 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2717 s32 err = 0;
2718
2719 WL_TRACE("Enter\n");
2720 if (!check_sys_up(wiphy))
2721 return -EIO;
2722
2723 memset(cfg_priv->pmk_list, 0, sizeof(*cfg_priv->pmk_list));
2724 err = brcmf_update_pmklist(ndev, cfg_priv->pmk_list, err);
2725
2726 WL_TRACE("Exit\n");
2727 return err;
2728
2729 }
2730
2731 static struct cfg80211_ops wl_cfg80211_ops = {
2732 .change_virtual_intf = brcmf_cfg80211_change_iface,
2733 .scan = brcmf_cfg80211_scan,
2734 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
2735 .join_ibss = brcmf_cfg80211_join_ibss,
2736 .leave_ibss = brcmf_cfg80211_leave_ibss,
2737 .get_station = brcmf_cfg80211_get_station,
2738 .set_tx_power = brcmf_cfg80211_set_tx_power,
2739 .get_tx_power = brcmf_cfg80211_get_tx_power,
2740 .add_key = brcmf_cfg80211_add_key,
2741 .del_key = brcmf_cfg80211_del_key,
2742 .get_key = brcmf_cfg80211_get_key,
2743 .set_default_key = brcmf_cfg80211_config_default_key,
2744 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
2745 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
2746 .set_bitrate_mask = brcmf_cfg80211_set_bitrate_mask,
2747 .connect = brcmf_cfg80211_connect,
2748 .disconnect = brcmf_cfg80211_disconnect,
2749 .suspend = brcmf_cfg80211_suspend,
2750 .resume = brcmf_cfg80211_resume,
2751 .set_pmksa = brcmf_cfg80211_set_pmksa,
2752 .del_pmksa = brcmf_cfg80211_del_pmksa,
2753 .flush_pmksa = brcmf_cfg80211_flush_pmksa
2754 };
2755
2756 static s32 brcmf_mode_to_nl80211_iftype(s32 mode)
2757 {
2758 s32 err = 0;
2759
2760 switch (mode) {
2761 case WL_MODE_BSS:
2762 return NL80211_IFTYPE_STATION;
2763 case WL_MODE_IBSS:
2764 return NL80211_IFTYPE_ADHOC;
2765 default:
2766 return NL80211_IFTYPE_UNSPECIFIED;
2767 }
2768
2769 return err;
2770 }
2771
2772 static struct wireless_dev *brcmf_alloc_wdev(s32 sizeof_iface,
2773 struct device *ndev)
2774 {
2775 struct wireless_dev *wdev;
2776 s32 err = 0;
2777
2778 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2779 if (!wdev)
2780 return ERR_PTR(-ENOMEM);
2781
2782 wdev->wiphy =
2783 wiphy_new(&wl_cfg80211_ops,
2784 sizeof(struct brcmf_cfg80211_priv) + sizeof_iface);
2785 if (!wdev->wiphy) {
2786 WL_ERR("Couldn not allocate wiphy device\n");
2787 err = -ENOMEM;
2788 goto wiphy_new_out;
2789 }
2790 set_wiphy_dev(wdev->wiphy, ndev);
2791 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2792 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2793 wdev->wiphy->interface_modes =
2794 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2795 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2796 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2797 * it as 11a by default.
2798 * This will be updated with
2799 * 11n phy tables in
2800 * "ifconfig up"
2801 * if phy has 11n capability
2802 */
2803 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2804 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2805 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2806 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2807 * save mode
2808 * by default
2809 */
2810 err = wiphy_register(wdev->wiphy);
2811 if (err < 0) {
2812 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2813 goto wiphy_register_out;
2814 }
2815 return wdev;
2816
2817 wiphy_register_out:
2818 wiphy_free(wdev->wiphy);
2819
2820 wiphy_new_out:
2821 kfree(wdev);
2822
2823 return ERR_PTR(err);
2824 }
2825
2826 static void brcmf_free_wdev(struct brcmf_cfg80211_priv *cfg_priv)
2827 {
2828 struct wireless_dev *wdev = cfg_priv->wdev;
2829
2830 if (!wdev) {
2831 WL_ERR("wdev is invalid\n");
2832 return;
2833 }
2834 wiphy_unregister(wdev->wiphy);
2835 wiphy_free(wdev->wiphy);
2836 kfree(wdev);
2837 cfg_priv->wdev = NULL;
2838 }
2839
2840 static bool brcmf_is_linkup(struct brcmf_cfg80211_priv *cfg_priv,
2841 const struct brcmf_event_msg *e)
2842 {
2843 u32 event = be32_to_cpu(e->event_type);
2844 u32 status = be32_to_cpu(e->status);
2845
2846 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
2847 WL_CONN("Processing set ssid\n");
2848 cfg_priv->link_up = true;
2849 return true;
2850 }
2851
2852 return false;
2853 }
2854
2855 static bool brcmf_is_linkdown(struct brcmf_cfg80211_priv *cfg_priv,
2856 const struct brcmf_event_msg *e)
2857 {
2858 u32 event = be32_to_cpu(e->event_type);
2859 u16 flags = be16_to_cpu(e->flags);
2860
2861 if (event == BRCMF_E_LINK && (!(flags & BRCMF_EVENT_MSG_LINK))) {
2862 WL_CONN("Processing link down\n");
2863 return true;
2864 }
2865 return false;
2866 }
2867
2868 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_priv *cfg_priv,
2869 const struct brcmf_event_msg *e)
2870 {
2871 u32 event = be32_to_cpu(e->event_type);
2872 u32 status = be32_to_cpu(e->status);
2873
2874 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
2875 WL_CONN("Processing Link %s & no network found\n",
2876 be16_to_cpu(e->flags) & BRCMF_EVENT_MSG_LINK ?
2877 "up" : "down");
2878 return true;
2879 }
2880
2881 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
2882 WL_CONN("Processing connecting & no network found\n");
2883 return true;
2884 }
2885
2886 return false;
2887 }
2888
2889 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2890 {
2891 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2892
2893 kfree(conn_info->req_ie);
2894 conn_info->req_ie = NULL;
2895 conn_info->req_ie_len = 0;
2896 kfree(conn_info->resp_ie);
2897 conn_info->resp_ie = NULL;
2898 conn_info->resp_ie_len = 0;
2899 }
2900
2901 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2902 {
2903 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2904 struct brcmf_cfg80211_assoc_ielen_le *assoc_info;
2905 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2906 u32 req_len;
2907 u32 resp_len;
2908 s32 err = 0;
2909
2910 brcmf_clear_assoc_ies(cfg_priv);
2911
2912 err = brcmf_dev_bufvar_get(ndev, "assoc_info", cfg_priv->extra_buf,
2913 WL_ASSOC_INFO_MAX);
2914 if (err) {
2915 WL_ERR("could not get assoc info (%d)\n", err);
2916 return err;
2917 }
2918 assoc_info =
2919 (struct brcmf_cfg80211_assoc_ielen_le *)cfg_priv->extra_buf;
2920 req_len = le32_to_cpu(assoc_info->req_len);
2921 resp_len = le32_to_cpu(assoc_info->resp_len);
2922 if (req_len) {
2923 err = brcmf_dev_bufvar_get(ndev, "assoc_req_ies",
2924 cfg_priv->extra_buf,
2925 WL_ASSOC_INFO_MAX);
2926 if (err) {
2927 WL_ERR("could not get assoc req (%d)\n", err);
2928 return err;
2929 }
2930 conn_info->req_ie_len = req_len;
2931 conn_info->req_ie =
2932 kmemdup(cfg_priv->extra_buf, conn_info->req_ie_len,
2933 GFP_KERNEL);
2934 } else {
2935 conn_info->req_ie_len = 0;
2936 conn_info->req_ie = NULL;
2937 }
2938 if (resp_len) {
2939 err = brcmf_dev_bufvar_get(ndev, "assoc_resp_ies",
2940 cfg_priv->extra_buf,
2941 WL_ASSOC_INFO_MAX);
2942 if (err) {
2943 WL_ERR("could not get assoc resp (%d)\n", err);
2944 return err;
2945 }
2946 conn_info->resp_ie_len = resp_len;
2947 conn_info->resp_ie =
2948 kmemdup(cfg_priv->extra_buf, conn_info->resp_ie_len,
2949 GFP_KERNEL);
2950 } else {
2951 conn_info->resp_ie_len = 0;
2952 conn_info->resp_ie = NULL;
2953 }
2954 WL_CONN("req len (%d) resp len (%d)\n",
2955 conn_info->req_ie_len, conn_info->resp_ie_len);
2956
2957 return err;
2958 }
2959
2960 static s32
2961 brcmf_bss_roaming_done(struct brcmf_cfg80211_priv *cfg_priv,
2962 struct net_device *ndev,
2963 const struct brcmf_event_msg *e)
2964 {
2965 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2966 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2967 struct brcmf_channel_info_le channel_le;
2968 struct ieee80211_channel *notify_channel;
2969 struct ieee80211_supported_band *band;
2970 u32 freq;
2971 s32 err = 0;
2972 u32 target_channel;
2973
2974 WL_TRACE("Enter\n");
2975
2976 brcmf_get_assoc_ies(cfg_priv);
2977 brcmf_update_prof(cfg_priv, NULL, &e->addr, WL_PROF_BSSID);
2978 brcmf_update_bss_info(cfg_priv);
2979
2980 brcmf_exec_dcmd(ndev, BRCMF_C_GET_CHANNEL, &channel_le,
2981 sizeof(channel_le));
2982
2983 target_channel = le32_to_cpu(channel_le.target_channel);
2984 WL_CONN("Roamed to channel %d\n", target_channel);
2985
2986 if (target_channel <= CH_MAX_2G_CHANNEL)
2987 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2988 else
2989 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2990
2991 freq = ieee80211_channel_to_frequency(target_channel, band->band);
2992 notify_channel = ieee80211_get_channel(wiphy, freq);
2993
2994 cfg80211_roamed(ndev, notify_channel,
2995 (u8 *)brcmf_read_prof(cfg_priv, WL_PROF_BSSID),
2996 conn_info->req_ie, conn_info->req_ie_len,
2997 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2998 WL_CONN("Report roaming result\n");
2999
3000 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
3001 WL_TRACE("Exit\n");
3002 return err;
3003 }
3004
3005 static s32
3006 brcmf_bss_connect_done(struct brcmf_cfg80211_priv *cfg_priv,
3007 struct net_device *ndev, const struct brcmf_event_msg *e,
3008 bool completed)
3009 {
3010 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
3011 s32 err = 0;
3012
3013 WL_TRACE("Enter\n");
3014
3015 if (test_and_clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) {
3016 if (completed) {
3017 brcmf_get_assoc_ies(cfg_priv);
3018 brcmf_update_prof(cfg_priv, NULL, &e->addr,
3019 WL_PROF_BSSID);
3020 brcmf_update_bss_info(cfg_priv);
3021 }
3022 cfg80211_connect_result(ndev,
3023 (u8 *)brcmf_read_prof(cfg_priv,
3024 WL_PROF_BSSID),
3025 conn_info->req_ie,
3026 conn_info->req_ie_len,
3027 conn_info->resp_ie,
3028 conn_info->resp_ie_len,
3029 completed ? WLAN_STATUS_SUCCESS :
3030 WLAN_STATUS_AUTH_TIMEOUT,
3031 GFP_KERNEL);
3032 if (completed)
3033 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
3034 WL_CONN("Report connect result - connection %s\n",
3035 completed ? "succeeded" : "failed");
3036 }
3037 WL_TRACE("Exit\n");
3038 return err;
3039 }
3040
3041 static s32
3042 brcmf_notify_connect_status(struct brcmf_cfg80211_priv *cfg_priv,
3043 struct net_device *ndev,
3044 const struct brcmf_event_msg *e, void *data)
3045 {
3046 s32 err = 0;
3047
3048 if (brcmf_is_linkup(cfg_priv, e)) {
3049 WL_CONN("Linkup\n");
3050 if (brcmf_is_ibssmode(cfg_priv)) {
3051 brcmf_update_prof(cfg_priv, NULL, (void *)e->addr,
3052 WL_PROF_BSSID);
3053 wl_inform_ibss(cfg_priv, ndev, e->addr);
3054 cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
3055 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
3056 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
3057 } else
3058 brcmf_bss_connect_done(cfg_priv, ndev, e, true);
3059 } else if (brcmf_is_linkdown(cfg_priv, e)) {
3060 WL_CONN("Linkdown\n");
3061 if (brcmf_is_ibssmode(cfg_priv)) {
3062 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
3063 if (test_and_clear_bit(WL_STATUS_CONNECTED,
3064 &cfg_priv->status))
3065 brcmf_link_down(cfg_priv);
3066 } else {
3067 brcmf_bss_connect_done(cfg_priv, ndev, e, false);
3068 if (test_and_clear_bit(WL_STATUS_CONNECTED,
3069 &cfg_priv->status)) {
3070 cfg80211_disconnected(ndev, 0, NULL, 0,
3071 GFP_KERNEL);
3072 brcmf_link_down(cfg_priv);
3073 }
3074 }
3075 brcmf_init_prof(cfg_priv->profile);
3076 } else if (brcmf_is_nonetwork(cfg_priv, e)) {
3077 if (brcmf_is_ibssmode(cfg_priv))
3078 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
3079 else
3080 brcmf_bss_connect_done(cfg_priv, ndev, e, false);
3081 }
3082
3083 return err;
3084 }
3085
3086 static s32
3087 brcmf_notify_roaming_status(struct brcmf_cfg80211_priv *cfg_priv,
3088 struct net_device *ndev,
3089 const struct brcmf_event_msg *e, void *data)
3090 {
3091 s32 err = 0;
3092 u32 event = be32_to_cpu(e->event_type);
3093 u32 status = be32_to_cpu(e->status);
3094
3095 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
3096 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status))
3097 brcmf_bss_roaming_done(cfg_priv, ndev, e);
3098 else
3099 brcmf_bss_connect_done(cfg_priv, ndev, e, true);
3100 }
3101
3102 return err;
3103 }
3104
3105 static s32
3106 brcmf_notify_mic_status(struct brcmf_cfg80211_priv *cfg_priv,
3107 struct net_device *ndev,
3108 const struct brcmf_event_msg *e, void *data)
3109 {
3110 u16 flags = be16_to_cpu(e->flags);
3111 enum nl80211_key_type key_type;
3112
3113 if (flags & BRCMF_EVENT_MSG_GROUP)
3114 key_type = NL80211_KEYTYPE_GROUP;
3115 else
3116 key_type = NL80211_KEYTYPE_PAIRWISE;
3117
3118 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
3119 NULL, GFP_KERNEL);
3120
3121 return 0;
3122 }
3123
3124 static s32
3125 brcmf_notify_scan_status(struct brcmf_cfg80211_priv *cfg_priv,
3126 struct net_device *ndev,
3127 const struct brcmf_event_msg *e, void *data)
3128 {
3129 struct brcmf_channel_info_le channel_inform_le;
3130 struct brcmf_scan_results_le *bss_list_le;
3131 u32 len = WL_SCAN_BUF_MAX;
3132 s32 err = 0;
3133 bool scan_abort = false;
3134 u32 scan_channel;
3135
3136 WL_TRACE("Enter\n");
3137
3138 if (cfg_priv->iscan_on && cfg_priv->iscan_kickstart) {
3139 WL_TRACE("Exit\n");
3140 return brcmf_wakeup_iscan(cfg_to_iscan(cfg_priv));
3141 }
3142
3143 if (!test_and_clear_bit(WL_STATUS_SCANNING, &cfg_priv->status)) {
3144 WL_ERR("Scan complete while device not scanning\n");
3145 scan_abort = true;
3146 err = -EINVAL;
3147 goto scan_done_out;
3148 }
3149
3150 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_CHANNEL, &channel_inform_le,
3151 sizeof(channel_inform_le));
3152 if (err) {
3153 WL_ERR("scan busy (%d)\n", err);
3154 scan_abort = true;
3155 goto scan_done_out;
3156 }
3157 scan_channel = le32_to_cpu(channel_inform_le.scan_channel);
3158 if (scan_channel)
3159 WL_CONN("channel_inform.scan_channel (%d)\n", scan_channel);
3160 cfg_priv->bss_list = cfg_priv->scan_results;
3161 bss_list_le = (struct brcmf_scan_results_le *) cfg_priv->bss_list;
3162
3163 memset(cfg_priv->scan_results, 0, len);
3164 bss_list_le->buflen = cpu_to_le32(len);
3165 err = brcmf_exec_dcmd(ndev, BRCMF_C_SCAN_RESULTS,
3166 cfg_priv->scan_results, len);
3167 if (err) {
3168 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
3169 err = -EINVAL;
3170 scan_abort = true;
3171 goto scan_done_out;
3172 }
3173 cfg_priv->scan_results->buflen = le32_to_cpu(bss_list_le->buflen);
3174 cfg_priv->scan_results->version = le32_to_cpu(bss_list_le->version);
3175 cfg_priv->scan_results->count = le32_to_cpu(bss_list_le->count);
3176
3177 err = brcmf_inform_bss(cfg_priv);
3178 if (err) {
3179 scan_abort = true;
3180 goto scan_done_out;
3181 }
3182
3183 scan_done_out:
3184 if (cfg_priv->scan_request) {
3185 WL_SCAN("calling cfg80211_scan_done\n");
3186 cfg80211_scan_done(cfg_priv->scan_request, scan_abort);
3187 brcmf_set_mpc(ndev, 1);
3188 cfg_priv->scan_request = NULL;
3189 }
3190
3191 WL_TRACE("Exit\n");
3192
3193 return err;
3194 }
3195
3196 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
3197 {
3198 conf->mode = (u32)-1;
3199 conf->frag_threshold = (u32)-1;
3200 conf->rts_threshold = (u32)-1;
3201 conf->retry_short = (u32)-1;
3202 conf->retry_long = (u32)-1;
3203 conf->tx_power = -1;
3204 }
3205
3206 static void brcmf_init_eloop_handler(struct brcmf_cfg80211_event_loop *el)
3207 {
3208 memset(el, 0, sizeof(*el));
3209 el->handler[BRCMF_E_SCAN_COMPLETE] = brcmf_notify_scan_status;
3210 el->handler[BRCMF_E_LINK] = brcmf_notify_connect_status;
3211 el->handler[BRCMF_E_ROAM] = brcmf_notify_roaming_status;
3212 el->handler[BRCMF_E_MIC_ERROR] = brcmf_notify_mic_status;
3213 el->handler[BRCMF_E_SET_SSID] = brcmf_notify_connect_status;
3214 }
3215
3216 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3217 {
3218 kfree(cfg_priv->scan_results);
3219 cfg_priv->scan_results = NULL;
3220 kfree(cfg_priv->bss_info);
3221 cfg_priv->bss_info = NULL;
3222 kfree(cfg_priv->conf);
3223 cfg_priv->conf = NULL;
3224 kfree(cfg_priv->profile);
3225 cfg_priv->profile = NULL;
3226 kfree(cfg_priv->scan_req_int);
3227 cfg_priv->scan_req_int = NULL;
3228 kfree(cfg_priv->dcmd_buf);
3229 cfg_priv->dcmd_buf = NULL;
3230 kfree(cfg_priv->extra_buf);
3231 cfg_priv->extra_buf = NULL;
3232 kfree(cfg_priv->iscan);
3233 cfg_priv->iscan = NULL;
3234 kfree(cfg_priv->pmk_list);
3235 cfg_priv->pmk_list = NULL;
3236 }
3237
3238 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3239 {
3240 cfg_priv->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
3241 if (!cfg_priv->scan_results)
3242 goto init_priv_mem_out;
3243 cfg_priv->conf = kzalloc(sizeof(*cfg_priv->conf), GFP_KERNEL);
3244 if (!cfg_priv->conf)
3245 goto init_priv_mem_out;
3246 cfg_priv->profile = kzalloc(sizeof(*cfg_priv->profile), GFP_KERNEL);
3247 if (!cfg_priv->profile)
3248 goto init_priv_mem_out;
3249 cfg_priv->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
3250 if (!cfg_priv->bss_info)
3251 goto init_priv_mem_out;
3252 cfg_priv->scan_req_int = kzalloc(sizeof(*cfg_priv->scan_req_int),
3253 GFP_KERNEL);
3254 if (!cfg_priv->scan_req_int)
3255 goto init_priv_mem_out;
3256 cfg_priv->dcmd_buf = kzalloc(WL_DCMD_LEN_MAX, GFP_KERNEL);
3257 if (!cfg_priv->dcmd_buf)
3258 goto init_priv_mem_out;
3259 cfg_priv->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3260 if (!cfg_priv->extra_buf)
3261 goto init_priv_mem_out;
3262 cfg_priv->iscan = kzalloc(sizeof(*cfg_priv->iscan), GFP_KERNEL);
3263 if (!cfg_priv->iscan)
3264 goto init_priv_mem_out;
3265 cfg_priv->pmk_list = kzalloc(sizeof(*cfg_priv->pmk_list), GFP_KERNEL);
3266 if (!cfg_priv->pmk_list)
3267 goto init_priv_mem_out;
3268
3269 return 0;
3270
3271 init_priv_mem_out:
3272 brcmf_deinit_priv_mem(cfg_priv);
3273
3274 return -ENOMEM;
3275 }
3276
3277 /*
3278 * retrieve first queued event from head
3279 */
3280
3281 static struct brcmf_cfg80211_event_q *brcmf_deq_event(
3282 struct brcmf_cfg80211_priv *cfg_priv)
3283 {
3284 struct brcmf_cfg80211_event_q *e = NULL;
3285
3286 spin_lock_irq(&cfg_priv->evt_q_lock);
3287 if (!list_empty(&cfg_priv->evt_q_list)) {
3288 e = list_first_entry(&cfg_priv->evt_q_list,
3289 struct brcmf_cfg80211_event_q, evt_q_list);
3290 list_del(&e->evt_q_list);
3291 }
3292 spin_unlock_irq(&cfg_priv->evt_q_lock);
3293
3294 return e;
3295 }
3296
3297 /*
3298 ** push event to tail of the queue
3299 */
3300
3301 static s32
3302 brcmf_enq_event(struct brcmf_cfg80211_priv *cfg_priv, u32 event,
3303 const struct brcmf_event_msg *msg)
3304 {
3305 struct brcmf_cfg80211_event_q *e;
3306 s32 err = 0;
3307
3308 e = kzalloc(sizeof(struct brcmf_cfg80211_event_q), GFP_KERNEL);
3309 if (!e)
3310 return -ENOMEM;
3311
3312 e->etype = event;
3313 memcpy(&e->emsg, msg, sizeof(struct brcmf_event_msg));
3314
3315 spin_lock_irq(&cfg_priv->evt_q_lock);
3316 list_add_tail(&e->evt_q_list, &cfg_priv->evt_q_list);
3317 spin_unlock_irq(&cfg_priv->evt_q_lock);
3318
3319 return err;
3320 }
3321
3322 static void brcmf_put_event(struct brcmf_cfg80211_event_q *e)
3323 {
3324 kfree(e);
3325 }
3326
3327 static void brcmf_cfg80211_event_handler(struct work_struct *work)
3328 {
3329 struct brcmf_cfg80211_priv *cfg_priv =
3330 container_of(work, struct brcmf_cfg80211_priv,
3331 event_work);
3332 struct brcmf_cfg80211_event_q *e;
3333
3334 e = brcmf_deq_event(cfg_priv);
3335 if (unlikely(!e)) {
3336 WL_ERR("event queue empty...\n");
3337 return;
3338 }
3339
3340 do {
3341 WL_INFO("event type (%d)\n", e->etype);
3342 if (cfg_priv->el.handler[e->etype])
3343 cfg_priv->el.handler[e->etype](cfg_priv,
3344 cfg_to_ndev(cfg_priv),
3345 &e->emsg, e->edata);
3346 else
3347 WL_INFO("Unknown Event (%d): ignoring\n", e->etype);
3348 brcmf_put_event(e);
3349 } while ((e = brcmf_deq_event(cfg_priv)));
3350
3351 }
3352
3353 static void brcmf_init_eq(struct brcmf_cfg80211_priv *cfg_priv)
3354 {
3355 spin_lock_init(&cfg_priv->evt_q_lock);
3356 INIT_LIST_HEAD(&cfg_priv->evt_q_list);
3357 }
3358
3359 static void brcmf_flush_eq(struct brcmf_cfg80211_priv *cfg_priv)
3360 {
3361 struct brcmf_cfg80211_event_q *e;
3362
3363 spin_lock_irq(&cfg_priv->evt_q_lock);
3364 while (!list_empty(&cfg_priv->evt_q_list)) {
3365 e = list_first_entry(&cfg_priv->evt_q_list,
3366 struct brcmf_cfg80211_event_q, evt_q_list);
3367 list_del(&e->evt_q_list);
3368 kfree(e);
3369 }
3370 spin_unlock_irq(&cfg_priv->evt_q_lock);
3371 }
3372
3373 static s32 wl_init_priv(struct brcmf_cfg80211_priv *cfg_priv)
3374 {
3375 s32 err = 0;
3376
3377 cfg_priv->scan_request = NULL;
3378 cfg_priv->pwr_save = true;
3379 cfg_priv->iscan_on = true; /* iscan on & off switch.
3380 we enable iscan per default */
3381 cfg_priv->roam_on = true; /* roam on & off switch.
3382 we enable roam per default */
3383
3384 cfg_priv->iscan_kickstart = false;
3385 cfg_priv->active_scan = true; /* we do active scan for
3386 specific scan per default */
3387 cfg_priv->dongle_up = false; /* dongle is not up yet */
3388 brcmf_init_eq(cfg_priv);
3389 err = brcmf_init_priv_mem(cfg_priv);
3390 if (err)
3391 return err;
3392 INIT_WORK(&cfg_priv->event_work, brcmf_cfg80211_event_handler);
3393 brcmf_init_eloop_handler(&cfg_priv->el);
3394 mutex_init(&cfg_priv->usr_sync);
3395 err = brcmf_init_iscan(cfg_priv);
3396 if (err)
3397 return err;
3398 brcmf_init_conf(cfg_priv->conf);
3399 brcmf_init_prof(cfg_priv->profile);
3400 brcmf_link_down(cfg_priv);
3401
3402 return err;
3403 }
3404
3405 static void wl_deinit_priv(struct brcmf_cfg80211_priv *cfg_priv)
3406 {
3407 cancel_work_sync(&cfg_priv->event_work);
3408 cfg_priv->dongle_up = false; /* dongle down */
3409 brcmf_flush_eq(cfg_priv);
3410 brcmf_link_down(cfg_priv);
3411 brcmf_term_iscan(cfg_priv);
3412 brcmf_deinit_priv_mem(cfg_priv);
3413 }
3414
3415 struct brcmf_cfg80211_dev *brcmf_cfg80211_attach(struct net_device *ndev,
3416 struct device *busdev,
3417 void *data)
3418 {
3419 struct wireless_dev *wdev;
3420 struct brcmf_cfg80211_priv *cfg_priv;
3421 struct brcmf_cfg80211_iface *ci;
3422 struct brcmf_cfg80211_dev *cfg_dev;
3423 s32 err = 0;
3424
3425 if (!ndev) {
3426 WL_ERR("ndev is invalid\n");
3427 return NULL;
3428 }
3429 cfg_dev = kzalloc(sizeof(struct brcmf_cfg80211_dev), GFP_KERNEL);
3430 if (!cfg_dev)
3431 return NULL;
3432
3433 wdev = brcmf_alloc_wdev(sizeof(struct brcmf_cfg80211_iface), busdev);
3434 if (IS_ERR(wdev)) {
3435 kfree(cfg_dev);
3436 return NULL;
3437 }
3438
3439 wdev->iftype = brcmf_mode_to_nl80211_iftype(WL_MODE_BSS);
3440 cfg_priv = wdev_to_cfg(wdev);
3441 cfg_priv->wdev = wdev;
3442 cfg_priv->pub = data;
3443 ci = (struct brcmf_cfg80211_iface *)&cfg_priv->ci;
3444 ci->cfg_priv = cfg_priv;
3445 ndev->ieee80211_ptr = wdev;
3446 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3447 wdev->netdev = ndev;
3448 err = wl_init_priv(cfg_priv);
3449 if (err) {
3450 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3451 goto cfg80211_attach_out;
3452 }
3453 brcmf_set_drvdata(cfg_dev, ci);
3454
3455 return cfg_dev;
3456
3457 cfg80211_attach_out:
3458 brcmf_free_wdev(cfg_priv);
3459 kfree(cfg_dev);
3460 return NULL;
3461 }
3462
3463 void brcmf_cfg80211_detach(struct brcmf_cfg80211_dev *cfg_dev)
3464 {
3465 struct brcmf_cfg80211_priv *cfg_priv;
3466
3467 cfg_priv = brcmf_priv_get(cfg_dev);
3468
3469 wl_deinit_priv(cfg_priv);
3470 brcmf_free_wdev(cfg_priv);
3471 brcmf_set_drvdata(cfg_dev, NULL);
3472 kfree(cfg_dev);
3473 }
3474
3475 void
3476 brcmf_cfg80211_event(struct net_device *ndev,
3477 const struct brcmf_event_msg *e, void *data)
3478 {
3479 u32 event_type = be32_to_cpu(e->event_type);
3480 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
3481
3482 if (!brcmf_enq_event(cfg_priv, event_type, e))
3483 schedule_work(&cfg_priv->event_work);
3484 }
3485
3486 static s32 brcmf_dongle_mode(struct net_device *ndev, s32 iftype)
3487 {
3488 s32 infra = 0;
3489 s32 err = 0;
3490
3491 switch (iftype) {
3492 case NL80211_IFTYPE_MONITOR:
3493 case NL80211_IFTYPE_WDS:
3494 WL_ERR("type (%d) : currently we do not support this mode\n",
3495 iftype);
3496 err = -EINVAL;
3497 return err;
3498 case NL80211_IFTYPE_ADHOC:
3499 infra = 0;
3500 break;
3501 case NL80211_IFTYPE_STATION:
3502 infra = 1;
3503 break;
3504 default:
3505 err = -EINVAL;
3506 WL_ERR("invalid type (%d)\n", iftype);
3507 return err;
3508 }
3509 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_INFRA, &infra);
3510 if (err) {
3511 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
3512 return err;
3513 }
3514
3515 return 0;
3516 }
3517
3518 static s32 brcmf_dongle_eventmsg(struct net_device *ndev)
3519 {
3520 /* Room for "event_msgs" + '\0' + bitvec */
3521 s8 iovbuf[BRCMF_EVENTING_MASK_LEN + 12];
3522 s8 eventmask[BRCMF_EVENTING_MASK_LEN];
3523 s32 err = 0;
3524
3525 WL_TRACE("Enter\n");
3526
3527 /* Setup event_msgs */
3528 brcmf_c_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN,
3529 iovbuf, sizeof(iovbuf));
3530 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, iovbuf, sizeof(iovbuf));
3531 if (err) {
3532 WL_ERR("Get event_msgs error (%d)\n", err);
3533 goto dongle_eventmsg_out;
3534 }
3535 memcpy(eventmask, iovbuf, BRCMF_EVENTING_MASK_LEN);
3536
3537 setbit(eventmask, BRCMF_E_SET_SSID);
3538 setbit(eventmask, BRCMF_E_ROAM);
3539 setbit(eventmask, BRCMF_E_PRUNE);
3540 setbit(eventmask, BRCMF_E_AUTH);
3541 setbit(eventmask, BRCMF_E_REASSOC);
3542 setbit(eventmask, BRCMF_E_REASSOC_IND);
3543 setbit(eventmask, BRCMF_E_DEAUTH_IND);
3544 setbit(eventmask, BRCMF_E_DISASSOC_IND);
3545 setbit(eventmask, BRCMF_E_DISASSOC);
3546 setbit(eventmask, BRCMF_E_JOIN);
3547 setbit(eventmask, BRCMF_E_ASSOC_IND);
3548 setbit(eventmask, BRCMF_E_PSK_SUP);
3549 setbit(eventmask, BRCMF_E_LINK);
3550 setbit(eventmask, BRCMF_E_NDIS_LINK);
3551 setbit(eventmask, BRCMF_E_MIC_ERROR);
3552 setbit(eventmask, BRCMF_E_PMKID_CACHE);
3553 setbit(eventmask, BRCMF_E_TXFAIL);
3554 setbit(eventmask, BRCMF_E_JOIN_START);
3555 setbit(eventmask, BRCMF_E_SCAN_COMPLETE);
3556
3557 brcmf_c_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN,
3558 iovbuf, sizeof(iovbuf));
3559 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3560 if (err) {
3561 WL_ERR("Set event_msgs error (%d)\n", err);
3562 goto dongle_eventmsg_out;
3563 }
3564
3565 dongle_eventmsg_out:
3566 WL_TRACE("Exit\n");
3567 return err;
3568 }
3569
3570 static s32
3571 brcmf_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3572 {
3573 s8 iovbuf[32];
3574 s32 err = 0;
3575 __le32 roamtrigger[2];
3576 __le32 roam_delta[2];
3577 __le32 bcn_to_le;
3578 __le32 roamvar_le;
3579
3580 /*
3581 * Setup timeout if Beacons are lost and roam is
3582 * off to report link down
3583 */
3584 if (roamvar) {
3585 bcn_to_le = cpu_to_le32(bcn_timeout);
3586 brcmf_c_mkiovar("bcn_timeout", (char *)&bcn_to_le,
3587 sizeof(bcn_to_le), iovbuf, sizeof(iovbuf));
3588 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR,
3589 iovbuf, sizeof(iovbuf));
3590 if (err) {
3591 WL_ERR("bcn_timeout error (%d)\n", err);
3592 goto dongle_rom_out;
3593 }
3594 }
3595
3596 /*
3597 * Enable/Disable built-in roaming to allow supplicant
3598 * to take care of roaming
3599 */
3600 WL_INFO("Internal Roaming = %s\n", roamvar ? "Off" : "On");
3601 roamvar_le = cpu_to_le32(roamvar);
3602 brcmf_c_mkiovar("roam_off", (char *)&roamvar_le,
3603 sizeof(roamvar_le), iovbuf, sizeof(iovbuf));
3604 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3605 if (err) {
3606 WL_ERR("roam_off error (%d)\n", err);
3607 goto dongle_rom_out;
3608 }
3609
3610 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL);
3611 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL);
3612 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_ROAM_TRIGGER,
3613 (void *)roamtrigger, sizeof(roamtrigger));
3614 if (err) {
3615 WL_ERR("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
3616 goto dongle_rom_out;
3617 }
3618
3619 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA);
3620 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL);
3621 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_ROAM_DELTA,
3622 (void *)roam_delta, sizeof(roam_delta));
3623 if (err) {
3624 WL_ERR("WLC_SET_ROAM_DELTA error (%d)\n", err);
3625 goto dongle_rom_out;
3626 }
3627
3628 dongle_rom_out:
3629 return err;
3630 }
3631
3632 static s32
3633 brcmf_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
3634 s32 scan_unassoc_time, s32 scan_passive_time)
3635 {
3636 s32 err = 0;
3637 __le32 scan_assoc_tm_le = cpu_to_le32(scan_assoc_time);
3638 __le32 scan_unassoc_tm_le = cpu_to_le32(scan_unassoc_time);
3639 __le32 scan_passive_tm_le = cpu_to_le32(scan_passive_time);
3640
3641 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SCAN_CHANNEL_TIME,
3642 &scan_assoc_tm_le, sizeof(scan_assoc_tm_le));
3643 if (err) {
3644 if (err == -EOPNOTSUPP)
3645 WL_INFO("Scan assoc time is not supported\n");
3646 else
3647 WL_ERR("Scan assoc time error (%d)\n", err);
3648 goto dongle_scantime_out;
3649 }
3650 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SCAN_UNASSOC_TIME,
3651 &scan_unassoc_tm_le, sizeof(scan_unassoc_tm_le));
3652 if (err) {
3653 if (err == -EOPNOTSUPP)
3654 WL_INFO("Scan unassoc time is not supported\n");
3655 else
3656 WL_ERR("Scan unassoc time error (%d)\n", err);
3657 goto dongle_scantime_out;
3658 }
3659
3660 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SCAN_PASSIVE_TIME,
3661 &scan_passive_tm_le, sizeof(scan_passive_tm_le));
3662 if (err) {
3663 if (err == -EOPNOTSUPP)
3664 WL_INFO("Scan passive time is not supported\n");
3665 else
3666 WL_ERR("Scan passive time error (%d)\n", err);
3667 goto dongle_scantime_out;
3668 }
3669
3670 dongle_scantime_out:
3671 return err;
3672 }
3673
3674 static s32 wl_update_wiphybands(struct brcmf_cfg80211_priv *cfg_priv)
3675 {
3676 struct wiphy *wiphy;
3677 s32 phy_list;
3678 s8 phy;
3679 s32 err = 0;
3680
3681 err = brcmf_exec_dcmd(cfg_to_ndev(cfg_priv), BRCM_GET_PHYLIST,
3682 &phy_list, sizeof(phy_list));
3683 if (err) {
3684 WL_ERR("error (%d)\n", err);
3685 return err;
3686 }
3687
3688 phy = ((char *)&phy_list)[1];
3689 WL_INFO("%c phy\n", phy);
3690 if (phy == 'n' || phy == 'a') {
3691 wiphy = cfg_to_wiphy(cfg_priv);
3692 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
3693 }
3694
3695 return err;
3696 }
3697
3698 static s32 brcmf_dongle_probecap(struct brcmf_cfg80211_priv *cfg_priv)
3699 {
3700 return wl_update_wiphybands(cfg_priv);
3701 }
3702
3703 static s32 brcmf_config_dongle(struct brcmf_cfg80211_priv *cfg_priv)
3704 {
3705 struct net_device *ndev;
3706 struct wireless_dev *wdev;
3707 s32 power_mode;
3708 s32 err = 0;
3709
3710 if (cfg_priv->dongle_up)
3711 return err;
3712
3713 ndev = cfg_to_ndev(cfg_priv);
3714 wdev = ndev->ieee80211_ptr;
3715
3716 brcmf_dongle_scantime(ndev, WL_SCAN_CHANNEL_TIME,
3717 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
3718
3719 err = brcmf_dongle_eventmsg(ndev);
3720 if (err)
3721 goto default_conf_out;
3722
3723 power_mode = cfg_priv->pwr_save ? PM_FAST : PM_OFF;
3724 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_PM, &power_mode);
3725 if (err)
3726 goto default_conf_out;
3727 WL_INFO("power save set to %s\n",
3728 (power_mode ? "enabled" : "disabled"));
3729
3730 err = brcmf_dongle_roam(ndev, (cfg_priv->roam_on ? 0 : 1),
3731 WL_BEACON_TIMEOUT);
3732 if (err)
3733 goto default_conf_out;
3734 err = brcmf_dongle_mode(ndev, wdev->iftype);
3735 if (err && err != -EINPROGRESS)
3736 goto default_conf_out;
3737 err = brcmf_dongle_probecap(cfg_priv);
3738 if (err)
3739 goto default_conf_out;
3740
3741 /* -EINPROGRESS: Call commit handler */
3742
3743 default_conf_out:
3744
3745 cfg_priv->dongle_up = true;
3746
3747 return err;
3748
3749 }
3750
3751 static int brcmf_debugfs_add_netdev_params(struct brcmf_cfg80211_priv *cfg_priv)
3752 {
3753 char buf[10+IFNAMSIZ];
3754 struct dentry *fd;
3755 s32 err = 0;
3756
3757 sprintf(buf, "netdev:%s", cfg_to_ndev(cfg_priv)->name);
3758 cfg_priv->debugfsdir = debugfs_create_dir(buf,
3759 cfg_to_wiphy(cfg_priv)->debugfsdir);
3760
3761 fd = debugfs_create_u16("beacon_int", S_IRUGO, cfg_priv->debugfsdir,
3762 (u16 *)&cfg_priv->profile->beacon_interval);
3763 if (!fd) {
3764 err = -ENOMEM;
3765 goto err_out;
3766 }
3767
3768 fd = debugfs_create_u8("dtim_period", S_IRUGO, cfg_priv->debugfsdir,
3769 (u8 *)&cfg_priv->profile->dtim_period);
3770 if (!fd) {
3771 err = -ENOMEM;
3772 goto err_out;
3773 }
3774
3775 err_out:
3776 return err;
3777 }
3778
3779 static void brcmf_debugfs_remove_netdev(struct brcmf_cfg80211_priv *cfg_priv)
3780 {
3781 debugfs_remove_recursive(cfg_priv->debugfsdir);
3782 cfg_priv->debugfsdir = NULL;
3783 }
3784
3785 static s32 __brcmf_cfg80211_up(struct brcmf_cfg80211_priv *cfg_priv)
3786 {
3787 s32 err = 0;
3788
3789 set_bit(WL_STATUS_READY, &cfg_priv->status);
3790
3791 brcmf_debugfs_add_netdev_params(cfg_priv);
3792
3793 err = brcmf_config_dongle(cfg_priv);
3794 if (err)
3795 return err;
3796
3797 brcmf_invoke_iscan(cfg_priv);
3798
3799 return err;
3800 }
3801
3802 static s32 __brcmf_cfg80211_down(struct brcmf_cfg80211_priv *cfg_priv)
3803 {
3804 /*
3805 * While going down, if associated with AP disassociate
3806 * from AP to save power
3807 */
3808 if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
3809 test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
3810 test_bit(WL_STATUS_READY, &cfg_priv->status)) {
3811 WL_INFO("Disassociating from AP");
3812 brcmf_link_down(cfg_priv);
3813
3814 /* Make sure WPA_Supplicant receives all the event
3815 generated due to DISASSOC call to the fw to keep
3816 the state fw and WPA_Supplicant state consistent
3817 */
3818 brcmf_delay(500);
3819 }
3820
3821 set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3822 brcmf_term_iscan(cfg_priv);
3823 if (cfg_priv->scan_request) {
3824 cfg80211_scan_done(cfg_priv->scan_request, true);
3825 /* May need to perform this to cover rmmod */
3826 /* wl_set_mpc(cfg_to_ndev(wl), 1); */
3827 cfg_priv->scan_request = NULL;
3828 }
3829 clear_bit(WL_STATUS_READY, &cfg_priv->status);
3830 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
3831 clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3832
3833 brcmf_debugfs_remove_netdev(cfg_priv);
3834
3835 return 0;
3836 }
3837
3838 s32 brcmf_cfg80211_up(struct brcmf_cfg80211_dev *cfg_dev)
3839 {
3840 struct brcmf_cfg80211_priv *cfg_priv;
3841 s32 err = 0;
3842
3843 cfg_priv = brcmf_priv_get(cfg_dev);
3844 mutex_lock(&cfg_priv->usr_sync);
3845 err = __brcmf_cfg80211_up(cfg_priv);
3846 mutex_unlock(&cfg_priv->usr_sync);
3847
3848 return err;
3849 }
3850
3851 s32 brcmf_cfg80211_down(struct brcmf_cfg80211_dev *cfg_dev)
3852 {
3853 struct brcmf_cfg80211_priv *cfg_priv;
3854 s32 err = 0;
3855
3856 cfg_priv = brcmf_priv_get(cfg_dev);
3857 mutex_lock(&cfg_priv->usr_sync);
3858 err = __brcmf_cfg80211_down(cfg_priv);
3859 mutex_unlock(&cfg_priv->usr_sync);
3860
3861 return err;
3862 }
3863
3864 static __used s32 brcmf_add_ie(struct brcmf_cfg80211_priv *cfg_priv,
3865 u8 t, u8 l, u8 *v)
3866 {
3867 struct brcmf_cfg80211_ie *ie = &cfg_priv->ie;
3868 s32 err = 0;
3869
3870 if (ie->offset + l + 2 > WL_TLV_INFO_MAX) {
3871 WL_ERR("ei crosses buffer boundary\n");
3872 return -ENOSPC;
3873 }
3874 ie->buf[ie->offset] = t;
3875 ie->buf[ie->offset + 1] = l;
3876 memcpy(&ie->buf[ie->offset + 2], v, l);
3877 ie->offset += l + 2;
3878
3879 return err;
3880 }