projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cfg80211: clarify set tx power mBm documentation
[deliverable/linux.git] / drivers / net / wireless / brcm80211 / brcmfmac / wl_cfg80211.c
CommitLineData
5b435de0
AS		 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
39static const u8 ether_bcast[ETH_ALEN] = {255, 255, 255, 255, 255, 255};
40
41static u32 brcmf_dbg_level = WL_DBG_ERR;
42
43static void brcmf_set_drvdata(struct brcmf_cfg80211_dev *dev, void *data)
44{
45 dev->driver_data = data;
46}
47
48static 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
57static
58struct 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
64static 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
101static 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
121static 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
138static 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
160static 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
218static 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
226static 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
234static 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
242static 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
f8e4b412
AB		 250/* tag_ID/length/value_buffer tuple */
251struct brcmf_tlv {
252 u8 id;
253 u8 len;
254 u8 data[1];
255};
256
ef6ac17a
AB		 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
278static 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
287static 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
310static 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
5b435de0
AS		 341/* function for reading/writing a single u32 from/to the dongle */
342static int
343brcmf_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
354static 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
368static 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
381static s32
382brcmf_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
426done:
427 WL_TRACE("Exit\n");
428
429 return err;
430}
431
432static 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);
53a2277d 440 len = brcmf_c_mkiovar(name, (char *)(&val_le), sizeof(val_le), buf,
5b435de0
AS		 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
451static s32
452brcmf_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 =
53a2277d 463 brcmf_c_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
5b435de0
AS		 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
475static 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
490static 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
505static s32
506brcmf_dev_iovar_setbuf(struct net_device *ndev, s8 * iovar, void *param,
507 s32 paramlen, void *bufptr, s32 buflen)
508{
509 s32 iolen;
510
53a2277d 511 iolen = brcmf_c_mkiovar(iovar, param, paramlen, bufptr, buflen);
5b435de0
AS		 512 BUG_ON(!iolen);
513
514 return brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, bufptr, iolen);
515}
516
517static s32
518brcmf_dev_iovar_getbuf(struct net_device *ndev, s8 * iovar, void *param,
519 s32 paramlen, void *bufptr, s32 buflen)
520{
521 s32 iolen;
522
53a2277d 523 iolen = brcmf_c_mkiovar(iovar, param, paramlen, bufptr, buflen);
5b435de0
AS		 524 BUG_ON(!iolen);
525
526 return brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, bufptr, buflen);
527}
528
529static s32
530brcmf_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
564static 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;
66831075 569 __le32 passive_scan;
5b435de0
AS		 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
66831075 577 passive_scan = cfg_priv->active_scan ? 0 : cpu_to_le32(1);
5b435de0
AS		 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
597static 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;
66831075 605 __le32 passive_scan;
5b435de0
AS		 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
66831075 661 passive_scan = cfg_priv->active_scan ? 0 : cpu_to_le32(1);
5b435de0
AS		 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
685scan_out:
686 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
687 cfg_priv->scan_request = NULL;
688 return err;
689}
690
691static s32
692brcmf_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
710static 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
721static 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
732static 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
745static 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
784done:
785 WL_TRACE("Exit\n");
786 return err;
787}
788
789static 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
803static s32
804brcmf_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
844static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
845{
846 memset(prof, 0, sizeof(*prof));
847}
848
849static 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
876static 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
894static s32
895brcmf_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
1035done:
1036 if (err)
1037 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1038 WL_TRACE("Exit\n");
1039 return err;
1040}
1041
1042static s32
1043brcmf_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
1059static 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
1084static 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
1123static s32
1124brcmf_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
1190static s32
1191brcmf_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
1245static s32
a718e2fe 1246brcmf_set_wep_sharedkey(struct net_device *ndev,
5b435de0
AS		 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);
5b435de0 1256
a718e2fe
RV		 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;
5b435de0
AS		 1305 }
1306 }
1307 }
1308 return err;
1309}
1310
1311static s32
1312brcmf_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
a718e2fe 1368 err = brcmf_set_wep_sharedkey(ndev, sme);
5b435de0 1369 if (err) {
a718e2fe 1370 WL_ERR("brcmf_set_wep_sharedkey failed (%d)\n", err);
5b435de0
AS		 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
1396done:
1397 if (err)
1398 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1399 WL_TRACE("Exit\n");
1400 return err;
1401}
1402
1403static s32
1404brcmf_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
1430static s32
1431brcmf_cfg80211_set_tx_power(struct wiphy *wiphy,
1432 enum nl80211_tx_power_setting type, s32 dbm)
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
1441 WL_TRACE("Enter\n");
1442 if (!check_sys_up(wiphy))
1443 return -EIO;
1444
1445 switch (type) {
1446 case NL80211_TX_POWER_AUTOMATIC:
1447 break;
1448 case NL80211_TX_POWER_LIMITED:
1449 if (dbm < 0) {
1450 WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
1451 err = -EINVAL;
1452 goto done;
1453 }
1454 break;
1455 case NL80211_TX_POWER_FIXED:
1456 if (dbm < 0) {
1457 WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1458 err = -EINVAL;
1459 goto done;
1460 }
1461 break;
1462 }
1463 /* Make sure radio is off or on as far as software is concerned */
1464 disable = WL_RADIO_SW_DISABLE << 16;
1465 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_RADIO, &disable);
1466 if (err)
1467 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1468
1469 if (dbm > 0xffff)
1470 txpwrmw = 0xffff;
1471 else
1472 txpwrmw = (u16) dbm;
1473 err = brcmf_dev_intvar_set(ndev, "qtxpower",
ef6ac17a 1474 (s32) (brcmf_mw_to_qdbm(txpwrmw)));
5b435de0
AS		 1475 if (err)
1476 WL_ERR("qtxpower error (%d)\n", err);
1477 cfg_priv->conf->tx_power = dbm;
1478
1479done:
1480 WL_TRACE("Exit\n");
1481 return err;
1482}
1483
1484static s32 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1485{
1486 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1487 struct net_device *ndev = cfg_to_ndev(cfg_priv);
1488 s32 txpwrdbm;
1489 u8 result;
1490 s32 err = 0;
1491
1492 WL_TRACE("Enter\n");
1493 if (!check_sys_up(wiphy))
1494 return -EIO;
1495
1496 err = brcmf_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1497 if (err) {
1498 WL_ERR("error (%d)\n", err);
1499 goto done;
1500 }
1501
1502 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
ef6ac17a 1503 *dbm = (s32) brcmf_qdbm_to_mw(result);
5b435de0
AS		 1504
1505done:
1506 WL_TRACE("Exit\n");
1507 return err;
1508}
1509
1510static s32
1511brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *ndev,
1512 u8 key_idx, bool unicast, bool multicast)
1513{
1514 u32 index;
1515 u32 wsec;
1516 s32 err = 0;
1517
1518 WL_TRACE("Enter\n");
1519 WL_CONN("key index (%d)\n", key_idx);
1520 if (!check_sys_up(wiphy))
1521 return -EIO;
1522
1523 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_GET_WSEC, &wsec);
1524 if (err) {
1525 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1526 goto done;
1527 }
1528
1529 if (wsec & WEP_ENABLED) {
1530 /* Just select a new current key */
1531 index = key_idx;
1532 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_KEY_PRIMARY,
1533 &index);
1534 if (err)
1535 WL_ERR("error (%d)\n", err);
1536 }
1537done:
1538 WL_TRACE("Exit\n");
1539 return err;
1540}
1541
1542static s32
1543brcmf_add_keyext(struct wiphy *wiphy, struct net_device *ndev,
1544 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1545{
1546 struct brcmf_wsec_key key;
1547 struct brcmf_wsec_key_le key_le;
1548 s32 err = 0;
1549
1550 memset(&key, 0, sizeof(key));
1551 key.index = (u32) key_idx;
1552 /* Instead of bcast for ea address for default wep keys,
1553 driver needs it to be Null */
1554 if (!is_multicast_ether_addr(mac_addr))
1555 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1556 key.len = (u32) params->key_len;
1557 /* check for key index change */
1558 if (key.len == 0) {
1559 /* key delete */
1560 err = send_key_to_dongle(ndev, &key);
1561 if (err)
1562 return err;
1563 } else {
1564 if (key.len > sizeof(key.data)) {
1565 WL_ERR("Invalid key length (%d)\n", key.len);
1566 return -EINVAL;
1567 }
1568
1569 WL_CONN("Setting the key index %d\n", key.index);
1570 memcpy(key.data, params->key, key.len);
1571
1572 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1573 u8 keybuf[8];
1574 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1575 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1576 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1577 }
1578
1579 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1580 if (params->seq && params->seq_len == 6) {
1581 /* rx iv */
1582 u8 *ivptr;
1583 ivptr = (u8 *) params->seq;
1584 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1585 (ivptr[3] << 8) | ivptr[2];
1586 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1587 key.iv_initialized = true;
1588 }
1589
1590 switch (params->cipher) {
1591 case WLAN_CIPHER_SUITE_WEP40:
1592 key.algo = CRYPTO_ALGO_WEP1;
1593 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1594 break;
1595 case WLAN_CIPHER_SUITE_WEP104:
1596 key.algo = CRYPTO_ALGO_WEP128;
1597 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1598 break;
1599 case WLAN_CIPHER_SUITE_TKIP:
1600 key.algo = CRYPTO_ALGO_TKIP;
1601 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1602 break;
1603 case WLAN_CIPHER_SUITE_AES_CMAC:
1604 key.algo = CRYPTO_ALGO_AES_CCM;
1605 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1606 break;
1607 case WLAN_CIPHER_SUITE_CCMP:
1608 key.algo = CRYPTO_ALGO_AES_CCM;
1609 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1610 break;
1611 default:
1612 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1613 return -EINVAL;
1614 }
1615 convert_key_from_CPU(&key, &key_le);
1616
1617 brcmf_netdev_wait_pend8021x(ndev);
1618 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_KEY, &key_le,
1619 sizeof(key_le));
1620 if (err) {
1621 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1622 return err;
1623 }
1624 }
1625 return err;
1626}
1627
1628static s32
1629brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
1630 u8 key_idx, bool pairwise, const u8 *mac_addr,
1631 struct key_params *params)
1632{
1633 struct brcmf_wsec_key key;
1634 s32 val;
1635 s32 wsec;
1636 s32 err = 0;
1637 u8 keybuf[8];
1638
1639 WL_TRACE("Enter\n");
1640 WL_CONN("key index (%d)\n", key_idx);
1641 if (!check_sys_up(wiphy))
1642 return -EIO;
1643
1644 if (mac_addr) {
1645 WL_TRACE("Exit");
1646 return brcmf_add_keyext(wiphy, ndev, key_idx, mac_addr, params);
1647 }
1648 memset(&key, 0, sizeof(key));
1649
1650 key.len = (u32) params->key_len;
1651 key.index = (u32) key_idx;
1652
1653 if (key.len > sizeof(key.data)) {
1654 WL_ERR("Too long key length (%u)\n", key.len);
1655 err = -EINVAL;
1656 goto done;
1657 }
1658 memcpy(key.data, params->key, key.len);
1659
1660 key.flags = BRCMF_PRIMARY_KEY;
1661 switch (params->cipher) {
1662 case WLAN_CIPHER_SUITE_WEP40:
1663 key.algo = CRYPTO_ALGO_WEP1;
1664 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1665 break;
1666 case WLAN_CIPHER_SUITE_WEP104:
1667 key.algo = CRYPTO_ALGO_WEP128;
1668 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1669 break;
1670 case WLAN_CIPHER_SUITE_TKIP:
1671 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1672 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1673 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1674 key.algo = CRYPTO_ALGO_TKIP;
1675 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1676 break;
1677 case WLAN_CIPHER_SUITE_AES_CMAC:
1678 key.algo = CRYPTO_ALGO_AES_CCM;
1679 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1680 break;
1681 case WLAN_CIPHER_SUITE_CCMP:
1682 key.algo = CRYPTO_ALGO_AES_CCM;
1683 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1684 break;
1685 default:
1686 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1687 err = -EINVAL;
1688 goto done;
1689 }
1690
1691 err = send_key_to_dongle(ndev, &key); /* Set the new key/index */
1692 if (err)
1693 goto done;
1694
1695 val = WEP_ENABLED;
1696 err = brcmf_dev_intvar_get(ndev, "wsec", &wsec);
1697 if (err) {
1698 WL_ERR("get wsec error (%d)\n", err);
1699 goto done;
1700 }
1701 wsec &= ~(WEP_ENABLED);
1702 wsec |= val;
1703 err = brcmf_dev_intvar_set(ndev, "wsec", wsec);
1704 if (err) {
1705 WL_ERR("set wsec error (%d)\n", err);
1706 goto done;
1707 }
1708
1709 val = 1; /* assume shared key. otherwise 0 */
1710 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_AUTH, &val);
1711 if (err)
1712 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1713done:
1714 WL_TRACE("Exit\n");
1715 return err;
1716}
1717
1718static s32
1719brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
1720 u8 key_idx, bool pairwise, const u8 *mac_addr)
1721{
1722 struct brcmf_wsec_key key;
1723 s32 err = 0;
1724 s32 val;
1725 s32 wsec;
1726
1727 WL_TRACE("Enter\n");
1728 if (!check_sys_up(wiphy))
1729 return -EIO;
1730
1731 memset(&key, 0, sizeof(key));
1732
1733 key.index = (u32) key_idx;
1734 key.flags = BRCMF_PRIMARY_KEY;
1735 key.algo = CRYPTO_ALGO_OFF;
1736
1737 WL_CONN("key index (%d)\n", key_idx);
1738
1739 /* Set the new key/index */
1740 err = send_key_to_dongle(ndev, &key);
1741 if (err) {
1742 if (err == -EINVAL) {
1743 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
1744 /* we ignore this key index in this case */
1745 WL_ERR("invalid key index (%d)\n", key_idx);
1746 }
1747 /* Ignore this error, may happen during DISASSOC */
1748 err = -EAGAIN;
1749 goto done;
1750 }
1751
1752 val = 0;
1753 err = brcmf_dev_intvar_get(ndev, "wsec", &wsec);
1754 if (err) {
1755 WL_ERR("get wsec error (%d)\n", err);
1756 /* Ignore this error, may happen during DISASSOC */
1757 err = -EAGAIN;
1758 goto done;
1759 }
1760 wsec &= ~(WEP_ENABLED);
1761 wsec |= val;
1762 err = brcmf_dev_intvar_set(ndev, "wsec", wsec);
1763 if (err) {
1764 WL_ERR("set wsec error (%d)\n", err);
1765 /* Ignore this error, may happen during DISASSOC */
1766 err = -EAGAIN;
1767 goto done;
1768 }
1769
1770 val = 0; /* assume open key. otherwise 1 */
1771 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_AUTH, &val);
1772 if (err) {
1773 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1774 /* Ignore this error, may happen during DISASSOC */
1775 err = -EAGAIN;
1776 }
1777done:
1778 WL_TRACE("Exit\n");
1779 return err;
1780}
1781
1782static s32
1783brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
1784 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1785 void (*callback) (void *cookie, struct key_params * params))
1786{
1787 struct key_params params;
1788 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1789 struct brcmf_cfg80211_security *sec;
1790 s32 wsec;
1791 s32 err = 0;
1792
1793 WL_TRACE("Enter\n");
1794 WL_CONN("key index (%d)\n", key_idx);
1795 if (!check_sys_up(wiphy))
1796 return -EIO;
1797
1798 memset(&params, 0, sizeof(params));
1799
1800 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_GET_WSEC, &wsec);
1801 if (err) {
1802 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1803 /* Ignore this error, may happen during DISASSOC */
1804 err = -EAGAIN;
1805 goto done;
1806 }
1807 switch (wsec) {
1808 case WEP_ENABLED:
1809 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1810 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1811 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1812 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1813 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1814 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1815 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1816 }
1817 break;
1818 case TKIP_ENABLED:
1819 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1820 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1821 break;
1822 case AES_ENABLED:
1823 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1824 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1825 break;
1826 default:
1827 WL_ERR("Invalid algo (0x%x)\n", wsec);
1828 err = -EINVAL;
1829 goto done;
1830 }
1831 callback(cookie, &params);
1832
1833done:
1834 WL_TRACE("Exit\n");
1835 return err;
1836}
1837
1838static s32
1839brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1840 struct net_device *ndev, u8 key_idx)
1841{
1842 WL_INFO("Not supported\n");
1843
1844 return -EOPNOTSUPP;
1845}
1846
1847static s32
1848brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *ndev,
1849 u8 *mac, struct station_info *sinfo)
1850{
1851 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1852 struct brcmf_scb_val_le scb_val;
1853 int rssi;
1854 s32 rate;
1855 s32 err = 0;
1856 u8 *bssid = brcmf_read_prof(cfg_priv, WL_PROF_BSSID);
1857
1858 WL_TRACE("Enter\n");
1859 if (!check_sys_up(wiphy))
1860 return -EIO;
1861
1862 if (memcmp(mac, bssid, ETH_ALEN)) {
1863 WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
1864 "wl_bssid-%X:%X:%X:%X:%X:%X\n",
1865 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
1866 bssid[0], bssid[1], bssid[2], bssid[3],
1867 bssid[4], bssid[5]);
1868 err = -ENOENT;
1869 goto done;
1870 }
1871
1872 /* Report the current tx rate */
1873 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_GET_RATE, &rate);
1874 if (err) {
1875 WL_ERR("Could not get rate (%d)\n", err);
1876 } else {
1877 sinfo->filled |= STATION_INFO_TX_BITRATE;
1878 sinfo->txrate.legacy = rate * 5;
1879 WL_CONN("Rate %d Mbps\n", rate / 2);
1880 }
1881
1882 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status)) {
1883 scb_val.val = cpu_to_le32(0);
1884 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_RSSI, &scb_val,
1885 sizeof(struct brcmf_scb_val_le));
1886 if (err)
1887 WL_ERR("Could not get rssi (%d)\n", err);
1888
1889 rssi = le32_to_cpu(scb_val.val);
1890 sinfo->filled |= STATION_INFO_SIGNAL;
1891 sinfo->signal = rssi;
1892 WL_CONN("RSSI %d dBm\n", rssi);
1893 }
1894
1895done:
1896 WL_TRACE("Exit\n");
1897 return err;
1898}
1899
1900static s32
1901brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *ndev,
1902 bool enabled, s32 timeout)
1903{
1904 s32 pm;
1905 s32 err = 0;
1906 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1907
1908 WL_TRACE("Enter\n");
1909
1910 /*
1911 * Powersave enable/disable request is coming from the
1912 * cfg80211 even before the interface is up. In that
1913 * scenario, driver will be storing the power save
1914 * preference in cfg_priv struct to apply this to
1915 * FW later while initializing the dongle
1916 */
1917 cfg_priv->pwr_save = enabled;
1918 if (!test_bit(WL_STATUS_READY, &cfg_priv->status)) {
1919
1920 WL_INFO("Device is not ready,"
1921 "storing the value in cfg_priv struct\n");
1922 goto done;
1923 }
1924
1925 pm = enabled ? PM_FAST : PM_OFF;
1926 WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
1927
1928 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_PM, &pm);
1929 if (err) {
1930 if (err == -ENODEV)
1931 WL_ERR("net_device is not ready yet\n");
1932 else
1933 WL_ERR("error (%d)\n", err);
1934 }
1935done:
1936 WL_TRACE("Exit\n");
1937 return err;
1938}
1939
1940static s32
1941brcmf_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *ndev,
1942 const u8 *addr,
1943 const struct cfg80211_bitrate_mask *mask)
1944{
1945 struct brcm_rateset_le rateset_le;
1946 s32 rate;
1947 s32 val;
1948 s32 err_bg;
1949 s32 err_a;
1950 u32 legacy;
1951 s32 err = 0;
1952
1953 WL_TRACE("Enter\n");
1954 if (!check_sys_up(wiphy))
1955 return -EIO;
1956
1957 /* addr param is always NULL. ignore it */
1958 /* Get current rateset */
1959 err = brcmf_exec_dcmd(ndev, BRCM_GET_CURR_RATESET, &rateset_le,
1960 sizeof(rateset_le));
1961 if (err) {
1962 WL_ERR("could not get current rateset (%d)\n", err);
1963 goto done;
1964 }
1965
1966 legacy = ffs(mask->control[IEEE80211_BAND_2GHZ].legacy & 0xFFFF);
1967 if (!legacy)
1968 legacy = ffs(mask->control[IEEE80211_BAND_5GHZ].legacy &
1969 0xFFFF);
1970
1971 val = wl_g_rates[legacy - 1].bitrate * 100000;
1972
1973 if (val < le32_to_cpu(rateset_le.count))
1974 /* Select rate by rateset index */
1975 rate = rateset_le.rates[val] & 0x7f;
1976 else
1977 /* Specified rate in bps */
1978 rate = val / 500000;
1979
1980 WL_CONN("rate %d mbps\n", rate / 2);
1981
1982 /*
1983 *
1984 * Set rate override,
1985 * Since the is a/b/g-blind, both a/bg_rate are enforced.
1986 */
1987 err_bg = brcmf_dev_intvar_set(ndev, "bg_rate", rate);
1988 err_a = brcmf_dev_intvar_set(ndev, "a_rate", rate);
1989 if (err_bg && err_a) {
1990 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
1991 err = err_bg | err_a;
1992 }
1993
1994done:
1995 WL_TRACE("Exit\n");
1996 return err;
1997}
1998
1999static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_priv *cfg_priv,
d34bf64f 2000 struct brcmf_bss_info_le *bi)
5b435de0
AS		 2001{
2002 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2003 struct ieee80211_channel *notify_channel;
2004 struct cfg80211_bss *bss;
2005 struct ieee80211_supported_band *band;
2006 s32 err = 0;
2007 u16 channel;
2008 u32 freq;
2009 u64 notify_timestamp;
2010 u16 notify_capability;
2011 u16 notify_interval;
2012 u8 *notify_ie;
2013 size_t notify_ielen;
2014 s32 notify_signal;
2015
2016 if (le32_to_cpu(bi->length) > WL_BSS_INFO_MAX) {
2017 WL_ERR("Bss info is larger than buffer. Discarding\n");
2018 return 0;
2019 }
2020
2021 channel = bi->ctl_ch ? bi->ctl_ch :
2022 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2023
2024 if (channel <= CH_MAX_2G_CHANNEL)
2025 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2026 else
2027 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2028
2029 freq = ieee80211_channel_to_frequency(channel, band->band);
2030 notify_channel = ieee80211_get_channel(wiphy, freq);
2031
2032 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2033 notify_capability = le16_to_cpu(bi->capability);
2034 notify_interval = le16_to_cpu(bi->beacon_period);
2035 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2036 notify_ielen = le32_to_cpu(bi->ie_length);
2037 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2038
2039 WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2040 bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
2041 bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
2042 WL_CONN("Channel: %d(%d)\n", channel, freq);
2043 WL_CONN("Capability: %X\n", notify_capability);
2044 WL_CONN("Beacon interval: %d\n", notify_interval);
2045 WL_CONN("Signal: %d\n", notify_signal);
2046 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2047
2048 bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2049 notify_timestamp, notify_capability, notify_interval, notify_ie,
2050 notify_ielen, notify_signal, GFP_KERNEL);
2051
e78946e1
FL		 2052 if (!bss)
2053 return -ENOMEM;
2054
2055 cfg80211_put_bss(bss);
5b435de0
AS		 2056
2057 return err;
2058}
2059
6f09be0a
RV		 2060static struct brcmf_bss_info_le *
2061next_bss_le(struct brcmf_scan_results *list, struct brcmf_bss_info_le *bss)
2062{
2063 if (bss == NULL)
2064 return list->bss_info_le;
2065 return (struct brcmf_bss_info_le *)((unsigned long)bss +
2066 le32_to_cpu(bss->length));
2067}
2068
5b435de0
AS		 2069static s32 brcmf_inform_bss(struct brcmf_cfg80211_priv *cfg_priv)
2070{
2071 struct brcmf_scan_results *bss_list;
d34bf64f 2072 struct brcmf_bss_info_le *bi = NULL; /* must be initialized */
5b435de0
AS		 2073 s32 err = 0;
2074 int i;
2075
2076 bss_list = cfg_priv->bss_list;
2077 if (bss_list->version != BRCMF_BSS_INFO_VERSION) {
2078 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2079 bss_list->version);
2080 return -EOPNOTSUPP;
2081 }
2082 WL_SCAN("scanned AP count (%d)\n", bss_list->count);
2083 for (i = 0; i < bss_list->count && i < WL_AP_MAX; i++) {
6f09be0a 2084 bi = next_bss_le(bss_list, bi);
5b435de0
AS		 2085 err = brcmf_inform_single_bss(cfg_priv, bi);
2086 if (err)
2087 break;
2088 }
2089 return err;
2090}
2091
2092static s32 wl_inform_ibss(struct brcmf_cfg80211_priv *cfg_priv,
2093 struct net_device *ndev, const u8 *bssid)
2094{
2095 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2096 struct ieee80211_channel *notify_channel;
d34bf64f 2097 struct brcmf_bss_info_le *bi = NULL;
5b435de0 2098 struct ieee80211_supported_band *band;
e78946e1 2099 struct cfg80211_bss *bss;
5b435de0
AS		 2100 u8 *buf = NULL;
2101 s32 err = 0;
2102 u16 channel;
2103 u32 freq;
2104 u64 notify_timestamp;
2105 u16 notify_capability;
2106 u16 notify_interval;
2107 u8 *notify_ie;
2108 size_t notify_ielen;
2109 s32 notify_signal;
2110
2111 WL_TRACE("Enter\n");
2112
2113 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2114 if (buf == NULL) {
2115 err = -ENOMEM;
2116 goto CleanUp;
2117 }
2118
2119 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2120
2121 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
2122 if (err) {
2123 WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
2124 goto CleanUp;
2125 }
2126
d34bf64f 2127 bi = (struct brcmf_bss_info_le *)(buf + 4);
5b435de0
AS		 2128
2129 channel = bi->ctl_ch ? bi->ctl_ch :
2130 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2131
2132 if (channel <= CH_MAX_2G_CHANNEL)
2133 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2134 else
2135 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2136
2137 freq = ieee80211_channel_to_frequency(channel, band->band);
2138 notify_channel = ieee80211_get_channel(wiphy, freq);
2139
2140 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2141 notify_capability = le16_to_cpu(bi->capability);
2142 notify_interval = le16_to_cpu(bi->beacon_period);
2143 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2144 notify_ielen = le32_to_cpu(bi->ie_length);
2145 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2146
2147 WL_CONN("channel: %d(%d)\n", channel, freq);
2148 WL_CONN("capability: %X\n", notify_capability);
2149 WL_CONN("beacon interval: %d\n", notify_interval);
2150 WL_CONN("signal: %d\n", notify_signal);
2151 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2152
e78946e1 2153 bss = cfg80211_inform_bss(wiphy, notify_channel, bssid,
5b435de0
AS		 2154 notify_timestamp, notify_capability, notify_interval,
2155 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2156
e78946e1
FL		 2157 if (!bss) {
2158 err = -ENOMEM;
2159 goto CleanUp;
2160 }
2161
2162 cfg80211_put_bss(bss);
2163
5b435de0
AS		 2164CleanUp:
2165
2166 kfree(buf);
2167
2168 WL_TRACE("Exit\n");
2169
2170 return err;
2171}
2172
2173static bool brcmf_is_ibssmode(struct brcmf_cfg80211_priv *cfg_priv)
2174{
2175 return cfg_priv->conf->mode == WL_MODE_IBSS;
2176}
2177
f8e4b412
AB		 2178/*
2179 * Traverse a string of 1-byte tag/1-byte length/variable-length value
2180 * triples, returning a pointer to the substring whose first element
2181 * matches tag
2182 */
2183static struct brcmf_tlv *brcmf_parse_tlvs(void *buf, int buflen, uint key)
2184{
2185 struct brcmf_tlv *elt;
2186 int totlen;
2187
2188 elt = (struct brcmf_tlv *) buf;
2189 totlen = buflen;
2190
2191 /* find tagged parameter */
2192 while (totlen >= 2) {
2193 int len = elt->len;
2194
2195 /* validate remaining totlen */
2196 if ((elt->id == key) && (totlen >= (len + 2)))
2197 return elt;
2198
2199 elt = (struct brcmf_tlv *) ((u8 *) elt + (len + 2));
2200 totlen -= (len + 2);
2201 }
2202
2203 return NULL;
2204}
2205
5b435de0
AS		 2206static s32 brcmf_update_bss_info(struct brcmf_cfg80211_priv *cfg_priv)
2207{
d34bf64f 2208 struct brcmf_bss_info_le *bi;
5b435de0 2209 struct brcmf_ssid *ssid;
f8e4b412 2210 struct brcmf_tlv *tim;
5b435de0
AS		 2211 u16 beacon_interval;
2212 u8 dtim_period;
2213 size_t ie_len;
2214 u8 *ie;
2215 s32 err = 0;
2216
2217 WL_TRACE("Enter\n");
2218 if (brcmf_is_ibssmode(cfg_priv))
2219 return err;
2220
2221 ssid = (struct brcmf_ssid *)brcmf_read_prof(cfg_priv, WL_PROF_SSID);
2222
2223 *(__le32 *)cfg_priv->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2224 err = brcmf_exec_dcmd(cfg_to_ndev(cfg_priv), BRCMF_C_GET_BSS_INFO,
2225 cfg_priv->extra_buf, WL_EXTRA_BUF_MAX);
2226 if (err) {
2227 WL_ERR("Could not get bss info %d\n", err);
2228 goto update_bss_info_out;
2229 }
2230
d34bf64f 2231 bi = (struct brcmf_bss_info_le *)(cfg_priv->extra_buf + 4);
5b435de0
AS		 2232 err = brcmf_inform_single_bss(cfg_priv, bi);
2233 if (err)
2234 goto update_bss_info_out;
2235
2236 ie = ((u8 *)bi) + le16_to_cpu(bi->ie_offset);
2237 ie_len = le32_to_cpu(bi->ie_length);
2238 beacon_interval = le16_to_cpu(bi->beacon_period);
2239
f8e4b412 2240 tim = brcmf_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
5b435de0
AS		 2241 if (tim)
2242 dtim_period = tim->data[1];
2243 else {
2244 /*
2245 * active scan was done so we could not get dtim
2246 * information out of probe response.
2247 * so we speficially query dtim information to dongle.
2248 */
2249 u32 var;
2250 err = brcmf_dev_intvar_get(cfg_to_ndev(cfg_priv),
2251 "dtim_assoc", &var);
2252 if (err) {
2253 WL_ERR("wl dtim_assoc failed (%d)\n", err);
2254 goto update_bss_info_out;
2255 }
2256 dtim_period = (u8)var;
2257 }
2258
2259 brcmf_update_prof(cfg_priv, NULL, &beacon_interval, WL_PROF_BEACONINT);
2260 brcmf_update_prof(cfg_priv, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2261
2262update_bss_info_out:
2263 WL_TRACE("Exit");
2264 return err;
2265}
2266
2267static void brcmf_term_iscan(struct brcmf_cfg80211_priv *cfg_priv)
2268{
2269 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
2270 struct brcmf_ssid ssid;
2271
2272 if (cfg_priv->iscan_on) {
2273 iscan->state = WL_ISCAN_STATE_IDLE;
2274
2275 if (iscan->timer_on) {
2276 del_timer_sync(&iscan->timer);
2277 iscan->timer_on = 0;
2278 }
2279
2280 cancel_work_sync(&iscan->work);
2281
2282 /* Abort iscan running in FW */
2283 memset(&ssid, 0, sizeof(ssid));
2284 brcmf_run_iscan(iscan, &ssid, WL_SCAN_ACTION_ABORT);
2285 }
2286}
2287
2288static void brcmf_notify_iscan_complete(struct brcmf_cfg80211_iscan_ctrl *iscan,
2289 bool aborted)
2290{
2291 struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
2292 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2293
2294 if (!test_and_clear_bit(WL_STATUS_SCANNING, &cfg_priv->status)) {
2295 WL_ERR("Scan complete while device not scanning\n");
2296 return;
2297 }
2298 if (cfg_priv->scan_request) {
2299 WL_SCAN("ISCAN Completed scan: %s\n",
2300 aborted ? "Aborted" : "Done");
2301 cfg80211_scan_done(cfg_priv->scan_request, aborted);
2302 brcmf_set_mpc(ndev, 1);
2303 cfg_priv->scan_request = NULL;
2304 }
2305 cfg_priv->iscan_kickstart = false;
2306}
2307
2308static s32 brcmf_wakeup_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan)
2309{
2310 if (iscan->state != WL_ISCAN_STATE_IDLE) {
2311 WL_SCAN("wake up iscan\n");
2312 schedule_work(&iscan->work);
2313 return 0;
2314 }
2315
2316 return -EIO;
2317}
2318
2319static s32
2320brcmf_get_iscan_results(struct brcmf_cfg80211_iscan_ctrl *iscan, u32 *status,
2321 struct brcmf_scan_results **bss_list)
2322{
2323 struct brcmf_iscan_results list;
2324 struct brcmf_scan_results *results;
2325 struct brcmf_scan_results_le *results_le;
2326 struct brcmf_iscan_results *list_buf;
2327 s32 err = 0;
2328
2329 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
2330 list_buf = (struct brcmf_iscan_results *)iscan->scan_buf;
2331 results = &list_buf->results;
2332 results_le = &list_buf->results_le;
2333 results->buflen = BRCMF_ISCAN_RESULTS_FIXED_SIZE;
2334 results->version = 0;
2335 results->count = 0;
2336
2337 memset(&list, 0, sizeof(list));
2338 list.results_le.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
2339 err = brcmf_dev_iovar_getbuf(iscan->ndev, "iscanresults", &list,
2340 BRCMF_ISCAN_RESULTS_FIXED_SIZE,
2341 iscan->scan_buf, WL_ISCAN_BUF_MAX);
2342 if (err) {
2343 WL_ERR("error (%d)\n", err);
2344 return err;
2345 }
2346 results->buflen = le32_to_cpu(results_le->buflen);
2347 results->version = le32_to_cpu(results_le->version);
2348 results->count = le32_to_cpu(results_le->count);
2349 WL_SCAN("results->count = %d\n", results_le->count);
2350 WL_SCAN("results->buflen = %d\n", results_le->buflen);
2351 *status = le32_to_cpu(list_buf->status_le);
2352 WL_SCAN("status = %d\n", *status);
2353 *bss_list = results;
2354
2355 return err;
2356}
2357
2358static s32 brcmf_iscan_done(struct brcmf_cfg80211_priv *cfg_priv)
2359{
2360 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2361 s32 err = 0;
2362
2363 iscan->state = WL_ISCAN_STATE_IDLE;
2364 brcmf_inform_bss(cfg_priv);
2365 brcmf_notify_iscan_complete(iscan, false);
2366
2367 return err;
2368}
2369
2370static s32 brcmf_iscan_pending(struct brcmf_cfg80211_priv *cfg_priv)
2371{
2372 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2373 s32 err = 0;
2374
2375 /* Reschedule the timer */
2376 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
2377 iscan->timer_on = 1;
2378
2379 return err;
2380}
2381
2382static s32 brcmf_iscan_inprogress(struct brcmf_cfg80211_priv *cfg_priv)
2383{
2384 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2385 s32 err = 0;
2386
2387 brcmf_inform_bss(cfg_priv);
2388 brcmf_run_iscan(iscan, NULL, BRCMF_SCAN_ACTION_CONTINUE);
2389 /* Reschedule the timer */
2390 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
2391 iscan->timer_on = 1;
2392
2393 return err;
2394}
2395
2396static s32 brcmf_iscan_aborted(struct brcmf_cfg80211_priv *cfg_priv)
2397{
2398 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
2399 s32 err = 0;
2400
2401 iscan->state = WL_ISCAN_STATE_IDLE;
2402 brcmf_notify_iscan_complete(iscan, true);
2403
2404 return err;
2405}
2406
2407static void brcmf_cfg80211_iscan_handler(struct work_struct *work)
2408{
2409 struct brcmf_cfg80211_iscan_ctrl *iscan =
2410 container_of(work, struct brcmf_cfg80211_iscan_ctrl,
2411 work);
2412 struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
2413 struct brcmf_cfg80211_iscan_eloop *el = &iscan->el;
2414 u32 status = BRCMF_SCAN_RESULTS_PARTIAL;
2415
2416 if (iscan->timer_on) {
2417 del_timer_sync(&iscan->timer);
2418 iscan->timer_on = 0;
2419 }
2420
2421 if (brcmf_get_iscan_results(iscan, &status, &cfg_priv->bss_list)) {
2422 status = BRCMF_SCAN_RESULTS_ABORTED;
2423 WL_ERR("Abort iscan\n");
2424 }
2425
2426 el->handler[status](cfg_priv);
2427}
2428
2429static void brcmf_iscan_timer(unsigned long data)
2430{
2431 struct brcmf_cfg80211_iscan_ctrl *iscan =
2432 (struct brcmf_cfg80211_iscan_ctrl *)data;
2433
2434 if (iscan) {
2435 iscan->timer_on = 0;
2436 WL_SCAN("timer expired\n");
2437 brcmf_wakeup_iscan(iscan);
2438 }
2439}
2440
2441static s32 brcmf_invoke_iscan(struct brcmf_cfg80211_priv *cfg_priv)
2442{
2443 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
2444
2445 if (cfg_priv->iscan_on) {
2446 iscan->state = WL_ISCAN_STATE_IDLE;
2447 INIT_WORK(&iscan->work, brcmf_cfg80211_iscan_handler);
2448 }
2449
2450 return 0;
2451}
2452
2453static void brcmf_init_iscan_eloop(struct brcmf_cfg80211_iscan_eloop *el)
2454{
2455 memset(el, 0, sizeof(*el));
2456 el->handler[BRCMF_SCAN_RESULTS_SUCCESS] = brcmf_iscan_done;
2457 el->handler[BRCMF_SCAN_RESULTS_PARTIAL] = brcmf_iscan_inprogress;
2458 el->handler[BRCMF_SCAN_RESULTS_PENDING] = brcmf_iscan_pending;
2459 el->handler[BRCMF_SCAN_RESULTS_ABORTED] = brcmf_iscan_aborted;
2460 el->handler[BRCMF_SCAN_RESULTS_NO_MEM] = brcmf_iscan_aborted;
2461}
2462
2463static s32 brcmf_init_iscan(struct brcmf_cfg80211_priv *cfg_priv)
2464{
2465 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
2466 int err = 0;
2467
2468 if (cfg_priv->iscan_on) {
2469 iscan->ndev = cfg_to_ndev(cfg_priv);
2470 brcmf_init_iscan_eloop(&iscan->el);
2471 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
2472 init_timer(&iscan->timer);
2473 iscan->timer.data = (unsigned long) iscan;
2474 iscan->timer.function = brcmf_iscan_timer;
2475 err = brcmf_invoke_iscan(cfg_priv);
2476 if (!err)
2477 iscan->data = cfg_priv;
2478 }
2479
2480 return err;
2481}
2482
2483static void brcmf_delay(u32 ms)
2484{
2485 if (ms < 1000 / HZ) {
2486 cond_resched();
2487 mdelay(ms);
2488 } else {
2489 msleep(ms);
2490 }
2491}
2492
2493static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
2494{
2495 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2496
2497 /*
2498 * Check for WL_STATUS_READY before any function call which
2499 * could result is bus access. Don't block the resume for
2500 * any driver error conditions
2501 */
2502 WL_TRACE("Enter\n");
2503
2504 if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2505 brcmf_invoke_iscan(wiphy_to_cfg(wiphy));
2506
2507 WL_TRACE("Exit\n");
2508 return 0;
2509}
2510
2511static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
2512 struct cfg80211_wowlan *wow)
2513{
2514 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2515 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2516
2517 WL_TRACE("Enter\n");
2518
2519 /*
2520 * Check for WL_STATUS_READY before any function call which
2521 * could result is bus access. Don't block the suspend for
2522 * any driver error conditions
2523 */
2524
2525 /*
2526 * While going to suspend if associated with AP disassociate
2527 * from AP to save power while system is in suspended state
2528 */
2529 if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
2530 test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
2531 test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2532 WL_INFO("Disassociating from AP"
2533 " while entering suspend state\n");
2534 brcmf_link_down(cfg_priv);
2535
2536 /*
2537 * Make sure WPA_Supplicant receives all the event
2538 * generated due to DISASSOC call to the fw to keep
2539 * the state fw and WPA_Supplicant state consistent
2540 */
2541 brcmf_delay(500);
2542 }
2543
2544 set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2545 if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2546 brcmf_term_iscan(cfg_priv);
2547
2548 if (cfg_priv->scan_request) {
2549 /* Indidate scan abort to cfg80211 layer */
2550 WL_INFO("Terminating scan in progress\n");
2551 cfg80211_scan_done(cfg_priv->scan_request, true);
2552 cfg_priv->scan_request = NULL;
2553 }
2554 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
2555 clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2556
2557 /* Turn off watchdog timer */
2558 if (test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2559 WL_INFO("Enable MPC\n");
2560 brcmf_set_mpc(ndev, 1);
2561 }
2562
2563 WL_TRACE("Exit\n");
2564
2565 return 0;
2566}
2567
2568static __used s32
2569brcmf_dev_bufvar_set(struct net_device *ndev, s8 *name, s8 *buf, s32 len)
2570{
2571 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
2572 u32 buflen;
2573
53a2277d 2574 buflen = brcmf_c_mkiovar(name, buf, len, cfg_priv->dcmd_buf,
5b435de0
AS		 2575 WL_DCMD_LEN_MAX);
2576 BUG_ON(!buflen);
2577
2578 return brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, cfg_priv->dcmd_buf,
2579 buflen);
2580}
2581
2582static s32
2583brcmf_dev_bufvar_get(struct net_device *ndev, s8 *name, s8 *buf,
2584 s32 buf_len)
2585{
2586 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
2587 u32 len;
2588 s32 err = 0;
2589
53a2277d 2590 len = brcmf_c_mkiovar(name, NULL, 0, cfg_priv->dcmd_buf,
5b435de0
AS		 2591 WL_DCMD_LEN_MAX);
2592 BUG_ON(!len);
2593 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, cfg_priv->dcmd_buf,
2594 WL_DCMD_LEN_MAX);
2595 if (err) {
2596 WL_ERR("error (%d)\n", err);
2597 return err;
2598 }
2599 memcpy(buf, cfg_priv->dcmd_buf, buf_len);
2600
2601 return err;
2602}
2603
2604static __used s32
2605brcmf_update_pmklist(struct net_device *ndev,
2606 struct brcmf_cfg80211_pmk_list *pmk_list, s32 err)
2607{
2608 int i, j;
40c8e95a 2609 int pmkid_len;
5b435de0 2610
40c8e95a
AS		 2611 pmkid_len = le32_to_cpu(pmk_list->pmkids.npmkid);
2612
2613 WL_CONN("No of elements %d\n", pmkid_len);
2614 for (i = 0; i < pmkid_len; i++) {
5b435de0
AS		 2615 WL_CONN("PMKID[%d]: %pM =\n", i,
2616 &pmk_list->pmkids.pmkid[i].BSSID);
2617 for (j = 0; j < WLAN_PMKID_LEN; j++)
2618 WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2619 }
2620
2621 if (!err)
2622 brcmf_dev_bufvar_set(ndev, "pmkid_info", (char *)pmk_list,
2623 sizeof(*pmk_list));
2624
2625 return err;
2626}
2627
2628static s32
2629brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev,
2630 struct cfg80211_pmksa *pmksa)
2631{
2632 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2633 struct pmkid_list *pmkids = &cfg_priv->pmk_list->pmkids;
2634 s32 err = 0;
2635 int i;
40c8e95a 2636 int pmkid_len;
5b435de0
AS		 2637
2638 WL_TRACE("Enter\n");
2639 if (!check_sys_up(wiphy))
2640 return -EIO;
2641
40c8e95a
AS		 2642 pmkid_len = le32_to_cpu(pmkids->npmkid);
2643 for (i = 0; i < pmkid_len; i++)
5b435de0
AS		 2644 if (!memcmp(pmksa->bssid, pmkids->pmkid[i].BSSID, ETH_ALEN))
2645 break;
2646 if (i < WL_NUM_PMKIDS_MAX) {
2647 memcpy(pmkids->pmkid[i].BSSID, pmksa->bssid, ETH_ALEN);
2648 memcpy(pmkids->pmkid[i].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
40c8e95a
AS		 2649 if (i == pmkid_len) {
2650 pmkid_len++;
2651 pmkids->npmkid = cpu_to_le32(pmkid_len);
2652 }
5b435de0
AS		 2653 } else
2654 err = -EINVAL;
2655
2656 WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
40c8e95a 2657 pmkids->pmkid[pmkid_len].BSSID);
5b435de0 2658 for (i = 0; i < WLAN_PMKID_LEN; i++)
40c8e95a 2659 WL_CONN("%02x\n", pmkids->pmkid[pmkid_len].PMKID[i]);
5b435de0
AS		 2660
2661 err = brcmf_update_pmklist(ndev, cfg_priv->pmk_list, err);
2662
2663 WL_TRACE("Exit\n");
2664 return err;
2665}
2666
2667static s32
2668brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *ndev,
2669 struct cfg80211_pmksa *pmksa)
2670{
2671 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2672 struct pmkid_list pmkid;
2673 s32 err = 0;
40c8e95a 2674 int i, pmkid_len;
5b435de0
AS		 2675
2676 WL_TRACE("Enter\n");
2677 if (!check_sys_up(wiphy))
2678 return -EIO;
2679
2680 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2681 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2682
2683 WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2684 &pmkid.pmkid[0].BSSID);
2685 for (i = 0; i < WLAN_PMKID_LEN; i++)
2686 WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
2687
40c8e95a
AS		 2688 pmkid_len = le32_to_cpu(cfg_priv->pmk_list->pmkids.npmkid);
2689 for (i = 0; i < pmkid_len; i++)
5b435de0
AS		 2690 if (!memcmp
2691 (pmksa->bssid, &cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2692 ETH_ALEN))
2693 break;
2694
40c8e95a
AS		 2695 if ((pmkid_len > 0)
2696 && (i < pmkid_len)) {
5b435de0
AS		 2697 memset(&cfg_priv->pmk_list->pmkids.pmkid[i], 0,
2698 sizeof(struct pmkid));
40c8e95a 2699 for (; i < (pmkid_len - 1); i++) {
5b435de0
AS		 2700 memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2701 &cfg_priv->pmk_list->pmkids.pmkid[i + 1].BSSID,
2702 ETH_ALEN);
2703 memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].PMKID,
2704 &cfg_priv->pmk_list->pmkids.pmkid[i + 1].PMKID,
2705 WLAN_PMKID_LEN);
2706 }
40c8e95a 2707 cfg_priv->pmk_list->pmkids.npmkid = cpu_to_le32(pmkid_len - 1);
5b435de0
AS		 2708 } else
2709 err = -EINVAL;
2710
2711 err = brcmf_update_pmklist(ndev, cfg_priv->pmk_list, err);
2712
2713 WL_TRACE("Exit\n");
2714 return err;
2715
2716}
2717
2718static s32
2719brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev)
2720{
2721 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2722 s32 err = 0;
2723
2724 WL_TRACE("Enter\n");
2725 if (!check_sys_up(wiphy))
2726 return -EIO;
2727
2728 memset(cfg_priv->pmk_list, 0, sizeof(*cfg_priv->pmk_list));
2729 err = brcmf_update_pmklist(ndev, cfg_priv->pmk_list, err);
2730
2731 WL_TRACE("Exit\n");
2732 return err;
2733
2734}
2735
2736static struct cfg80211_ops wl_cfg80211_ops = {
2737 .change_virtual_intf = brcmf_cfg80211_change_iface,
2738 .scan = brcmf_cfg80211_scan,
2739 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
2740 .join_ibss = brcmf_cfg80211_join_ibss,
2741 .leave_ibss = brcmf_cfg80211_leave_ibss,
2742 .get_station = brcmf_cfg80211_get_station,
2743 .set_tx_power = brcmf_cfg80211_set_tx_power,
2744 .get_tx_power = brcmf_cfg80211_get_tx_power,
2745 .add_key = brcmf_cfg80211_add_key,
2746 .del_key = brcmf_cfg80211_del_key,
2747 .get_key = brcmf_cfg80211_get_key,
2748 .set_default_key = brcmf_cfg80211_config_default_key,
2749 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
2750 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
2751 .set_bitrate_mask = brcmf_cfg80211_set_bitrate_mask,
2752 .connect = brcmf_cfg80211_connect,
2753 .disconnect = brcmf_cfg80211_disconnect,
2754 .suspend = brcmf_cfg80211_suspend,
2755 .resume = brcmf_cfg80211_resume,
2756 .set_pmksa = brcmf_cfg80211_set_pmksa,
2757 .del_pmksa = brcmf_cfg80211_del_pmksa,
2758 .flush_pmksa = brcmf_cfg80211_flush_pmksa
2759};
2760
2761static s32 brcmf_mode_to_nl80211_iftype(s32 mode)
2762{
2763 s32 err = 0;
2764
2765 switch (mode) {
2766 case WL_MODE_BSS:
2767 return NL80211_IFTYPE_STATION;
2768 case WL_MODE_IBSS:
2769 return NL80211_IFTYPE_ADHOC;
2770 default:
2771 return NL80211_IFTYPE_UNSPECIFIED;
2772 }
2773
2774 return err;
2775}
2776
2777static struct wireless_dev *brcmf_alloc_wdev(s32 sizeof_iface,
2778 struct device *ndev)
2779{
2780 struct wireless_dev *wdev;
2781 s32 err = 0;
2782
2783 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2784 if (!wdev)
2785 return ERR_PTR(-ENOMEM);
2786
2787 wdev->wiphy =
2788 wiphy_new(&wl_cfg80211_ops,
2789 sizeof(struct brcmf_cfg80211_priv) + sizeof_iface);
2790 if (!wdev->wiphy) {
2791 WL_ERR("Couldn not allocate wiphy device\n");
2792 err = -ENOMEM;
2793 goto wiphy_new_out;
2794 }
2795 set_wiphy_dev(wdev->wiphy, ndev);
2796 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2797 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2798 wdev->wiphy->interface_modes =
2799 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2800 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2801 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2802 * it as 11a by default.
2803 * This will be updated with
2804 * 11n phy tables in
2805 * "ifconfig up"
2806 * if phy has 11n capability
2807 */
2808 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2809 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2810 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2811 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2812 * save mode
2813 * by default
2814 */
2815 err = wiphy_register(wdev->wiphy);
2816 if (err < 0) {
2817 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2818 goto wiphy_register_out;
2819 }
2820 return wdev;
2821
2822wiphy_register_out:
2823 wiphy_free(wdev->wiphy);
2824
2825wiphy_new_out:
2826 kfree(wdev);
2827
2828 return ERR_PTR(err);
2829}
2830
2831static void brcmf_free_wdev(struct brcmf_cfg80211_priv *cfg_priv)
2832{
2833 struct wireless_dev *wdev = cfg_priv->wdev;
2834
2835 if (!wdev) {
2836 WL_ERR("wdev is invalid\n");
2837 return;
2838 }
2839 wiphy_unregister(wdev->wiphy);
2840 wiphy_free(wdev->wiphy);
2841 kfree(wdev);
2842 cfg_priv->wdev = NULL;
2843}
2844
2845static bool brcmf_is_linkup(struct brcmf_cfg80211_priv *cfg_priv,
2846 const struct brcmf_event_msg *e)
2847{
2848 u32 event = be32_to_cpu(e->event_type);
2849 u32 status = be32_to_cpu(e->status);
2850
2851 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
2852 WL_CONN("Processing set ssid\n");
2853 cfg_priv->link_up = true;
2854 return true;
2855 }
2856
2857 return false;
2858}
2859
2860static bool brcmf_is_linkdown(struct brcmf_cfg80211_priv *cfg_priv,
2861 const struct brcmf_event_msg *e)
2862{
2863 u32 event = be32_to_cpu(e->event_type);
2864 u16 flags = be16_to_cpu(e->flags);
2865
2866 if (event == BRCMF_E_LINK && (!(flags & BRCMF_EVENT_MSG_LINK))) {
2867 WL_CONN("Processing link down\n");
2868 return true;
2869 }
2870 return false;
2871}
2872
2873static bool brcmf_is_nonetwork(struct brcmf_cfg80211_priv *cfg_priv,
2874 const struct brcmf_event_msg *e)
2875{
2876 u32 event = be32_to_cpu(e->event_type);
2877 u32 status = be32_to_cpu(e->status);
2878
2879 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
2880 WL_CONN("Processing Link %s & no network found\n",
2881 be16_to_cpu(e->flags) & BRCMF_EVENT_MSG_LINK ?
2882 "up" : "down");
2883 return true;
2884 }
2885
2886 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
2887 WL_CONN("Processing connecting & no network found\n");
2888 return true;
2889 }
2890
2891 return false;
2892}
2893
2894static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2895{
2896 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2897
2898 kfree(conn_info->req_ie);
2899 conn_info->req_ie = NULL;
2900 conn_info->req_ie_len = 0;
2901 kfree(conn_info->resp_ie);
2902 conn_info->resp_ie = NULL;
2903 conn_info->resp_ie_len = 0;
2904}
2905
2906static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2907{
2908 struct net_device *ndev = cfg_to_ndev(cfg_priv);
c4e382d2 2909 struct brcmf_cfg80211_assoc_ielen_le *assoc_info;
5b435de0
AS		 2910 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2911 u32 req_len;
2912 u32 resp_len;
2913 s32 err = 0;
2914
2915 brcmf_clear_assoc_ies(cfg_priv);
2916
2917 err = brcmf_dev_bufvar_get(ndev, "assoc_info", cfg_priv->extra_buf,
2918 WL_ASSOC_INFO_MAX);
2919 if (err) {
2920 WL_ERR("could not get assoc info (%d)\n", err);
2921 return err;
2922 }
c4e382d2
AS		 2923 assoc_info =
2924 (struct brcmf_cfg80211_assoc_ielen_le *)cfg_priv->extra_buf;
2925 req_len = le32_to_cpu(assoc_info->req_len);
2926 resp_len = le32_to_cpu(assoc_info->resp_len);
5b435de0
AS		 2927 if (req_len) {
2928 err = brcmf_dev_bufvar_get(ndev, "assoc_req_ies",
2929 cfg_priv->extra_buf,
2930 WL_ASSOC_INFO_MAX);
2931 if (err) {
2932 WL_ERR("could not get assoc req (%d)\n", err);
2933 return err;
2934 }
2935 conn_info->req_ie_len = req_len;
2936 conn_info->req_ie =
2937 kmemdup(cfg_priv->extra_buf, conn_info->req_ie_len,
2938 GFP_KERNEL);
2939 } else {
2940 conn_info->req_ie_len = 0;
2941 conn_info->req_ie = NULL;
2942 }
2943 if (resp_len) {
2944 err = brcmf_dev_bufvar_get(ndev, "assoc_resp_ies",
2945 cfg_priv->extra_buf,
2946 WL_ASSOC_INFO_MAX);
2947 if (err) {
2948 WL_ERR("could not get assoc resp (%d)\n", err);
2949 return err;
2950 }
2951 conn_info->resp_ie_len = resp_len;
2952 conn_info->resp_ie =
2953 kmemdup(cfg_priv->extra_buf, conn_info->resp_ie_len,
2954 GFP_KERNEL);
2955 } else {
2956 conn_info->resp_ie_len = 0;
2957 conn_info->resp_ie = NULL;
2958 }
2959 WL_CONN("req len (%d) resp len (%d)\n",
2960 conn_info->req_ie_len, conn_info->resp_ie_len);
2961
2962 return err;
2963}
2964
2965static s32
2966brcmf_bss_roaming_done(struct brcmf_cfg80211_priv *cfg_priv,
2967 struct net_device *ndev,
2968 const struct brcmf_event_msg *e)
2969{
2970 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2971 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2972 struct brcmf_channel_info_le channel_le;
2973 struct ieee80211_channel *notify_channel;
2974 struct ieee80211_supported_band *band;
2975 u32 freq;
2976 s32 err = 0;
2977 u32 target_channel;
2978
2979 WL_TRACE("Enter\n");
2980
2981 brcmf_get_assoc_ies(cfg_priv);
2982 brcmf_update_prof(cfg_priv, NULL, &e->addr, WL_PROF_BSSID);
2983 brcmf_update_bss_info(cfg_priv);
2984
2985 brcmf_exec_dcmd(ndev, BRCMF_C_GET_CHANNEL, &channel_le,
2986 sizeof(channel_le));
2987
2988 target_channel = le32_to_cpu(channel_le.target_channel);
2989 WL_CONN("Roamed to channel %d\n", target_channel);
2990
2991 if (target_channel <= CH_MAX_2G_CHANNEL)
2992 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2993 else
2994 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2995
2996 freq = ieee80211_channel_to_frequency(target_channel, band->band);
2997 notify_channel = ieee80211_get_channel(wiphy, freq);
2998
2999 cfg80211_roamed(ndev, notify_channel,
3000 (u8 *)brcmf_read_prof(cfg_priv, WL_PROF_BSSID),
3001 conn_info->req_ie, conn_info->req_ie_len,
3002 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
3003 WL_CONN("Report roaming result\n");
3004
3005 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
3006 WL_TRACE("Exit\n");
3007 return err;
3008}
3009
3010static s32
3011brcmf_bss_connect_done(struct brcmf_cfg80211_priv *cfg_priv,
3012 struct net_device *ndev, const struct brcmf_event_msg *e,
3013 bool completed)
3014{
3015 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
3016 s32 err = 0;
3017
3018 WL_TRACE("Enter\n");
3019
3020 if (test_and_clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) {
3021 if (completed) {
3022 brcmf_get_assoc_ies(cfg_priv);
3023 brcmf_update_prof(cfg_priv, NULL, &e->addr,
3024 WL_PROF_BSSID);
3025 brcmf_update_bss_info(cfg_priv);
3026 }
3027 cfg80211_connect_result(ndev,
3028 (u8 *)brcmf_read_prof(cfg_priv,
3029 WL_PROF_BSSID),
3030 conn_info->req_ie,
3031 conn_info->req_ie_len,
3032 conn_info->resp_ie,
3033 conn_info->resp_ie_len,
3034 completed ? WLAN_STATUS_SUCCESS :
3035 WLAN_STATUS_AUTH_TIMEOUT,
3036 GFP_KERNEL);
3037 if (completed)
3038 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
3039 WL_CONN("Report connect result - connection %s\n",
3040 completed ? "succeeded" : "failed");
3041 }
3042 WL_TRACE("Exit\n");
3043 return err;
3044}
3045
3046static s32
3047brcmf_notify_connect_status(struct brcmf_cfg80211_priv *cfg_priv,
3048 struct net_device *ndev,
3049 const struct brcmf_event_msg *e, void *data)
3050{
3051 s32 err = 0;
3052
3053 if (brcmf_is_linkup(cfg_priv, e)) {
3054 WL_CONN("Linkup\n");
3055 if (brcmf_is_ibssmode(cfg_priv)) {
3056 brcmf_update_prof(cfg_priv, NULL, (void *)e->addr,
3057 WL_PROF_BSSID);
3058 wl_inform_ibss(cfg_priv, ndev, e->addr);
3059 cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
3060 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
3061 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
3062 } else
3063 brcmf_bss_connect_done(cfg_priv, ndev, e, true);
3064 } else if (brcmf_is_linkdown(cfg_priv, e)) {
3065 WL_CONN("Linkdown\n");
3066 if (brcmf_is_ibssmode(cfg_priv)) {
3067 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
3068 if (test_and_clear_bit(WL_STATUS_CONNECTED,
3069 &cfg_priv->status))
3070 brcmf_link_down(cfg_priv);
3071 } else {
3072 brcmf_bss_connect_done(cfg_priv, ndev, e, false);
3073 if (test_and_clear_bit(WL_STATUS_CONNECTED,
3074 &cfg_priv->status)) {
3075 cfg80211_disconnected(ndev, 0, NULL, 0,
3076 GFP_KERNEL);
3077 brcmf_link_down(cfg_priv);
3078 }
3079 }
3080 brcmf_init_prof(cfg_priv->profile);
3081 } else if (brcmf_is_nonetwork(cfg_priv, e)) {
3082 if (brcmf_is_ibssmode(cfg_priv))
3083 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
3084 else
3085 brcmf_bss_connect_done(cfg_priv, ndev, e, false);
3086 }
3087
3088 return err;
3089}
3090
3091static s32
3092brcmf_notify_roaming_status(struct brcmf_cfg80211_priv *cfg_priv,
3093 struct net_device *ndev,
3094 const struct brcmf_event_msg *e, void *data)
3095{
3096 s32 err = 0;
3097 u32 event = be32_to_cpu(e->event_type);
3098 u32 status = be32_to_cpu(e->status);
3099
3100 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
3101 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status))
3102 brcmf_bss_roaming_done(cfg_priv, ndev, e);
3103 else
3104 brcmf_bss_connect_done(cfg_priv, ndev, e, true);
3105 }
3106
3107 return err;
3108}
3109
3110static s32
3111brcmf_notify_mic_status(struct brcmf_cfg80211_priv *cfg_priv,
3112 struct net_device *ndev,
3113 const struct brcmf_event_msg *e, void *data)
3114{
3115 u16 flags = be16_to_cpu(e->flags);
3116 enum nl80211_key_type key_type;
3117
3118 if (flags & BRCMF_EVENT_MSG_GROUP)
3119 key_type = NL80211_KEYTYPE_GROUP;
3120 else
3121 key_type = NL80211_KEYTYPE_PAIRWISE;
3122
3123 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
3124 NULL, GFP_KERNEL);
3125
3126 return 0;
3127}
3128
3129static s32
3130brcmf_notify_scan_status(struct brcmf_cfg80211_priv *cfg_priv,
3131 struct net_device *ndev,
3132 const struct brcmf_event_msg *e, void *data)
3133{
3134 struct brcmf_channel_info_le channel_inform_le;
3135 struct brcmf_scan_results_le *bss_list_le;
3136 u32 len = WL_SCAN_BUF_MAX;
3137 s32 err = 0;
3138 bool scan_abort = false;
3139 u32 scan_channel;
3140
3141 WL_TRACE("Enter\n");
3142
3143 if (cfg_priv->iscan_on && cfg_priv->iscan_kickstart) {
3144 WL_TRACE("Exit\n");
3145 return brcmf_wakeup_iscan(cfg_to_iscan(cfg_priv));
3146 }
3147
3148 if (!test_and_clear_bit(WL_STATUS_SCANNING, &cfg_priv->status)) {
3149 WL_ERR("Scan complete while device not scanning\n");
3150 scan_abort = true;
3151 err = -EINVAL;
3152 goto scan_done_out;
3153 }
3154
3155 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_CHANNEL, &channel_inform_le,
3156 sizeof(channel_inform_le));
3157 if (err) {
3158 WL_ERR("scan busy (%d)\n", err);
3159 scan_abort = true;
3160 goto scan_done_out;
3161 }
3162 scan_channel = le32_to_cpu(channel_inform_le.scan_channel);
3163 if (scan_channel)
3164 WL_CONN("channel_inform.scan_channel (%d)\n", scan_channel);
3165 cfg_priv->bss_list = cfg_priv->scan_results;
3166 bss_list_le = (struct brcmf_scan_results_le *) cfg_priv->bss_list;
3167
3168 memset(cfg_priv->scan_results, 0, len);
3169 bss_list_le->buflen = cpu_to_le32(len);
3170 err = brcmf_exec_dcmd(ndev, BRCMF_C_SCAN_RESULTS,
3171 cfg_priv->scan_results, len);
3172 if (err) {
3173 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
3174 err = -EINVAL;
3175 scan_abort = true;
3176 goto scan_done_out;
3177 }
3178 cfg_priv->scan_results->buflen = le32_to_cpu(bss_list_le->buflen);
3179 cfg_priv->scan_results->version = le32_to_cpu(bss_list_le->version);
3180 cfg_priv->scan_results->count = le32_to_cpu(bss_list_le->count);
3181
3182 err = brcmf_inform_bss(cfg_priv);
3183 if (err) {
3184 scan_abort = true;
3185 goto scan_done_out;
3186 }
3187
3188scan_done_out:
3189 if (cfg_priv->scan_request) {
3190 WL_SCAN("calling cfg80211_scan_done\n");
3191 cfg80211_scan_done(cfg_priv->scan_request, scan_abort);
3192 brcmf_set_mpc(ndev, 1);
3193 cfg_priv->scan_request = NULL;
3194 }
3195
3196 WL_TRACE("Exit\n");
3197
3198 return err;
3199}
3200
3201static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
3202{
3203 conf->mode = (u32)-1;
3204 conf->frag_threshold = (u32)-1;
3205 conf->rts_threshold = (u32)-1;
3206 conf->retry_short = (u32)-1;
3207 conf->retry_long = (u32)-1;
3208 conf->tx_power = -1;
3209}
3210
3211static void brcmf_init_eloop_handler(struct brcmf_cfg80211_event_loop *el)
3212{
3213 memset(el, 0, sizeof(*el));
3214 el->handler[BRCMF_E_SCAN_COMPLETE] = brcmf_notify_scan_status;
3215 el->handler[BRCMF_E_LINK] = brcmf_notify_connect_status;
3216 el->handler[BRCMF_E_ROAM] = brcmf_notify_roaming_status;
3217 el->handler[BRCMF_E_MIC_ERROR] = brcmf_notify_mic_status;
3218 el->handler[BRCMF_E_SET_SSID] = brcmf_notify_connect_status;
3219}
3220
3221static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3222{
3223 kfree(cfg_priv->scan_results);
3224 cfg_priv->scan_results = NULL;
3225 kfree(cfg_priv->bss_info);
3226 cfg_priv->bss_info = NULL;
3227 kfree(cfg_priv->conf);
3228 cfg_priv->conf = NULL;
3229 kfree(cfg_priv->profile);
3230 cfg_priv->profile = NULL;
3231 kfree(cfg_priv->scan_req_int);
3232 cfg_priv->scan_req_int = NULL;
3233 kfree(cfg_priv->dcmd_buf);
3234 cfg_priv->dcmd_buf = NULL;
3235 kfree(cfg_priv->extra_buf);
3236 cfg_priv->extra_buf = NULL;
3237 kfree(cfg_priv->iscan);
3238 cfg_priv->iscan = NULL;
3239 kfree(cfg_priv->pmk_list);
3240 cfg_priv->pmk_list = NULL;
3241}
3242
3243static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3244{
3245 cfg_priv->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
3246 if (!cfg_priv->scan_results)
3247 goto init_priv_mem_out;
3248 cfg_priv->conf = kzalloc(sizeof(*cfg_priv->conf), GFP_KERNEL);
3249 if (!cfg_priv->conf)
3250 goto init_priv_mem_out;
3251 cfg_priv->profile = kzalloc(sizeof(*cfg_priv->profile), GFP_KERNEL);
3252 if (!cfg_priv->profile)
3253 goto init_priv_mem_out;
3254 cfg_priv->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
3255 if (!cfg_priv->bss_info)
3256 goto init_priv_mem_out;
3257 cfg_priv->scan_req_int = kzalloc(sizeof(*cfg_priv->scan_req_int),
3258 GFP_KERNEL);
3259 if (!cfg_priv->scan_req_int)
3260 goto init_priv_mem_out;
3261 cfg_priv->dcmd_buf = kzalloc(WL_DCMD_LEN_MAX, GFP_KERNEL);
3262 if (!cfg_priv->dcmd_buf)
3263 goto init_priv_mem_out;
3264 cfg_priv->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3265 if (!cfg_priv->extra_buf)
3266 goto init_priv_mem_out;
3267 cfg_priv->iscan = kzalloc(sizeof(*cfg_priv->iscan), GFP_KERNEL);
3268 if (!cfg_priv->iscan)
3269 goto init_priv_mem_out;
3270 cfg_priv->pmk_list = kzalloc(sizeof(*cfg_priv->pmk_list), GFP_KERNEL);
3271 if (!cfg_priv->pmk_list)
3272 goto init_priv_mem_out;
3273
3274 return 0;
3275
3276init_priv_mem_out:
3277 brcmf_deinit_priv_mem(cfg_priv);
3278
3279 return -ENOMEM;
3280}
3281
3282/*
3283* retrieve first queued event from head
3284*/
3285
3286static struct brcmf_cfg80211_event_q *brcmf_deq_event(
3287 struct brcmf_cfg80211_priv *cfg_priv)
3288{
3289 struct brcmf_cfg80211_event_q *e = NULL;
3290
3291 spin_lock_irq(&cfg_priv->evt_q_lock);
3292 if (!list_empty(&cfg_priv->evt_q_list)) {
3293 e = list_first_entry(&cfg_priv->evt_q_list,
3294 struct brcmf_cfg80211_event_q, evt_q_list);
3295 list_del(&e->evt_q_list);
3296 }
3297 spin_unlock_irq(&cfg_priv->evt_q_lock);
3298
3299 return e;
3300}
3301
3302/*
3303** push event to tail of the queue
3304*/
3305
3306static s32
3307brcmf_enq_event(struct brcmf_cfg80211_priv *cfg_priv, u32 event,
3308 const struct brcmf_event_msg *msg)
3309{
3310 struct brcmf_cfg80211_event_q *e;
3311 s32 err = 0;
3312
3313 e = kzalloc(sizeof(struct brcmf_cfg80211_event_q), GFP_KERNEL);
3314 if (!e)
3315 return -ENOMEM;
3316
3317 e->etype = event;
3318 memcpy(&e->emsg, msg, sizeof(struct brcmf_event_msg));
3319
3320 spin_lock_irq(&cfg_priv->evt_q_lock);
3321 list_add_tail(&e->evt_q_list, &cfg_priv->evt_q_list);
3322 spin_unlock_irq(&cfg_priv->evt_q_lock);
3323
3324 return err;
3325}
3326
3327static void brcmf_put_event(struct brcmf_cfg80211_event_q *e)
3328{
3329 kfree(e);
3330}
3331
3332static void brcmf_cfg80211_event_handler(struct work_struct *work)
3333{
3334 struct brcmf_cfg80211_priv *cfg_priv =
3335 container_of(work, struct brcmf_cfg80211_priv,
3336 event_work);
3337 struct brcmf_cfg80211_event_q *e;
3338
3339 e = brcmf_deq_event(cfg_priv);
3340 if (unlikely(!e)) {
3341 WL_ERR("event queue empty...\n");
3342 return;
3343 }
3344
3345 do {
3346 WL_INFO("event type (%d)\n", e->etype);
3347 if (cfg_priv->el.handler[e->etype])
3348 cfg_priv->el.handler[e->etype](cfg_priv,
3349 cfg_to_ndev(cfg_priv),
3350 &e->emsg, e->edata);
3351 else
3352 WL_INFO("Unknown Event (%d): ignoring\n", e->etype);
3353 brcmf_put_event(e);
3354 } while ((e = brcmf_deq_event(cfg_priv)));
3355
3356}
3357
3358static void brcmf_init_eq(struct brcmf_cfg80211_priv *cfg_priv)
3359{
3360 spin_lock_init(&cfg_priv->evt_q_lock);
3361 INIT_LIST_HEAD(&cfg_priv->evt_q_list);
3362}
3363
3364static void brcmf_flush_eq(struct brcmf_cfg80211_priv *cfg_priv)
3365{
3366 struct brcmf_cfg80211_event_q *e;
3367
3368 spin_lock_irq(&cfg_priv->evt_q_lock);
3369 while (!list_empty(&cfg_priv->evt_q_list)) {
3370 e = list_first_entry(&cfg_priv->evt_q_list,
3371 struct brcmf_cfg80211_event_q, evt_q_list);
3372 list_del(&e->evt_q_list);
3373 kfree(e);
3374 }
3375 spin_unlock_irq(&cfg_priv->evt_q_lock);
3376}
3377
3378static s32 wl_init_priv(struct brcmf_cfg80211_priv *cfg_priv)
3379{
3380 s32 err = 0;
3381
3382 cfg_priv->scan_request = NULL;
3383 cfg_priv->pwr_save = true;
3384 cfg_priv->iscan_on = true; /* iscan on & off switch.
3385 we enable iscan per default */
3386 cfg_priv->roam_on = true; /* roam on & off switch.
3387 we enable roam per default */
3388
3389 cfg_priv->iscan_kickstart = false;
3390 cfg_priv->active_scan = true; /* we do active scan for
3391 specific scan per default */
3392 cfg_priv->dongle_up = false; /* dongle is not up yet */
3393 brcmf_init_eq(cfg_priv);
3394 err = brcmf_init_priv_mem(cfg_priv);
3395 if (err)
3396 return err;
3397 INIT_WORK(&cfg_priv->event_work, brcmf_cfg80211_event_handler);
3398 brcmf_init_eloop_handler(&cfg_priv->el);
3399 mutex_init(&cfg_priv->usr_sync);
3400 err = brcmf_init_iscan(cfg_priv);
3401 if (err)
3402 return err;
3403 brcmf_init_conf(cfg_priv->conf);
3404 brcmf_init_prof(cfg_priv->profile);
3405 brcmf_link_down(cfg_priv);
3406
3407 return err;
3408}
3409
3410static void wl_deinit_priv(struct brcmf_cfg80211_priv *cfg_priv)
3411{
3412 cancel_work_sync(&cfg_priv->event_work);
3413 cfg_priv->dongle_up = false; /* dongle down */
3414 brcmf_flush_eq(cfg_priv);
3415 brcmf_link_down(cfg_priv);
3416 brcmf_term_iscan(cfg_priv);
3417 brcmf_deinit_priv_mem(cfg_priv);
3418}
3419
3420struct brcmf_cfg80211_dev *brcmf_cfg80211_attach(struct net_device *ndev,
3421 struct device *busdev,
3422 void *data)
3423{
3424 struct wireless_dev *wdev;
3425 struct brcmf_cfg80211_priv *cfg_priv;
3426 struct brcmf_cfg80211_iface *ci;
3427 struct brcmf_cfg80211_dev *cfg_dev;
3428 s32 err = 0;
3429
3430 if (!ndev) {
3431 WL_ERR("ndev is invalid\n");
3432 return NULL;
3433 }
3434 cfg_dev = kzalloc(sizeof(struct brcmf_cfg80211_dev), GFP_KERNEL);
3435 if (!cfg_dev)
3436 return NULL;
3437
3438 wdev = brcmf_alloc_wdev(sizeof(struct brcmf_cfg80211_iface), busdev);
3439 if (IS_ERR(wdev)) {
3440 kfree(cfg_dev);
3441 return NULL;
3442 }
3443
3444 wdev->iftype = brcmf_mode_to_nl80211_iftype(WL_MODE_BSS);
3445 cfg_priv = wdev_to_cfg(wdev);
3446 cfg_priv->wdev = wdev;
3447 cfg_priv->pub = data;
3448 ci = (struct brcmf_cfg80211_iface *)&cfg_priv->ci;
3449 ci->cfg_priv = cfg_priv;
3450 ndev->ieee80211_ptr = wdev;
3451 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3452 wdev->netdev = ndev;
3453 err = wl_init_priv(cfg_priv);
3454 if (err) {
3455 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3456 goto cfg80211_attach_out;
3457 }
3458 brcmf_set_drvdata(cfg_dev, ci);
3459
3460 return cfg_dev;
3461
3462cfg80211_attach_out:
3463 brcmf_free_wdev(cfg_priv);
3464 kfree(cfg_dev);
3465 return NULL;
3466}
3467
3468void brcmf_cfg80211_detach(struct brcmf_cfg80211_dev *cfg_dev)
3469{
3470 struct brcmf_cfg80211_priv *cfg_priv;
3471
3472 cfg_priv = brcmf_priv_get(cfg_dev);
3473
3474 wl_deinit_priv(cfg_priv);
3475 brcmf_free_wdev(cfg_priv);
3476 brcmf_set_drvdata(cfg_dev, NULL);
3477 kfree(cfg_dev);
3478}
3479
3480void
3481brcmf_cfg80211_event(struct net_device *ndev,
3482 const struct brcmf_event_msg *e, void *data)
3483{
3484 u32 event_type = be32_to_cpu(e->event_type);
3485 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
3486
3487 if (!brcmf_enq_event(cfg_priv, event_type, e))
3488 schedule_work(&cfg_priv->event_work);
3489}
3490
3491static s32 brcmf_dongle_mode(struct net_device *ndev, s32 iftype)
3492{
3493 s32 infra = 0;
3494 s32 err = 0;
3495
3496 switch (iftype) {
3497 case NL80211_IFTYPE_MONITOR:
3498 case NL80211_IFTYPE_WDS:
3499 WL_ERR("type (%d) : currently we do not support this mode\n",
3500 iftype);
3501 err = -EINVAL;
3502 return err;
3503 case NL80211_IFTYPE_ADHOC:
3504 infra = 0;
3505 break;
3506 case NL80211_IFTYPE_STATION:
3507 infra = 1;
3508 break;
3509 default:
3510 err = -EINVAL;
3511 WL_ERR("invalid type (%d)\n", iftype);
3512 return err;
3513 }
3514 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_INFRA, &infra);
3515 if (err) {
3516 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
3517 return err;
3518 }
3519
3520 return 0;
3521}
3522
3523static s32 brcmf_dongle_eventmsg(struct net_device *ndev)
3524{
3525 /* Room for "event_msgs" + '\0' + bitvec */
3526 s8 iovbuf[BRCMF_EVENTING_MASK_LEN + 12];
3527 s8 eventmask[BRCMF_EVENTING_MASK_LEN];
3528 s32 err = 0;
3529
3530 WL_TRACE("Enter\n");
3531
3532 /* Setup event_msgs */
53a2277d
AB		 3533 brcmf_c_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN,
3534 iovbuf, sizeof(iovbuf));
5b435de0
AS		 3535 err = brcmf_exec_dcmd(ndev, BRCMF_C_GET_VAR, iovbuf, sizeof(iovbuf));
3536 if (err) {
3537 WL_ERR("Get event_msgs error (%d)\n", err);
3538 goto dongle_eventmsg_out;
3539 }
3540 memcpy(eventmask, iovbuf, BRCMF_EVENTING_MASK_LEN);
3541
3542 setbit(eventmask, BRCMF_E_SET_SSID);
3543 setbit(eventmask, BRCMF_E_ROAM);
3544 setbit(eventmask, BRCMF_E_PRUNE);
3545 setbit(eventmask, BRCMF_E_AUTH);
3546 setbit(eventmask, BRCMF_E_REASSOC);
3547 setbit(eventmask, BRCMF_E_REASSOC_IND);
3548 setbit(eventmask, BRCMF_E_DEAUTH_IND);
3549 setbit(eventmask, BRCMF_E_DISASSOC_IND);
3550 setbit(eventmask, BRCMF_E_DISASSOC);
3551 setbit(eventmask, BRCMF_E_JOIN);
3552 setbit(eventmask, BRCMF_E_ASSOC_IND);
3553 setbit(eventmask, BRCMF_E_PSK_SUP);
3554 setbit(eventmask, BRCMF_E_LINK);
3555 setbit(eventmask, BRCMF_E_NDIS_LINK);
3556 setbit(eventmask, BRCMF_E_MIC_ERROR);
3557 setbit(eventmask, BRCMF_E_PMKID_CACHE);
3558 setbit(eventmask, BRCMF_E_TXFAIL);
3559 setbit(eventmask, BRCMF_E_JOIN_START);
3560 setbit(eventmask, BRCMF_E_SCAN_COMPLETE);
3561
53a2277d
AB		 3562 brcmf_c_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN,
3563 iovbuf, sizeof(iovbuf));
5b435de0
AS		 3564 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3565 if (err) {
3566 WL_ERR("Set event_msgs error (%d)\n", err);
3567 goto dongle_eventmsg_out;
3568 }
3569
3570dongle_eventmsg_out:
3571 WL_TRACE("Exit\n");
3572 return err;
3573}
3574
3575static s32
3576brcmf_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3577{
3578 s8 iovbuf[32];
5b435de0 3579 s32 err = 0;
f588bc0c
AS		 3580 __le32 roamtrigger[2];
3581 __le32 roam_delta[2];
3582 __le32 bcn_to_le;
3583 __le32 roamvar_le;
5b435de0
AS		 3584
3585 /*
3586 * Setup timeout if Beacons are lost and roam is
3587 * off to report link down
3588 */
3589 if (roamvar) {
f588bc0c 3590 bcn_to_le = cpu_to_le32(bcn_timeout);
53a2277d 3591 brcmf_c_mkiovar("bcn_timeout", (char *)&bcn_to_le,
f588bc0c 3592 sizeof(bcn_to_le), iovbuf, sizeof(iovbuf));
5b435de0
AS		 3593 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR,
3594 iovbuf, sizeof(iovbuf));
3595 if (err) {
3596 WL_ERR("bcn_timeout error (%d)\n", err);
3597 goto dongle_rom_out;
3598 }
3599 }
3600
3601 /*
3602 * Enable/Disable built-in roaming to allow supplicant
3603 * to take care of roaming
3604 */
3605 WL_INFO("Internal Roaming = %s\n", roamvar ? "Off" : "On");
f588bc0c 3606 roamvar_le = cpu_to_le32(roamvar);
53a2277d 3607 brcmf_c_mkiovar("roam_off", (char *)&roamvar_le,
f588bc0c 3608 sizeof(roamvar_le), iovbuf, sizeof(iovbuf));
5b435de0
AS		 3609 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3610 if (err) {
3611 WL_ERR("roam_off error (%d)\n", err);
3612 goto dongle_rom_out;
3613 }
3614
f588bc0c
AS		 3615 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL);
3616 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL);
5b435de0
AS		 3617 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_ROAM_TRIGGER,
3618 (void *)roamtrigger, sizeof(roamtrigger));
3619 if (err) {
3620 WL_ERR("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
3621 goto dongle_rom_out;
3622 }
3623
f588bc0c
AS		 3624 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA);
3625 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL);
5b435de0
AS		 3626 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_ROAM_DELTA,
3627 (void *)roam_delta, sizeof(roam_delta));
3628 if (err) {
3629 WL_ERR("WLC_SET_ROAM_DELTA error (%d)\n", err);
3630 goto dongle_rom_out;
3631 }
3632
3633dongle_rom_out:
3634 return err;
3635}
3636
3637static s32
3638brcmf_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
c68cdc0f 3639 s32 scan_unassoc_time, s32 scan_passive_time)
5b435de0
AS		 3640{
3641 s32 err = 0;
c68cdc0f
AS		 3642 __le32 scan_assoc_tm_le = cpu_to_le32(scan_assoc_time);
3643 __le32 scan_unassoc_tm_le = cpu_to_le32(scan_unassoc_time);
3644 __le32 scan_passive_tm_le = cpu_to_le32(scan_passive_time);
5b435de0
AS		 3645
3646 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SCAN_CHANNEL_TIME,
c68cdc0f 3647 &scan_assoc_tm_le, sizeof(scan_assoc_tm_le));
5b435de0
AS		 3648 if (err) {
3649 if (err == -EOPNOTSUPP)
3650 WL_INFO("Scan assoc time is not supported\n");
3651 else
3652 WL_ERR("Scan assoc time error (%d)\n", err);
3653 goto dongle_scantime_out;
3654 }
3655 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SCAN_UNASSOC_TIME,
c68cdc0f 3656 &scan_unassoc_tm_le, sizeof(scan_unassoc_tm_le));
5b435de0
AS		 3657 if (err) {
3658 if (err == -EOPNOTSUPP)
3659 WL_INFO("Scan unassoc time is not supported\n");
3660 else
3661 WL_ERR("Scan unassoc time error (%d)\n", err);
3662 goto dongle_scantime_out;
3663 }
3664
3665 err = brcmf_exec_dcmd(ndev, BRCMF_C_SET_SCAN_PASSIVE_TIME,
c68cdc0f 3666 &scan_passive_tm_le, sizeof(scan_passive_tm_le));
5b435de0
AS		 3667 if (err) {
3668 if (err == -EOPNOTSUPP)
3669 WL_INFO("Scan passive time is not supported\n");
3670 else
3671 WL_ERR("Scan passive time error (%d)\n", err);
3672 goto dongle_scantime_out;
3673 }
3674
3675dongle_scantime_out:
3676 return err;
3677}
3678
3679static s32 wl_update_wiphybands(struct brcmf_cfg80211_priv *cfg_priv)
3680{
3681 struct wiphy *wiphy;
3682 s32 phy_list;
3683 s8 phy;
3684 s32 err = 0;
3685
3686 err = brcmf_exec_dcmd(cfg_to_ndev(cfg_priv), BRCM_GET_PHYLIST,
3687 &phy_list, sizeof(phy_list));
3688 if (err) {
3689 WL_ERR("error (%d)\n", err);
3690 return err;
3691 }
3692
3693 phy = ((char *)&phy_list)[1];
3694 WL_INFO("%c phy\n", phy);
3695 if (phy == 'n' || phy == 'a') {
3696 wiphy = cfg_to_wiphy(cfg_priv);
3697 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
3698 }
3699
3700 return err;
3701}
3702
3703static s32 brcmf_dongle_probecap(struct brcmf_cfg80211_priv *cfg_priv)
3704{
3705 return wl_update_wiphybands(cfg_priv);
3706}
3707
3708static s32 brcmf_config_dongle(struct brcmf_cfg80211_priv *cfg_priv)
3709{
3710 struct net_device *ndev;
3711 struct wireless_dev *wdev;
3712 s32 power_mode;
3713 s32 err = 0;
3714
3715 if (cfg_priv->dongle_up)
3716 return err;
3717
3718 ndev = cfg_to_ndev(cfg_priv);
3719 wdev = ndev->ieee80211_ptr;
3720
3721 brcmf_dongle_scantime(ndev, WL_SCAN_CHANNEL_TIME,
3722 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
3723
3724 err = brcmf_dongle_eventmsg(ndev);
3725 if (err)
3726 goto default_conf_out;
3727
3728 power_mode = cfg_priv->pwr_save ? PM_FAST : PM_OFF;
3729 err = brcmf_exec_dcmd_u32(ndev, BRCMF_C_SET_PM, &power_mode);
3730 if (err)
3731 goto default_conf_out;
3732 WL_INFO("power save set to %s\n",
3733 (power_mode ? "enabled" : "disabled"));
3734
3735 err = brcmf_dongle_roam(ndev, (cfg_priv->roam_on ? 0 : 1),
3736 WL_BEACON_TIMEOUT);
3737 if (err)
3738 goto default_conf_out;
3739 err = brcmf_dongle_mode(ndev, wdev->iftype);
3740 if (err && err != -EINPROGRESS)
3741 goto default_conf_out;
3742 err = brcmf_dongle_probecap(cfg_priv);
3743 if (err)
3744 goto default_conf_out;
3745
3746 /* -EINPROGRESS: Call commit handler */
3747
3748default_conf_out:
3749
3750 cfg_priv->dongle_up = true;
3751
3752 return err;
3753
3754}
3755
3756static int brcmf_debugfs_add_netdev_params(struct brcmf_cfg80211_priv *cfg_priv)
3757{
3758 char buf[10+IFNAMSIZ];
3759 struct dentry *fd;
3760 s32 err = 0;
3761
3762 sprintf(buf, "netdev:%s", cfg_to_ndev(cfg_priv)->name);
3763 cfg_priv->debugfsdir = debugfs_create_dir(buf,
3764 cfg_to_wiphy(cfg_priv)->debugfsdir);
3765
3766 fd = debugfs_create_u16("beacon_int", S_IRUGO, cfg_priv->debugfsdir,
3767 (u16 *)&cfg_priv->profile->beacon_interval);
3768 if (!fd) {
3769 err = -ENOMEM;
3770 goto err_out;
3771 }
3772
3773 fd = debugfs_create_u8("dtim_period", S_IRUGO, cfg_priv->debugfsdir,
3774 (u8 *)&cfg_priv->profile->dtim_period);
3775 if (!fd) {
3776 err = -ENOMEM;
3777 goto err_out;
3778 }
3779
3780err_out:
3781 return err;
3782}
3783
3784static void brcmf_debugfs_remove_netdev(struct brcmf_cfg80211_priv *cfg_priv)
3785{
3786 debugfs_remove_recursive(cfg_priv->debugfsdir);
3787 cfg_priv->debugfsdir = NULL;
3788}
3789
3790static s32 __brcmf_cfg80211_up(struct brcmf_cfg80211_priv *cfg_priv)
3791{
3792 s32 err = 0;
3793
3794 set_bit(WL_STATUS_READY, &cfg_priv->status);
3795
3796 brcmf_debugfs_add_netdev_params(cfg_priv);
3797
3798 err = brcmf_config_dongle(cfg_priv);
3799 if (err)
3800 return err;
3801
3802 brcmf_invoke_iscan(cfg_priv);
3803
3804 return err;
3805}
3806
3807static s32 __brcmf_cfg80211_down(struct brcmf_cfg80211_priv *cfg_priv)
3808{
3809 /*
3810 * While going down, if associated with AP disassociate
3811 * from AP to save power
3812 */
3813 if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
3814 test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
3815 test_bit(WL_STATUS_READY, &cfg_priv->status)) {
3816 WL_INFO("Disassociating from AP");
3817 brcmf_link_down(cfg_priv);
3818
3819 /* Make sure WPA_Supplicant receives all the event
3820 generated due to DISASSOC call to the fw to keep
3821 the state fw and WPA_Supplicant state consistent
3822 */
3823 brcmf_delay(500);
3824 }
3825
3826 set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3827 brcmf_term_iscan(cfg_priv);
3828 if (cfg_priv->scan_request) {
3829 cfg80211_scan_done(cfg_priv->scan_request, true);
3830 /* May need to perform this to cover rmmod */
3831 /* wl_set_mpc(cfg_to_ndev(wl), 1); */
3832 cfg_priv->scan_request = NULL;
3833 }
3834 clear_bit(WL_STATUS_READY, &cfg_priv->status);
3835 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
3836 clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3837
3838 brcmf_debugfs_remove_netdev(cfg_priv);
3839
3840 return 0;
3841}
3842
3843s32 brcmf_cfg80211_up(struct brcmf_cfg80211_dev *cfg_dev)
3844{
3845 struct brcmf_cfg80211_priv *cfg_priv;
3846 s32 err = 0;
3847
3848 cfg_priv = brcmf_priv_get(cfg_dev);
3849 mutex_lock(&cfg_priv->usr_sync);
3850 err = __brcmf_cfg80211_up(cfg_priv);
3851 mutex_unlock(&cfg_priv->usr_sync);
3852
3853 return err;
3854}
3855
3856s32 brcmf_cfg80211_down(struct brcmf_cfg80211_dev *cfg_dev)
3857{
3858 struct brcmf_cfg80211_priv *cfg_priv;
3859 s32 err = 0;
3860
3861 cfg_priv = brcmf_priv_get(cfg_dev);
3862 mutex_lock(&cfg_priv->usr_sync);
3863 err = __brcmf_cfg80211_down(cfg_priv);
3864 mutex_unlock(&cfg_priv->usr_sync);
3865
3866 return err;
3867}
3868
3869static __used s32 brcmf_add_ie(struct brcmf_cfg80211_priv *cfg_priv,
3870 u8 t, u8 l, u8 *v)
3871{
3872 struct brcmf_cfg80211_ie *ie = &cfg_priv->ie;
3873 s32 err = 0;
3874
3875 if (ie->offset + l + 2 > WL_TLV_INFO_MAX) {
3876 WL_ERR("ei crosses buffer boundary\n");
3877 return -ENOSPC;
3878 }
3879 ie->buf[ie->offset] = t;
3880 ie->buf[ie->offset + 1] = l;
3881 memcpy(&ie->buf[ie->offset + 2], v, l);
3882 ie->offset += l + 2;
3883
3884 return err;
3885}
Linux kernel - Deliverables
This page took 0.189243 seconds and 5 git commands to generate.