projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
staging: brcm80211: renamed files in brcmsmac and include directories
[deliverable/linux.git] / drivers / staging / brcm80211 / brcmfmac / wl_iw.c
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 #include <linux/kthread.h>
18 #include <linux/semaphore.h>
19 #include <defs.h>
20 #include <linux/netdevice.h>
21 #include <linux/etherdevice.h>
22 #include <linux/wireless.h>
23
24 #include <brcmu_utils.h>
25 #include <brcmu_wifi.h>
26
27 #include <linux/if_arp.h>
28 #include <asm/uaccess.h>
29
30 #include <dngl_stats.h>
31 #include <dhd.h>
32 #include <linux/ieee80211.h>
33
34 struct si_pub;
35
36 #include <dngl_stats.h>
37 #include <dhd.h>
38
39 #define WPA_OUI "\x00\x50\xF2"
40 #define DOT11_MNG_RSN_ID 48
41 #define DOT11_MNG_WPA_ID 221
42
43 #define WL_ERROR(fmt, args...) printk(fmt, ##args)
44 #define WL_TRACE(fmt, args...) no_printk(fmt, ##args)
45 #define WL_INFORM(fmt, args...) no_printk(fmt, ##args)
46 #define WL_WSEC(fmt, args...) no_printk(fmt, ##args)
47 #define WL_SCAN(fmt, args...) no_printk(fmt, ##args)
48
49 #include <wl_iw.h>
50
51 #define IW_WSEC_ENABLED(wsec) ((wsec) & (WEP_ENABLED | \
52 TKIP_ENABLED | AES_ENABLED))
53
54 #include <linux/rtnetlink.h>
55
56 #define WL_IW_USE_ISCAN 1
57 #define ENABLE_ACTIVE_PASSIVE_SCAN_SUPPRESS 1
58
59 bool g_set_essid_before_scan = true;
60
61 #define WL_IW_IOCTL_CALL(func_call) \
62 do { \
63 func_call; \
64 } while (0)
65
66 static int g_onoff = G_WLAN_SET_ON;
67 wl_iw_extra_params_t g_wl_iw_params;
68
69 extern bool wl_iw_conn_status_str(u32 event_type, u32 status,
70 u32 reason, char *stringBuf, uint buflen);
71
72 uint brcm_msg_level = LOG_ERROR_VAL;
73
74 #define MAX_WLIW_IOCTL_LEN 1024
75
76 #ifdef CONFIG_WIRELESS_EXT
77 extern int dhd_wait_pend8021x(struct net_device *dev);
78 #endif
79
80 #if WIRELESS_EXT < 19
81 #define IW_IOCTL_IDX(cmd) ((cmd) - SIOCIWFIRST)
82 #define IW_EVENT_IDX(cmd) ((cmd) - IWEVFIRST)
83 #endif
84
85 static void *g_scan;
86 static volatile uint g_scan_specified_ssid;
87 static wlc_ssid_t g_specific_ssid;
88
89 static wlc_ssid_t g_ssid;
90
91 #if defined(WL_IW_USE_ISCAN)
92 #define ISCAN_STATE_IDLE 0
93 #define ISCAN_STATE_SCANING 1
94
95 #define WLC_IW_ISCAN_MAXLEN 2048
96 typedef struct iscan_buf {
97 struct iscan_buf *next;
98 char iscan_buf[WLC_IW_ISCAN_MAXLEN];
99 } iscan_buf_t;
100
101 typedef struct iscan_info {
102 struct net_device *dev;
103 struct timer_list timer;
104 u32 timer_ms;
105 u32 timer_on;
106 int iscan_state;
107 iscan_buf_t *list_hdr;
108 iscan_buf_t *list_cur;
109
110 struct task_struct *sysioc_tsk;
111 struct semaphore sysioc_sem;
112
113 #if defined CSCAN
114 char ioctlbuf[WLC_IOCTL_MEDLEN];
115 #else
116 char ioctlbuf[WLC_IOCTL_SMLEN];
117 #endif
118 wl_iscan_params_t *iscan_ex_params_p;
119 int iscan_ex_param_size;
120 } iscan_info_t;
121 iscan_info_t *g_iscan;
122
123 typedef enum sup_auth_status {
124 WLC_SUP_DISCONNECTED = 0,
125 WLC_SUP_CONNECTING,
126 WLC_SUP_IDREQUIRED,
127 WLC_SUP_AUTHENTICATING,
128 WLC_SUP_AUTHENTICATED,
129 WLC_SUP_KEYXCHANGE,
130 WLC_SUP_KEYED,
131 WLC_SUP_TIMEOUT,
132 WLC_SUP_LAST_BASIC_STATE,
133 WLC_SUP_KEYXCHANGE_WAIT_M1 = WLC_SUP_AUTHENTICATED,
134 WLC_SUP_KEYXCHANGE_PREP_M2 = WLC_SUP_KEYXCHANGE,
135 WLC_SUP_KEYXCHANGE_WAIT_M3 = WLC_SUP_LAST_BASIC_STATE,
136 WLC_SUP_KEYXCHANGE_PREP_M4,
137 WLC_SUP_KEYXCHANGE_WAIT_G1,
138 WLC_SUP_KEYXCHANGE_PREP_G2
139 } sup_auth_status_t;
140
141 static const u8 ether_bcast[ETH_ALEN] = {255, 255, 255, 255, 255, 255};
142
143 /* Global ASSERT type flag */
144 u32 g_assert_type;
145
146 static void wl_iw_timerfunc(unsigned long data);
147 static void wl_iw_set_event_mask(struct net_device *dev);
148 static int wl_iw_iscan(iscan_info_t *iscan, wlc_ssid_t *ssid, u16 action);
149 #endif /* defined(WL_IW_USE_ISCAN) */
150
151 static int
152 wl_iw_set_scan(struct net_device *dev,
153 struct iw_request_info *info,
154 union iwreq_data *wrqu, char *extra);
155
156 static int
157 wl_iw_get_scan(struct net_device *dev,
158 struct iw_request_info *info,
159 struct iw_point *dwrq, char *extra);
160
161 static uint
162 wl_iw_get_scan_prep(wl_scan_results_t *list,
163 struct iw_request_info *info, char *extra, short max_size);
164
165 static void swap_key_from_BE(wl_wsec_key_t *key)
166 {
167 key->index = cpu_to_le32(key->index);
168 key->len = cpu_to_le32(key->len);
169 key->algo = cpu_to_le32(key->algo);
170 key->flags = cpu_to_le32(key->flags);
171 key->rxiv.hi = cpu_to_le32(key->rxiv.hi);
172 key->rxiv.lo = cpu_to_le16(key->rxiv.lo);
173 key->iv_initialized = cpu_to_le32(key->iv_initialized);
174 }
175
176 static void swap_key_to_BE(wl_wsec_key_t *key)
177 {
178 key->index = le32_to_cpu(key->index);
179 key->len = le32_to_cpu(key->len);
180 key->algo = le32_to_cpu(key->algo);
181 key->flags = le32_to_cpu(key->flags);
182 key->rxiv.hi = le32_to_cpu(key->rxiv.hi);
183 key->rxiv.lo = le16_to_cpu(key->rxiv.lo);
184 key->iv_initialized = le32_to_cpu(key->iv_initialized);
185 }
186
187 static int dev_wlc_ioctl(struct net_device *dev, int cmd, void *arg, int len)
188 {
189 struct ifreq ifr;
190 wl_ioctl_t ioc;
191 mm_segment_t fs;
192 int ret = -EINVAL;
193
194 if (!dev) {
195 WL_ERROR("%s: dev is null\n", __func__);
196 return ret;
197 }
198
199 WL_INFORM("\n%s, PID:%x: send Local IOCTL -> dhd: cmd:0x%x, buf:%p, len:%d\n",
200 __func__, current->pid, cmd, arg, len);
201
202 if (g_onoff == G_WLAN_SET_ON) {
203 memset(&ioc, 0, sizeof(ioc));
204 ioc.cmd = cmd;
205 ioc.buf = arg;
206 ioc.len = len;
207
208 strcpy(ifr.ifr_name, dev->name);
209 ifr.ifr_data = (caddr_t)&ioc;
210
211 ret = dev_open(dev);
212 if (ret) {
213 WL_ERROR("%s: Error dev_open: %d\n", __func__, ret);
214 return ret;
215 }
216
217 fs = get_fs();
218 set_fs(get_ds());
219 ret = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
220 set_fs(fs);
221 } else {
222 WL_TRACE("%s: call after driver stop : ignored\n", __func__);
223 }
224 return ret;
225 }
226
227 static int dev_wlc_intvar_set(struct net_device *dev, char *name, int val)
228 {
229 char buf[WLC_IOCTL_SMLEN];
230 uint len;
231
232 val = cpu_to_le32(val);
233 len = brcmu_mkiovar(name, (char *)(&val), sizeof(val), buf,
234 sizeof(buf));
235 ASSERT(len);
236
237 return dev_wlc_ioctl(dev, WLC_SET_VAR, buf, len);
238 }
239
240 #if defined(WL_IW_USE_ISCAN)
241 static int
242 dev_iw_iovar_setbuf(struct net_device *dev,
243 char *iovar,
244 void *param, int paramlen, void *bufptr, int buflen)
245 {
246 int iolen;
247
248 iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
249 ASSERT(iolen);
250
251 if (iolen == 0)
252 return 0;
253
254 return dev_wlc_ioctl(dev, WLC_SET_VAR, bufptr, iolen);
255 }
256
257 static int
258 dev_iw_iovar_getbuf(struct net_device *dev,
259 char *iovar,
260 void *param, int paramlen, void *bufptr, int buflen)
261 {
262 int iolen;
263
264 iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
265 ASSERT(iolen);
266
267 return dev_wlc_ioctl(dev, WLC_GET_VAR, bufptr, buflen);
268 }
269 #endif /* defined(WL_IW_USE_ISCAN) */
270
271 #if WIRELESS_EXT > 17
272 static int
273 dev_wlc_bufvar_set(struct net_device *dev, char *name, char *buf, int len)
274 {
275 static char ioctlbuf[MAX_WLIW_IOCTL_LEN];
276 uint buflen;
277
278 buflen = brcmu_mkiovar(name, buf, len, ioctlbuf, sizeof(ioctlbuf));
279 ASSERT(buflen);
280
281 return dev_wlc_ioctl(dev, WLC_SET_VAR, ioctlbuf, buflen);
282 }
283 #endif /* WIRELESS_EXT > 17 */
284
285 static int
286 dev_wlc_bufvar_get(struct net_device *dev, char *name, char *buf, int buflen)
287 {
288 static char ioctlbuf[MAX_WLIW_IOCTL_LEN];
289 int error;
290 uint len;
291
292 len = brcmu_mkiovar(name, NULL, 0, ioctlbuf, sizeof(ioctlbuf));
293 ASSERT(len);
294 error =
295 dev_wlc_ioctl(dev, WLC_GET_VAR, (void *)ioctlbuf,
296 MAX_WLIW_IOCTL_LEN);
297 if (!error)
298 memcpy(buf, ioctlbuf, buflen);
299
300 return error;
301 }
302
303 static int dev_wlc_intvar_get(struct net_device *dev, char *name, int *retval)
304 {
305 union {
306 char buf[WLC_IOCTL_SMLEN];
307 int val;
308 } var;
309 int error;
310
311 uint len;
312 uint data_null;
313
314 len =
315 brcmu_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
316 sizeof(var.buf));
317 ASSERT(len);
318 error = dev_wlc_ioctl(dev, WLC_GET_VAR, (void *)&var, len);
319
320 *retval = le32_to_cpu(var.val);
321
322 return error;
323 }
324
325 #if WIRELESS_EXT < 13
326 struct iw_request_info {
327 __u16 cmd;
328 __u16 flags;
329 };
330
331 typedef int (*iw_handler) (struct net_device *dev,
332 struct iw_request_info *info,
333 void *wrqu, char *extra);
334 #endif
335
336 static int
337 wl_iw_config_commit(struct net_device *dev,
338 struct iw_request_info *info, void *zwrq, char *extra)
339 {
340 wlc_ssid_t ssid;
341 int error;
342 struct sockaddr bssid;
343
344 WL_TRACE("%s: SIOCSIWCOMMIT\n", dev->name);
345
346 error = dev_wlc_ioctl(dev, WLC_GET_SSID, &ssid, sizeof(ssid));
347 if (error)
348 return error;
349
350 ssid.SSID_len = le32_to_cpu(ssid.SSID_len);
351
352 if (!ssid.SSID_len)
353 return 0;
354
355 memset(&bssid, 0, sizeof(struct sockaddr));
356 error = dev_wlc_ioctl(dev, WLC_REASSOC, &bssid, ETH_ALEN);
357 if (error) {
358 WL_ERROR("%s: WLC_REASSOC to %s failed\n",
359 __func__, ssid.SSID);
360 return error;
361 }
362
363 return 0;
364 }
365
366 static int
367 wl_iw_get_name(struct net_device *dev,
368 struct iw_request_info *info, char *cwrq, char *extra)
369 {
370 WL_TRACE("%s: SIOCGIWNAME\n", dev->name);
371
372 strcpy(cwrq, "IEEE 802.11-DS");
373
374 return 0;
375 }
376
377 static int
378 wl_iw_set_freq(struct net_device *dev,
379 struct iw_request_info *info, struct iw_freq *fwrq, char *extra)
380 {
381 int error, chan;
382 uint sf = 0;
383
384 WL_TRACE("\n %s %s: SIOCSIWFREQ\n", __func__, dev->name);
385
386 if (fwrq->e == 0 && fwrq->m < MAXCHANNEL) {
387 chan = fwrq->m;
388 } else {
389 if (fwrq->e >= 6) {
390 fwrq->e -= 6;
391 while (fwrq->e--)
392 fwrq->m *= 10;
393 } else if (fwrq->e < 6) {
394 while (fwrq->e++ < 6)
395 fwrq->m /= 10;
396 }
397 if (fwrq->m > 4000 && fwrq->m < 5000)
398 sf = WF_CHAN_FACTOR_4_G;
399
400 chan = brcmu_mhz2channel(fwrq->m, sf);
401 }
402 chan = cpu_to_le32(chan);
403
404 error = dev_wlc_ioctl(dev, WLC_SET_CHANNEL, &chan, sizeof(chan));
405 if (error)
406 return error;
407
408 g_wl_iw_params.target_channel = chan;
409 return -EINPROGRESS;
410 }
411
412 static int
413 wl_iw_get_freq(struct net_device *dev,
414 struct iw_request_info *info, struct iw_freq *fwrq, char *extra)
415 {
416 channel_info_t ci;
417 int error;
418
419 WL_TRACE("%s: SIOCGIWFREQ\n", dev->name);
420
421 error = dev_wlc_ioctl(dev, WLC_GET_CHANNEL, &ci, sizeof(ci));
422 if (error)
423 return error;
424
425 fwrq->m = le32_to_cpu(ci.hw_channel);
426 fwrq->e = le32_to_cpu(0);
427 return 0;
428 }
429
430 static int
431 wl_iw_set_mode(struct net_device *dev,
432 struct iw_request_info *info, __u32 *uwrq, char *extra)
433 {
434 int infra = 0, ap = 0, error = 0;
435
436 WL_TRACE("%s: SIOCSIWMODE\n", dev->name);
437
438 switch (*uwrq) {
439 case IW_MODE_MASTER:
440 infra = ap = 1;
441 break;
442 case IW_MODE_ADHOC:
443 case IW_MODE_AUTO:
444 break;
445 case IW_MODE_INFRA:
446 infra = 1;
447 break;
448 default:
449 return -EINVAL;
450 }
451 infra = cpu_to_le32(infra);
452 ap = cpu_to_le32(ap);
453
454 error = dev_wlc_ioctl(dev, WLC_SET_INFRA, &infra, sizeof(infra));
455 if (error)
456 return error;
457
458 error = dev_wlc_ioctl(dev, WLC_SET_AP, &ap, sizeof(ap));
459 if (error)
460 return error;
461
462 return -EINPROGRESS;
463 }
464
465 static int
466 wl_iw_get_mode(struct net_device *dev,
467 struct iw_request_info *info, __u32 *uwrq, char *extra)
468 {
469 int error, infra = 0, ap = 0;
470
471 WL_TRACE("%s: SIOCGIWMODE\n", dev->name);
472
473 error = dev_wlc_ioctl(dev, WLC_GET_INFRA, &infra, sizeof(infra));
474 if (error)
475 return error;
476
477 error = dev_wlc_ioctl(dev, WLC_GET_AP, &ap, sizeof(ap));
478 if (error)
479 return error;
480
481 infra = le32_to_cpu(infra);
482 ap = le32_to_cpu(ap);
483 *uwrq = infra ? ap ? IW_MODE_MASTER : IW_MODE_INFRA : IW_MODE_ADHOC;
484
485 return 0;
486 }
487
488 static int
489 wl_iw_get_range(struct net_device *dev,
490 struct iw_request_info *info,
491 struct iw_point *dwrq, char *extra)
492 {
493 struct iw_range *range = (struct iw_range *)extra;
494 wl_u32_list_t *list;
495 wl_rateset_t rateset;
496 s8 *channels;
497 int error, i, k;
498 uint ch;
499
500 int phytype;
501 int bw_cap = 0, sgi_tx = 0, nmode = 0;
502 channel_info_t ci;
503 u8 nrate_list2copy = 0;
504 u16 nrate_list[4][8] = { {13, 26, 39, 52, 78, 104, 117, 130},
505 {14, 29, 43, 58, 87, 116, 130, 144},
506 {27, 54, 81, 108, 162, 216, 243, 270},
507 {30, 60, 90, 120, 180, 240, 270, 300}
508 };
509
510 WL_TRACE("%s: SIOCGIWRANGE\n", dev->name);
511
512 if (!extra)
513 return -EINVAL;
514
515 channels = kmalloc((MAXCHANNEL + 1) * 4, GFP_KERNEL);
516 if (!channels) {
517 WL_ERROR("Could not alloc channels\n");
518 return -ENOMEM;
519 }
520 list = (wl_u32_list_t *) channels;
521
522 dwrq->length = sizeof(struct iw_range);
523 memset(range, 0, sizeof(*range));
524
525 list->count = cpu_to_le32(MAXCHANNEL);
526 error = dev_wlc_ioctl(dev, WLC_GET_VALID_CHANNELS, channels,
527 (MAXCHANNEL + 1) * 4);
528 if (error) {
529 kfree(channels);
530 return error;
531 }
532 for (i = 0; i < le32_to_cpu(list->count) && i < IW_MAX_FREQUENCIES;
533 i++) {
534 range->freq[i].i = le32_to_cpu(list->element[i]);
535
536 ch = le32_to_cpu(list->element[i]);
537 if (ch <= CH_MAX_2G_CHANNEL) {
538 range->freq[i].m = ieee80211_dsss_chan_to_freq(ch);
539 } else {
540 range->freq[i].m = ieee80211_ofdm_chan_to_freq(
541 WF_CHAN_FACTOR_5_G/2, ch);
542 }
543 range->freq[i].e = 6;
544 }
545 range->num_frequency = range->num_channels = i;
546
547 range->max_qual.qual = 5;
548 range->max_qual.level = 0x100 - 200;
549 range->max_qual.noise = 0x100 - 200;
550 range->sensitivity = 65535;
551
552 #if WIRELESS_EXT > 11
553 range->avg_qual.qual = 3;
554 range->avg_qual.level = 0x100 + WL_IW_RSSI_GOOD;
555 range->avg_qual.noise = 0x100 - 75;
556 #endif
557
558 error = dev_wlc_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
559 sizeof(rateset));
560 if (error) {
561 kfree(channels);
562 return error;
563 }
564 rateset.count = le32_to_cpu(rateset.count);
565 range->num_bitrates = rateset.count;
566 for (i = 0; i < rateset.count && i < IW_MAX_BITRATES; i++)
567 range->bitrate[i] = (rateset.rates[i] & 0x7f) * 500000;
568 dev_wlc_intvar_get(dev, "nmode", &nmode);
569 dev_wlc_ioctl(dev, WLC_GET_PHYTYPE, &phytype, sizeof(phytype));
570
571 if (nmode == 1 && phytype == WLC_PHY_TYPE_SSN) {
572 dev_wlc_intvar_get(dev, "mimo_bw_cap", &bw_cap);
573 dev_wlc_intvar_get(dev, "sgi_tx", &sgi_tx);
574 dev_wlc_ioctl(dev, WLC_GET_CHANNEL, &ci,
575 sizeof(channel_info_t));
576 ci.hw_channel = le32_to_cpu(ci.hw_channel);
577
578 if (bw_cap == 0 || (bw_cap == 2 && ci.hw_channel <= 14)) {
579 if (sgi_tx == 0)
580 nrate_list2copy = 0;
581 else
582 nrate_list2copy = 1;
583 }
584 if (bw_cap == 1 || (bw_cap == 2 && ci.hw_channel >= 36)) {
585 if (sgi_tx == 0)
586 nrate_list2copy = 2;
587 else
588 nrate_list2copy = 3;
589 }
590 range->num_bitrates += 8;
591 for (k = 0; i < range->num_bitrates; k++, i++) {
592 range->bitrate[i] =
593 (nrate_list[nrate_list2copy][k]) * 500000;
594 }
595 }
596
597 error = dev_wlc_ioctl(dev, WLC_GET_PHYTYPE, &i, sizeof(i));
598 if (error) {
599 kfree(channels);
600 return error;
601 }
602 i = le32_to_cpu(i);
603 if (i == WLC_PHY_TYPE_A)
604 range->throughput = 24000000;
605 else
606 range->throughput = 1500000;
607
608 range->min_rts = 0;
609 range->max_rts = 2347;
610 range->min_frag = 256;
611 range->max_frag = 2346;
612
613 range->max_encoding_tokens = DOT11_MAX_DEFAULT_KEYS;
614 range->num_encoding_sizes = 4;
615 range->encoding_size[0] = WLAN_KEY_LEN_WEP40;
616 range->encoding_size[1] = WLAN_KEY_LEN_WEP104;
617 #if WIRELESS_EXT > 17
618 range->encoding_size[2] = WLAN_KEY_LEN_TKIP;
619 #else
620 range->encoding_size[2] = 0;
621 #endif
622 range->encoding_size[3] = WLAN_KEY_LEN_AES_CMAC;
623
624 range->min_pmp = 0;
625 range->max_pmp = 0;
626 range->min_pmt = 0;
627 range->max_pmt = 0;
628 range->pmp_flags = 0;
629 range->pm_capa = 0;
630
631 range->num_txpower = 2;
632 range->txpower[0] = 1;
633 range->txpower[1] = 255;
634 range->txpower_capa = IW_TXPOW_MWATT;
635
636 #if WIRELESS_EXT > 10
637 range->we_version_compiled = WIRELESS_EXT;
638 range->we_version_source = 19;
639
640 range->retry_capa = IW_RETRY_LIMIT;
641 range->retry_flags = IW_RETRY_LIMIT;
642 range->r_time_flags = 0;
643 range->min_retry = 1;
644 range->max_retry = 255;
645 range->min_r_time = 0;
646 range->max_r_time = 0;
647 #endif
648
649 #if WIRELESS_EXT > 17
650 range->enc_capa = IW_ENC_CAPA_WPA;
651 range->enc_capa |= IW_ENC_CAPA_CIPHER_TKIP;
652 range->enc_capa |= IW_ENC_CAPA_CIPHER_CCMP;
653 range->enc_capa |= IW_ENC_CAPA_WPA2;
654
655 IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
656 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
657 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
658 IW_EVENT_CAPA_SET(range->event_capa, IWEVTXDROP);
659 IW_EVENT_CAPA_SET(range->event_capa, IWEVMICHAELMICFAILURE);
660 IW_EVENT_CAPA_SET(range->event_capa, IWEVPMKIDCAND);
661 #endif /* WIRELESS_EXT > 17 */
662
663 kfree(channels);
664
665 return 0;
666 }
667
668 static int rssi_to_qual(int rssi)
669 {
670 if (rssi <= WL_IW_RSSI_NO_SIGNAL)
671 return 0;
672 else if (rssi <= WL_IW_RSSI_VERY_LOW)
673 return 1;
674 else if (rssi <= WL_IW_RSSI_LOW)
675 return 2;
676 else if (rssi <= WL_IW_RSSI_GOOD)
677 return 3;
678 else if (rssi <= WL_IW_RSSI_VERY_GOOD)
679 return 4;
680 else
681 return 5;
682 }
683
684 static int
685 wl_iw_set_spy(struct net_device *dev,
686 struct iw_request_info *info, struct iw_point *dwrq, char *extra)
687 {
688 wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
689 struct sockaddr *addr = (struct sockaddr *)extra;
690 int i;
691
692 WL_TRACE("%s: SIOCSIWSPY\n", dev->name);
693
694 if (!extra)
695 return -EINVAL;
696
697 iw->spy_num = min_t(int, ARRAY_SIZE(iw->spy_addr), dwrq->length);
698 for (i = 0; i < iw->spy_num; i++)
699 memcpy(iw->spy_addr[i], addr[i].sa_data, ETH_ALEN);
700 memset(iw->spy_qual, 0, sizeof(iw->spy_qual));
701
702 return 0;
703 }
704
705 static int
706 wl_iw_get_spy(struct net_device *dev,
707 struct iw_request_info *info, struct iw_point *dwrq, char *extra)
708 {
709 wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
710 struct sockaddr *addr = (struct sockaddr *)extra;
711 struct iw_quality *qual = (struct iw_quality *)&addr[iw->spy_num];
712 int i;
713
714 WL_TRACE("%s: SIOCGIWSPY\n", dev->name);
715
716 if (!extra)
717 return -EINVAL;
718
719 dwrq->length = iw->spy_num;
720 for (i = 0; i < iw->spy_num; i++) {
721 memcpy(addr[i].sa_data, iw->spy_addr[i], ETH_ALEN);
722 addr[i].sa_family = AF_UNIX;
723 memcpy(&qual[i], &iw->spy_qual[i], sizeof(struct iw_quality));
724 iw->spy_qual[i].updated = 0;
725 }
726
727 return 0;
728 }
729
730 static int
731 wl_iw_ch_to_chanspec(int ch, wl_join_params_t *join_params,
732 int *join_params_size)
733 {
734 chanspec_t chanspec = 0;
735
736 if (ch != 0) {
737 join_params->params.chanspec_num = 1;
738 join_params->params.chanspec_list[0] = ch;
739
740 if (join_params->params.chanspec_list[0])
741 chanspec |= WL_CHANSPEC_BAND_2G;
742 else
743 chanspec |= WL_CHANSPEC_BAND_5G;
744
745 chanspec |= WL_CHANSPEC_BW_20;
746 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
747
748 *join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
749 join_params->params.chanspec_num * sizeof(chanspec_t);
750
751 join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
752 join_params->params.chanspec_list[0] |= chanspec;
753 join_params->params.chanspec_list[0] =
754 cpu_to_le16(join_params->params.chanspec_list[0]);
755
756 join_params->params.chanspec_num =
757 cpu_to_le32(join_params->params.chanspec_num);
758
759 WL_TRACE("%s join_params->params.chanspec_list[0]= %X\n",
760 __func__, join_params->params.chanspec_list[0]);
761 }
762 return 1;
763 }
764
765 static int
766 wl_iw_set_wap(struct net_device *dev,
767 struct iw_request_info *info, struct sockaddr *awrq, char *extra)
768 {
769 int error = -EINVAL;
770 wl_join_params_t join_params;
771 int join_params_size;
772
773 WL_TRACE("%s: SIOCSIWAP\n", dev->name);
774
775 if (awrq->sa_family != ARPHRD_ETHER) {
776 WL_ERROR("Invalid Header...sa_family\n");
777 return -EINVAL;
778 }
779
780 if (is_broadcast_ether_addr(awrq->sa_data) ||
781 is_zero_ether_addr(awrq->sa_data)) {
782 scb_val_t scbval;
783 memset(&scbval, 0, sizeof(scb_val_t));
784 (void)dev_wlc_ioctl(dev, WLC_DISASSOC, &scbval,
785 sizeof(scb_val_t));
786 return 0;
787 }
788
789 memset(&join_params, 0, sizeof(join_params));
790 join_params_size = sizeof(join_params.ssid);
791
792 memcpy(join_params.ssid.SSID, g_ssid.SSID, g_ssid.SSID_len);
793 join_params.ssid.SSID_len = cpu_to_le32(g_ssid.SSID_len);
794 memcpy(&join_params.params.bssid, awrq->sa_data, ETH_ALEN);
795
796 WL_TRACE("%s target_channel=%d\n",
797 __func__, g_wl_iw_params.target_channel);
798 wl_iw_ch_to_chanspec(g_wl_iw_params.target_channel, &join_params,
799 &join_params_size);
800
801 error = dev_wlc_ioctl(dev, WLC_SET_SSID, &join_params,
802 join_params_size);
803 if (error) {
804 WL_ERROR("%s Invalid ioctl data=%d\n", __func__, error);
805 }
806
807 if (g_ssid.SSID_len) {
808 WL_TRACE("%s: join SSID=%s BSSID=%pM ch=%d\n",
809 __func__, g_ssid.SSID, awrq->sa_data,
810 g_wl_iw_params.target_channel);
811 }
812
813 memset(&g_ssid, 0, sizeof(g_ssid));
814 return 0;
815 }
816
817 static int
818 wl_iw_get_wap(struct net_device *dev,
819 struct iw_request_info *info, struct sockaddr *awrq, char *extra)
820 {
821 WL_TRACE("%s: SIOCGIWAP\n", dev->name);
822
823 awrq->sa_family = ARPHRD_ETHER;
824 memset(awrq->sa_data, 0, ETH_ALEN);
825
826 (void)dev_wlc_ioctl(dev, WLC_GET_BSSID, awrq->sa_data, ETH_ALEN);
827
828 return 0;
829 }
830
831 #if WIRELESS_EXT > 17
832 static int
833 wl_iw_mlme(struct net_device *dev,
834 struct iw_request_info *info, struct sockaddr *awrq, char *extra)
835 {
836 struct iw_mlme *mlme;
837 scb_val_t scbval;
838 int error = -EINVAL;
839
840 WL_TRACE("%s: SIOCSIWMLME DISASSOC/DEAUTH\n", dev->name);
841
842 mlme = (struct iw_mlme *)extra;
843 if (mlme == NULL) {
844 WL_ERROR("Invalid ioctl data\n");
845 return error;
846 }
847
848 scbval.val = mlme->reason_code;
849 memcpy(&scbval.ea, &mlme->addr.sa_data, ETH_ALEN);
850
851 if (mlme->cmd == IW_MLME_DISASSOC) {
852 scbval.val = cpu_to_le32(scbval.val);
853 error =
854 dev_wlc_ioctl(dev, WLC_DISASSOC, &scbval,
855 sizeof(scb_val_t));
856 } else if (mlme->cmd == IW_MLME_DEAUTH) {
857 scbval.val = cpu_to_le32(scbval.val);
858 error =
859 dev_wlc_ioctl(dev, WLC_SCB_DEAUTHENTICATE_FOR_REASON,
860 &scbval, sizeof(scb_val_t));
861 } else {
862 WL_ERROR("Invalid ioctl data\n");
863 return error;
864 }
865
866 return error;
867 }
868 #endif /* WIRELESS_EXT > 17 */
869
870 #ifndef WL_IW_USE_ISCAN
871 static int
872 wl_iw_get_aplist(struct net_device *dev,
873 struct iw_request_info *info,
874 struct iw_point *dwrq, char *extra)
875 {
876 wl_scan_results_t *list;
877 struct sockaddr *addr = (struct sockaddr *)extra;
878 struct iw_quality qual[IW_MAX_AP];
879 wl_bss_info_t *bi = NULL;
880 int error, i;
881 uint buflen = dwrq->length;
882
883 WL_TRACE("%s: SIOCGIWAPLIST\n", dev->name);
884
885 if (!extra)
886 return -EINVAL;
887
888 list = kzalloc(buflen, GFP_KERNEL);
889 if (!list)
890 return -ENOMEM;
891 list->buflen = cpu_to_le32(buflen);
892 error = dev_wlc_ioctl(dev, WLC_SCAN_RESULTS, list, buflen);
893 if (error) {
894 WL_ERROR("%d: Scan results error %d\n", __LINE__, error);
895 kfree(list);
896 return error;
897 }
898 list->buflen = le32_to_cpu(list->buflen);
899 list->version = le32_to_cpu(list->version);
900 list->count = le32_to_cpu(list->count);
901 if (list->version != WL_BSS_INFO_VERSION) {
902 WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
903 __func__, list->version);
904 kfree(list);
905 return -EINVAL;
906 }
907
908 for (i = 0, dwrq->length = 0;
909 i < list->count && dwrq->length < IW_MAX_AP; i++) {
910 bi = bi ? (wl_bss_info_t *) ((unsigned long)bi +
911 le32_to_cpu(bi->length)) : list->
912 bss_info;
913 ASSERT(((unsigned long)bi + le32_to_cpu(bi->length)) <=
914 ((unsigned long)list + buflen));
915
916 if (!(le16_to_cpu(bi->capability) & WLAN_CAPABILITY_ESS))
917 continue;
918
919 memcpy(addr[dwrq->length].sa_data, &bi->BSSID, ETH_ALEN);
920 addr[dwrq->length].sa_family = ARPHRD_ETHER;
921 qual[dwrq->length].qual = rssi_to_qual(le16_to_cpu(bi->RSSI));
922 qual[dwrq->length].level = 0x100 + le16_to_cpu(bi->RSSI);
923 qual[dwrq->length].noise = 0x100 + bi->phy_noise;
924
925 #if WIRELESS_EXT > 18
926 qual[dwrq->length].updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
927 #else
928 qual[dwrq->length].updated = 7;
929 #endif
930 dwrq->length++;
931 }
932
933 kfree(list);
934
935 if (dwrq->length) {
936 memcpy(&addr[dwrq->length], qual,
937 sizeof(struct iw_quality) * dwrq->length);
938 dwrq->flags = 1;
939 }
940
941 return 0;
942 }
943 #endif /* WL_IW_USE_ISCAN */
944
945 #ifdef WL_IW_USE_ISCAN
946 static int
947 wl_iw_iscan_get_aplist(struct net_device *dev,
948 struct iw_request_info *info,
949 struct iw_point *dwrq, char *extra)
950 {
951 wl_scan_results_t *list;
952 iscan_buf_t *buf;
953 iscan_info_t *iscan = g_iscan;
954
955 struct sockaddr *addr = (struct sockaddr *)extra;
956 struct iw_quality qual[IW_MAX_AP];
957 wl_bss_info_t *bi = NULL;
958 int i;
959
960 WL_TRACE("%s: SIOCGIWAPLIST\n", dev->name);
961
962 if (!extra)
963 return -EINVAL;
964
965 if ((!iscan) || (!iscan->sysioc_tsk)) {
966 WL_ERROR("%s error\n", __func__);
967 return 0;
968 }
969
970 buf = iscan->list_hdr;
971 while (buf) {
972 list = &((wl_iscan_results_t *) buf->iscan_buf)->results;
973 if (list->version != WL_BSS_INFO_VERSION) {
974 WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
975 __func__, list->version);
976 return -EINVAL;
977 }
978
979 bi = NULL;
980 for (i = 0, dwrq->length = 0;
981 i < list->count && dwrq->length < IW_MAX_AP; i++) {
982 bi = bi ? (wl_bss_info_t *) ((unsigned long)bi +
983 le32_to_cpu(bi->length)) :
984 list->bss_info;
985 ASSERT(((unsigned long)bi + le32_to_cpu(bi->length)) <=
986 ((unsigned long)list + WLC_IW_ISCAN_MAXLEN));
987
988 if (!(le16_to_cpu(bi->capability) &
989 WLAN_CAPABILITY_ESS))
990 continue;
991
992 memcpy(addr[dwrq->length].sa_data, &bi->BSSID,
993 ETH_ALEN);
994 addr[dwrq->length].sa_family = ARPHRD_ETHER;
995 qual[dwrq->length].qual =
996 rssi_to_qual(le16_to_cpu(bi->RSSI));
997 qual[dwrq->length].level = 0x100 +
998 le16_to_cpu(bi->RSSI);
999 qual[dwrq->length].noise = 0x100 + bi->phy_noise;
1000
1001 #if WIRELESS_EXT > 18
1002 qual[dwrq->length].updated =
1003 IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1004 #else
1005 qual[dwrq->length].updated = 7;
1006 #endif
1007
1008 dwrq->length++;
1009 }
1010 buf = buf->next;
1011 }
1012 if (dwrq->length) {
1013 memcpy(&addr[dwrq->length], qual,
1014 sizeof(struct iw_quality) * dwrq->length);
1015 dwrq->flags = 1;
1016 }
1017
1018 return 0;
1019 }
1020
1021 static int wl_iw_iscan_prep(wl_scan_params_t *params, wlc_ssid_t *ssid)
1022 {
1023 int err = 0;
1024
1025 memcpy(params->bssid, ether_bcast, ETH_ALEN);
1026 params->bss_type = DOT11_BSSTYPE_ANY;
1027 params->scan_type = 0;
1028 params->nprobes = -1;
1029 params->active_time = -1;
1030 params->passive_time = -1;
1031 params->home_time = -1;
1032 params->channel_num = 0;
1033
1034 params->nprobes = cpu_to_le32(params->nprobes);
1035 params->active_time = cpu_to_le32(params->active_time);
1036 params->passive_time = cpu_to_le32(params->passive_time);
1037 params->home_time = cpu_to_le32(params->home_time);
1038 if (ssid && ssid->SSID_len)
1039 memcpy(&params->ssid, ssid, sizeof(wlc_ssid_t));
1040
1041 return err;
1042 }
1043
1044 static int wl_iw_iscan(iscan_info_t *iscan, wlc_ssid_t *ssid, u16 action)
1045 {
1046 int err = 0;
1047
1048 iscan->iscan_ex_params_p->version = cpu_to_le32(ISCAN_REQ_VERSION);
1049 iscan->iscan_ex_params_p->action = cpu_to_le16(action);
1050 iscan->iscan_ex_params_p->scan_duration = cpu_to_le16(0);
1051
1052 WL_SCAN("%s : nprobes=%d\n",
1053 __func__, iscan->iscan_ex_params_p->params.nprobes);
1054 WL_SCAN("active_time=%d\n",
1055 iscan->iscan_ex_params_p->params.active_time);
1056 WL_SCAN("passive_time=%d\n",
1057 iscan->iscan_ex_params_p->params.passive_time);
1058 WL_SCAN("home_time=%d\n", iscan->iscan_ex_params_p->params.home_time);
1059 WL_SCAN("scan_type=%d\n", iscan->iscan_ex_params_p->params.scan_type);
1060 WL_SCAN("bss_type=%d\n", iscan->iscan_ex_params_p->params.bss_type);
1061
1062 (void)dev_iw_iovar_setbuf(iscan->dev, "iscan", iscan->iscan_ex_params_p,
1063 iscan->iscan_ex_param_size, iscan->ioctlbuf,
1064 sizeof(iscan->ioctlbuf));
1065
1066 return err;
1067 }
1068
1069 static void wl_iw_timerfunc(unsigned long data)
1070 {
1071 iscan_info_t *iscan = (iscan_info_t *) data;
1072 if (iscan) {
1073 iscan->timer_on = 0;
1074 if (iscan->iscan_state != ISCAN_STATE_IDLE) {
1075 WL_TRACE("timer trigger\n");
1076 up(&iscan->sysioc_sem);
1077 }
1078 }
1079 }
1080
1081 static void wl_iw_set_event_mask(struct net_device *dev)
1082 {
1083 char eventmask[WL_EVENTING_MASK_LEN];
1084 char iovbuf[WL_EVENTING_MASK_LEN + 12];
1085
1086 dev_iw_iovar_getbuf(dev, "event_msgs", "", 0, iovbuf, sizeof(iovbuf));
1087 memcpy(eventmask, iovbuf, WL_EVENTING_MASK_LEN);
1088 setbit(eventmask, WLC_E_SCAN_COMPLETE);
1089 dev_iw_iovar_setbuf(dev, "event_msgs", eventmask, WL_EVENTING_MASK_LEN,
1090 iovbuf, sizeof(iovbuf));
1091 }
1092
1093 static u32 wl_iw_iscan_get(iscan_info_t *iscan)
1094 {
1095 iscan_buf_t *buf;
1096 iscan_buf_t *ptr;
1097 wl_iscan_results_t *list_buf;
1098 wl_iscan_results_t list;
1099 wl_scan_results_t *results;
1100 u32 status;
1101 int res = 0;
1102
1103 MUTEX_LOCK_WL_SCAN_SET();
1104 if (iscan->list_cur) {
1105 buf = iscan->list_cur;
1106 iscan->list_cur = buf->next;
1107 } else {
1108 buf = kmalloc(sizeof(iscan_buf_t), GFP_KERNEL);
1109 if (!buf) {
1110 WL_ERROR("%s can't alloc iscan_buf_t : going to abort current iscan\n",
1111 __func__);
1112 MUTEX_UNLOCK_WL_SCAN_SET();
1113 return WL_SCAN_RESULTS_NO_MEM;
1114 }
1115 buf->next = NULL;
1116 if (!iscan->list_hdr)
1117 iscan->list_hdr = buf;
1118 else {
1119 ptr = iscan->list_hdr;
1120 while (ptr->next) {
1121 ptr = ptr->next;
1122 }
1123 ptr->next = buf;
1124 }
1125 }
1126 memset(buf->iscan_buf, 0, WLC_IW_ISCAN_MAXLEN);
1127 list_buf = (wl_iscan_results_t *) buf->iscan_buf;
1128 results = &list_buf->results;
1129 results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
1130 results->version = 0;
1131 results->count = 0;
1132
1133 memset(&list, 0, sizeof(list));
1134 list.results.buflen = cpu_to_le32(WLC_IW_ISCAN_MAXLEN);
1135 res = dev_iw_iovar_getbuf(iscan->dev,
1136 "iscanresults",
1137 &list,
1138 WL_ISCAN_RESULTS_FIXED_SIZE,
1139 buf->iscan_buf, WLC_IW_ISCAN_MAXLEN);
1140 if (res == 0) {
1141 results->buflen = le32_to_cpu(results->buflen);
1142 results->version = le32_to_cpu(results->version);
1143 results->count = le32_to_cpu(results->count);
1144 WL_TRACE("results->count = %d\n", results->count);
1145 WL_TRACE("results->buflen = %d\n", results->buflen);
1146 status = le32_to_cpu(list_buf->status);
1147 } else {
1148 WL_ERROR("%s returns error %d\n", __func__, res);
1149 status = WL_SCAN_RESULTS_NO_MEM;
1150 }
1151 MUTEX_UNLOCK_WL_SCAN_SET();
1152 return status;
1153 }
1154
1155 static void wl_iw_force_specific_scan(iscan_info_t *iscan)
1156 {
1157 WL_TRACE("%s force Specific SCAN for %s\n",
1158 __func__, g_specific_ssid.SSID);
1159 rtnl_lock();
1160
1161 (void)dev_wlc_ioctl(iscan->dev, WLC_SCAN, &g_specific_ssid,
1162 sizeof(g_specific_ssid));
1163
1164 rtnl_unlock();
1165 }
1166
1167 static void wl_iw_send_scan_complete(iscan_info_t *iscan)
1168 {
1169 #ifndef SANDGATE2G
1170 union iwreq_data wrqu;
1171
1172 memset(&wrqu, 0, sizeof(wrqu));
1173
1174 wireless_send_event(iscan->dev, SIOCGIWSCAN, &wrqu, NULL);
1175 WL_TRACE("Send Event ISCAN complete\n");
1176 #endif
1177 }
1178
1179 static int _iscan_sysioc_thread(void *data)
1180 {
1181 u32 status;
1182 iscan_info_t *iscan = (iscan_info_t *) data;
1183 static bool iscan_pass_abort = false;
1184
1185 allow_signal(SIGTERM);
1186 status = WL_SCAN_RESULTS_PARTIAL;
1187 while (down_interruptible(&iscan->sysioc_sem) == 0) {
1188 if (kthread_should_stop())
1189 break;
1190
1191 if (iscan->timer_on) {
1192 del_timer_sync(&iscan->timer);
1193 iscan->timer_on = 0;
1194 }
1195 rtnl_lock();
1196 status = wl_iw_iscan_get(iscan);
1197 rtnl_unlock();
1198 if (g_scan_specified_ssid && (iscan_pass_abort == true)) {
1199 WL_TRACE("%s Get results from specific scan status = %d\n",
1200 __func__, status);
1201 wl_iw_send_scan_complete(iscan);
1202 iscan_pass_abort = false;
1203 status = -1;
1204 }
1205
1206 switch (status) {
1207 case WL_SCAN_RESULTS_PARTIAL:
1208 WL_TRACE("iscanresults incomplete\n");
1209 rtnl_lock();
1210 wl_iw_iscan(iscan, NULL, WL_SCAN_ACTION_CONTINUE);
1211 rtnl_unlock();
1212 mod_timer(&iscan->timer,
1213 jiffies + iscan->timer_ms * HZ / 1000);
1214 iscan->timer_on = 1;
1215 break;
1216 case WL_SCAN_RESULTS_SUCCESS:
1217 WL_TRACE("iscanresults complete\n");
1218 iscan->iscan_state = ISCAN_STATE_IDLE;
1219 wl_iw_send_scan_complete(iscan);
1220 break;
1221 case WL_SCAN_RESULTS_PENDING:
1222 WL_TRACE("iscanresults pending\n");
1223 mod_timer(&iscan->timer,
1224 jiffies + iscan->timer_ms * HZ / 1000);
1225 iscan->timer_on = 1;
1226 break;
1227 case WL_SCAN_RESULTS_ABORTED:
1228 WL_TRACE("iscanresults aborted\n");
1229 iscan->iscan_state = ISCAN_STATE_IDLE;
1230 if (g_scan_specified_ssid == 0)
1231 wl_iw_send_scan_complete(iscan);
1232 else {
1233 iscan_pass_abort = true;
1234 wl_iw_force_specific_scan(iscan);
1235 }
1236 break;
1237 case WL_SCAN_RESULTS_NO_MEM:
1238 WL_TRACE("iscanresults can't alloc memory: skip\n");
1239 iscan->iscan_state = ISCAN_STATE_IDLE;
1240 break;
1241 default:
1242 WL_TRACE("iscanresults returned unknown status %d\n",
1243 status);
1244 break;
1245 }
1246 }
1247
1248 if (iscan->timer_on) {
1249 del_timer_sync(&iscan->timer);
1250 iscan->timer_on = 0;
1251 }
1252 return 0;
1253 }
1254 #endif /* WL_IW_USE_ISCAN */
1255
1256 static int
1257 wl_iw_set_scan(struct net_device *dev,
1258 struct iw_request_info *info,
1259 union iwreq_data *wrqu, char *extra)
1260 {
1261 int error;
1262 WL_TRACE("\n:%s dev:%s: SIOCSIWSCAN : SCAN\n", __func__, dev->name);
1263
1264 g_set_essid_before_scan = false;
1265 #if defined(CSCAN)
1266 WL_ERROR("%s: Scan from SIOCGIWSCAN not supported\n", __func__);
1267 return -EINVAL;
1268 #endif
1269
1270 if (g_onoff == G_WLAN_SET_OFF)
1271 return 0;
1272
1273 memset(&g_specific_ssid, 0, sizeof(g_specific_ssid));
1274 #ifndef WL_IW_USE_ISCAN
1275 g_scan_specified_ssid = 0;
1276 #endif
1277
1278 #if WIRELESS_EXT > 17
1279 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
1280 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
1281 struct iw_scan_req *req = (struct iw_scan_req *)extra;
1282 if (g_scan_specified_ssid) {
1283 WL_TRACE("%s Specific SCAN is not done ignore scan for = %s\n",
1284 __func__, req->essid);
1285 return -EBUSY;
1286 } else {
1287 g_specific_ssid.SSID_len = min_t(size_t,
1288 sizeof(g_specific_ssid.SSID),
1289 req->essid_len);
1290 memcpy(g_specific_ssid.SSID, req->essid,
1291 g_specific_ssid.SSID_len);
1292 g_specific_ssid.SSID_len =
1293 cpu_to_le32(g_specific_ssid.SSID_len);
1294 g_scan_specified_ssid = 1;
1295 WL_TRACE("### Specific scan ssid=%s len=%d\n",
1296 g_specific_ssid.SSID,
1297 g_specific_ssid.SSID_len);
1298 }
1299 }
1300 }
1301 #endif /* WIRELESS_EXT > 17 */
1302 error = dev_wlc_ioctl(dev, WLC_SCAN, &g_specific_ssid,
1303 sizeof(g_specific_ssid));
1304 if (error) {
1305 WL_TRACE("#### Set SCAN for %s failed with %d\n",
1306 g_specific_ssid.SSID, error);
1307 g_scan_specified_ssid = 0;
1308 return -EBUSY;
1309 }
1310
1311 return 0;
1312 }
1313
1314 #ifdef WL_IW_USE_ISCAN
1315 int wl_iw_iscan_set_scan_broadcast_prep(struct net_device *dev, uint flag)
1316 {
1317 wlc_ssid_t ssid;
1318 iscan_info_t *iscan = g_iscan;
1319
1320 if (flag)
1321 rtnl_lock();
1322
1323 wl_iw_set_event_mask(dev);
1324
1325 WL_TRACE("+++: Set Broadcast ISCAN\n");
1326 memset(&ssid, 0, sizeof(ssid));
1327
1328 iscan->list_cur = iscan->list_hdr;
1329 iscan->iscan_state = ISCAN_STATE_SCANING;
1330
1331 memset(&iscan->iscan_ex_params_p->params, 0,
1332 iscan->iscan_ex_param_size);
1333 wl_iw_iscan_prep(&iscan->iscan_ex_params_p->params, &ssid);
1334 wl_iw_iscan(iscan, &ssid, WL_SCAN_ACTION_START);
1335
1336 if (flag)
1337 rtnl_unlock();
1338
1339 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
1340
1341 iscan->timer_on = 1;
1342
1343 return 0;
1344 }
1345
1346 static int
1347 wl_iw_iscan_set_scan(struct net_device *dev,
1348 struct iw_request_info *info,
1349 union iwreq_data *wrqu, char *extra)
1350 {
1351 wlc_ssid_t ssid;
1352 iscan_info_t *iscan = g_iscan;
1353
1354 WL_TRACE("%s: SIOCSIWSCAN : ISCAN\n", dev->name);
1355
1356 #if defined(CSCAN)
1357 WL_ERROR("%s: Scan from SIOCGIWSCAN not supported\n", __func__);
1358 return -EINVAL;
1359 #endif
1360
1361 if (g_onoff == G_WLAN_SET_OFF) {
1362 WL_TRACE("%s: driver is not up yet after START\n", __func__);
1363 return 0;
1364 }
1365 #ifdef PNO_SUPPORT
1366 if (dhd_dev_get_pno_status(dev)) {
1367 WL_ERROR("%s: Scan called when PNO is active\n", __func__);
1368 }
1369 #endif
1370
1371 if ((!iscan) || (!iscan->sysioc_tsk))
1372 return wl_iw_set_scan(dev, info, wrqu, extra);
1373
1374 if (g_scan_specified_ssid) {
1375 WL_TRACE("%s Specific SCAN already running ignoring BC scan\n",
1376 __func__);
1377 return -EBUSY;
1378 }
1379
1380 memset(&ssid, 0, sizeof(ssid));
1381
1382 #if WIRELESS_EXT > 17
1383 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
1384 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
1385 struct iw_scan_req *req = (struct iw_scan_req *)extra;
1386 ssid.SSID_len = min_t(size_t, sizeof(ssid.SSID),
1387 req->essid_len);
1388 memcpy(ssid.SSID, req->essid, ssid.SSID_len);
1389 ssid.SSID_len = cpu_to_le32(ssid.SSID_len);
1390 } else {
1391 g_scan_specified_ssid = 0;
1392
1393 if (iscan->iscan_state == ISCAN_STATE_SCANING) {
1394 WL_TRACE("%s ISCAN already in progress\n",
1395 __func__);
1396 return 0;
1397 }
1398 }
1399 }
1400 #endif /* WIRELESS_EXT > 17 */
1401 wl_iw_iscan_set_scan_broadcast_prep(dev, 0);
1402
1403 return 0;
1404 }
1405 #endif /* WL_IW_USE_ISCAN */
1406
1407 #if WIRELESS_EXT > 17
1408 static bool ie_is_wpa_ie(u8 **wpaie, u8 **tlvs, int *tlvs_len)
1409 {
1410
1411 u8 *ie = *wpaie;
1412
1413 if ((ie[1] >= 6) &&
1414 !memcmp((const void *)&ie[2], (const void *)(WPA_OUI "\x01"), 4)) {
1415 return true;
1416 }
1417
1418 ie += ie[1] + 2;
1419 *tlvs_len -= (int)(ie - *tlvs);
1420 *tlvs = ie;
1421 return false;
1422 }
1423
1424 static bool ie_is_wps_ie(u8 **wpsie, u8 **tlvs, int *tlvs_len)
1425 {
1426
1427 u8 *ie = *wpsie;
1428
1429 if ((ie[1] >= 4) &&
1430 !memcmp((const void *)&ie[2], (const void *)(WPA_OUI "\x04"), 4)) {
1431 return true;
1432 }
1433
1434 ie += ie[1] + 2;
1435 *tlvs_len -= (int)(ie - *tlvs);
1436 *tlvs = ie;
1437 return false;
1438 }
1439 #endif /* WIRELESS_EXT > 17 */
1440
1441 static int
1442 wl_iw_handle_scanresults_ies(char **event_p, char *end,
1443 struct iw_request_info *info, wl_bss_info_t *bi)
1444 {
1445 #if WIRELESS_EXT > 17
1446 struct iw_event iwe;
1447 char *event;
1448
1449 event = *event_p;
1450 if (bi->ie_length) {
1451 struct brcmu_tlv *ie;
1452 u8 *ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
1453 int ptr_len = bi->ie_length;
1454
1455 ie = brcmu_parse_tlvs(ptr, ptr_len, DOT11_MNG_RSN_ID);
1456 if (ie) {
1457 iwe.cmd = IWEVGENIE;
1458 iwe.u.data.length = ie->len + 2;
1459 event =
1460 IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1461 (char *)ie);
1462 }
1463 ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
1464
1465 while ((ie = brcmu_parse_tlvs(
1466 ptr, ptr_len, DOT11_MNG_WPA_ID))) {
1467 if (ie_is_wps_ie(((u8 **)&ie), &ptr, &ptr_len)) {
1468 iwe.cmd = IWEVGENIE;
1469 iwe.u.data.length = ie->len + 2;
1470 event =
1471 IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1472 (char *)ie);
1473 break;
1474 }
1475 }
1476
1477 ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
1478 ptr_len = bi->ie_length;
1479 while ((ie = brcmu_parse_tlvs(
1480 ptr, ptr_len, DOT11_MNG_WPA_ID))) {
1481 if (ie_is_wpa_ie(((u8 **)&ie), &ptr, &ptr_len)) {
1482 iwe.cmd = IWEVGENIE;
1483 iwe.u.data.length = ie->len + 2;
1484 event =
1485 IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1486 (char *)ie);
1487 break;
1488 }
1489 }
1490
1491 *event_p = event;
1492 }
1493 #endif /* WIRELESS_EXT > 17 */
1494 return 0;
1495 }
1496
1497 static uint
1498 wl_iw_get_scan_prep(wl_scan_results_t *list,
1499 struct iw_request_info *info, char *extra, short max_size)
1500 {
1501 int i, j;
1502 struct iw_event iwe;
1503 wl_bss_info_t *bi = NULL;
1504 char *event = extra, *end = extra + max_size - WE_ADD_EVENT_FIX, *value;
1505 int ret = 0;
1506
1507 ASSERT(list);
1508
1509 for (i = 0; i < list->count && i < IW_MAX_AP; i++) {
1510 if (list->version != WL_BSS_INFO_VERSION) {
1511 WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
1512 __func__, list->version);
1513 return ret;
1514 }
1515
1516 bi = bi ? (wl_bss_info_t *)((unsigned long)bi +
1517 le32_to_cpu(bi->length)) : list->
1518 bss_info;
1519
1520 WL_TRACE("%s : %s\n", __func__, bi->SSID);
1521
1522 iwe.cmd = SIOCGIWAP;
1523 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1524 memcpy(iwe.u.ap_addr.sa_data, &bi->BSSID, ETH_ALEN);
1525 event =
1526 IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1527 IW_EV_ADDR_LEN);
1528 iwe.u.data.length = le32_to_cpu(bi->SSID_len);
1529 iwe.cmd = SIOCGIWESSID;
1530 iwe.u.data.flags = 1;
1531 event = IWE_STREAM_ADD_POINT(info, event, end, &iwe, bi->SSID);
1532
1533 if (le16_to_cpu(bi->capability) & (WLAN_CAPABILITY_ESS |
1534 WLAN_CAPABILITY_IBSS)) {
1535 iwe.cmd = SIOCGIWMODE;
1536 if (le16_to_cpu(bi->capability) & WLAN_CAPABILITY_ESS)
1537 iwe.u.mode = IW_MODE_INFRA;
1538 else
1539 iwe.u.mode = IW_MODE_ADHOC;
1540 event =
1541 IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1542 IW_EV_UINT_LEN);
1543 }
1544
1545 iwe.cmd = SIOCGIWFREQ;
1546
1547 if (CHSPEC_CHANNEL(bi->chanspec) <= CH_MAX_2G_CHANNEL)
1548 iwe.u.freq.m = ieee80211_dsss_chan_to_freq(
1549 CHSPEC_CHANNEL(bi->chanspec));
1550 else
1551 iwe.u.freq.m = ieee80211_ofdm_chan_to_freq(
1552 WF_CHAN_FACTOR_5_G/2,
1553 CHSPEC_CHANNEL(bi->chanspec));
1554
1555 iwe.u.freq.e = 6;
1556 event =
1557 IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1558 IW_EV_FREQ_LEN);
1559
1560 iwe.cmd = IWEVQUAL;
1561 iwe.u.qual.qual = rssi_to_qual(le16_to_cpu(bi->RSSI));
1562 iwe.u.qual.level = 0x100 + le16_to_cpu(bi->RSSI);
1563 iwe.u.qual.noise = 0x100 + bi->phy_noise;
1564 event =
1565 IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1566 IW_EV_QUAL_LEN);
1567
1568 wl_iw_handle_scanresults_ies(&event, end, info, bi);
1569
1570 iwe.cmd = SIOCGIWENCODE;
1571 if (le16_to_cpu(bi->capability) & WLAN_CAPABILITY_PRIVACY)
1572 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1573 else
1574 iwe.u.data.flags = IW_ENCODE_DISABLED;
1575 iwe.u.data.length = 0;
1576 event =
1577 IWE_STREAM_ADD_POINT(info, event, end, &iwe, (char *)event);
1578
1579 if (bi->rateset.count) {
1580 if (((event - extra) +
1581 IW_EV_LCP_LEN) <= (unsigned long)end) {
1582 value = event + IW_EV_LCP_LEN;
1583 iwe.cmd = SIOCGIWRATE;
1584 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled =
1585 0;
1586 for (j = 0;
1587 j < bi->rateset.count
1588 && j < IW_MAX_BITRATES; j++) {
1589 iwe.u.bitrate.value =
1590 (bi->rateset.rates[j] & 0x7f) *
1591 500000;
1592 value =
1593 IWE_STREAM_ADD_VALUE(info, event,
1594 value, end, &iwe,
1595 IW_EV_PARAM_LEN);
1596 }
1597 event = value;
1598 }
1599 }
1600 }
1601
1602 ret = event - extra;
1603 if (ret < 0) {
1604 WL_ERROR("==> Wrong size\n");
1605 ret = 0;
1606 }
1607 WL_TRACE("%s: size=%d bytes prepared\n",
1608 __func__, (unsigned int)(event - extra));
1609 return (uint)ret;
1610 }
1611
1612 static int
1613 wl_iw_get_scan(struct net_device *dev,
1614 struct iw_request_info *info, struct iw_point *dwrq, char *extra)
1615 {
1616 channel_info_t ci;
1617 wl_scan_results_t *list_merge;
1618 wl_scan_results_t *list = (wl_scan_results_t *) g_scan;
1619 int error;
1620 uint buflen_from_user = dwrq->length;
1621 uint len = G_SCAN_RESULTS;
1622 __u16 len_ret = 0;
1623 #if defined(WL_IW_USE_ISCAN)
1624 iscan_info_t *iscan = g_iscan;
1625 iscan_buf_t *p_buf;
1626 #endif
1627
1628 WL_TRACE("%s: buflen_from_user %d:\n", dev->name, buflen_from_user);
1629
1630 if (!extra) {
1631 WL_TRACE("%s: wl_iw_get_scan return -EINVAL\n", dev->name);
1632 return -EINVAL;
1633 }
1634
1635 error = dev_wlc_ioctl(dev, WLC_GET_CHANNEL, &ci, sizeof(ci));
1636 if (error)
1637 return error;
1638 ci.scan_channel = le32_to_cpu(ci.scan_channel);
1639 if (ci.scan_channel)
1640 return -EAGAIN;
1641
1642 if (g_scan_specified_ssid) {
1643 list = kmalloc(len, GFP_KERNEL);
1644 if (!list) {
1645 WL_TRACE("%s: wl_iw_get_scan return -ENOMEM\n",
1646 dev->name);
1647 g_scan_specified_ssid = 0;
1648 return -ENOMEM;
1649 }
1650 }
1651
1652 memset(list, 0, len);
1653 list->buflen = cpu_to_le32(len);
1654 error = dev_wlc_ioctl(dev, WLC_SCAN_RESULTS, list, len);
1655 if (error) {
1656 WL_ERROR("%s: %s : Scan_results ERROR %d\n",
1657 dev->name, __func__, error);
1658 dwrq->length = len;
1659 if (g_scan_specified_ssid) {
1660 g_scan_specified_ssid = 0;
1661 kfree(list);
1662 }
1663 return 0;
1664 }
1665 list->buflen = le32_to_cpu(list->buflen);
1666 list->version = le32_to_cpu(list->version);
1667 list->count = le32_to_cpu(list->count);
1668
1669 if (list->version != WL_BSS_INFO_VERSION) {
1670 WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
1671 __func__, list->version);
1672 if (g_scan_specified_ssid) {
1673 g_scan_specified_ssid = 0;
1674 kfree(list);
1675 }
1676 return -EINVAL;
1677 }
1678
1679 if (g_scan_specified_ssid) {
1680 WL_TRACE("%s: Specified scan APs in the list =%d\n",
1681 __func__, list->count);
1682 len_ret =
1683 (__u16) wl_iw_get_scan_prep(list, info, extra,
1684 buflen_from_user);
1685 kfree(list);
1686
1687 #if defined(WL_IW_USE_ISCAN)
1688 p_buf = iscan->list_hdr;
1689 while (p_buf != iscan->list_cur) {
1690 list_merge =
1691 &((wl_iscan_results_t *) p_buf->iscan_buf)->results;
1692 WL_TRACE("%s: Bcast APs list=%d\n",
1693 __func__, list_merge->count);
1694 if (list_merge->count > 0)
1695 len_ret +=
1696 (__u16) wl_iw_get_scan_prep(list_merge,
1697 info, extra + len_ret,
1698 buflen_from_user - len_ret);
1699 p_buf = p_buf->next;
1700 }
1701 #else
1702 list_merge = (wl_scan_results_t *) g_scan;
1703 WL_TRACE("%s: Bcast APs list=%d\n",
1704 __func__, list_merge->count);
1705 if (list_merge->count > 0)
1706 len_ret +=
1707 (__u16) wl_iw_get_scan_prep(list_merge, info,
1708 extra + len_ret,
1709 buflen_from_user -
1710 len_ret);
1711 #endif /* defined(WL_IW_USE_ISCAN) */
1712 } else {
1713 list = (wl_scan_results_t *) g_scan;
1714 len_ret =
1715 (__u16) wl_iw_get_scan_prep(list, info, extra,
1716 buflen_from_user);
1717 }
1718
1719 #if defined(WL_IW_USE_ISCAN)
1720 g_scan_specified_ssid = 0;
1721 #endif
1722 if ((len_ret + WE_ADD_EVENT_FIX) < buflen_from_user)
1723 len = len_ret;
1724
1725 dwrq->length = len;
1726 dwrq->flags = 0;
1727
1728 WL_TRACE("%s return to WE %d bytes APs=%d\n",
1729 __func__, dwrq->length, list->count);
1730 return 0;
1731 }
1732
1733 #if defined(WL_IW_USE_ISCAN)
1734 static int
1735 wl_iw_iscan_get_scan(struct net_device *dev,
1736 struct iw_request_info *info,
1737 struct iw_point *dwrq, char *extra)
1738 {
1739 wl_scan_results_t *list;
1740 struct iw_event iwe;
1741 wl_bss_info_t *bi = NULL;
1742 int ii, j;
1743 int apcnt;
1744 char *event = extra, *end = extra + dwrq->length, *value;
1745 iscan_info_t *iscan = g_iscan;
1746 iscan_buf_t *p_buf;
1747 u32 counter = 0;
1748 u8 channel;
1749
1750 WL_TRACE("%s %s buflen_from_user %d:\n",
1751 dev->name, __func__, dwrq->length);
1752
1753 if (!extra) {
1754 WL_TRACE("%s: INVALID SIOCGIWSCAN GET bad parameter\n",
1755 dev->name);
1756 return -EINVAL;
1757 }
1758
1759 if ((!iscan) || (!iscan->sysioc_tsk)) {
1760 WL_ERROR("%ssysioc_tsk\n", __func__);
1761 return wl_iw_get_scan(dev, info, dwrq, extra);
1762 }
1763
1764 if (iscan->iscan_state == ISCAN_STATE_SCANING) {
1765 WL_TRACE("%s: SIOCGIWSCAN GET still scanning\n", dev->name);
1766 return -EAGAIN;
1767 }
1768
1769 WL_TRACE("%s: SIOCGIWSCAN GET broadcast results\n", dev->name);
1770 apcnt = 0;
1771 p_buf = iscan->list_hdr;
1772 while (p_buf != iscan->list_cur) {
1773 list = &((wl_iscan_results_t *) p_buf->iscan_buf)->results;
1774
1775 counter += list->count;
1776
1777 if (list->version != WL_BSS_INFO_VERSION) {
1778 WL_ERROR("%s : list->version %d != WL_BSS_INFO_VERSION\n",
1779 __func__, list->version);
1780 return -EINVAL;
1781 }
1782
1783 bi = NULL;
1784 for (ii = 0; ii < list->count && apcnt < IW_MAX_AP;
1785 apcnt++, ii++) {
1786 bi = bi ? (wl_bss_info_t *)((unsigned long)bi +
1787 le32_to_cpu(bi->length)) :
1788 list->bss_info;
1789 ASSERT(((unsigned long)bi + le32_to_cpu(bi->length)) <=
1790 ((unsigned long)list + WLC_IW_ISCAN_MAXLEN));
1791
1792 if (event + ETH_ALEN + bi->SSID_len +
1793 IW_EV_UINT_LEN + IW_EV_FREQ_LEN + IW_EV_QUAL_LEN >=
1794 end)
1795 return -E2BIG;
1796 iwe.cmd = SIOCGIWAP;
1797 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1798 memcpy(iwe.u.ap_addr.sa_data, &bi->BSSID,
1799 ETH_ALEN);
1800 event =
1801 IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1802 IW_EV_ADDR_LEN);
1803
1804 iwe.u.data.length = le32_to_cpu(bi->SSID_len);
1805 iwe.cmd = SIOCGIWESSID;
1806 iwe.u.data.flags = 1;
1807 event =
1808 IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1809 bi->SSID);
1810
1811 if (le16_to_cpu(bi->capability) &
1812 (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)) {
1813 iwe.cmd = SIOCGIWMODE;
1814 if (le16_to_cpu(bi->capability) &
1815 WLAN_CAPABILITY_ESS)
1816 iwe.u.mode = IW_MODE_INFRA;
1817 else
1818 iwe.u.mode = IW_MODE_ADHOC;
1819 event =
1820 IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1821 IW_EV_UINT_LEN);
1822 }
1823
1824 iwe.cmd = SIOCGIWFREQ;
1825 channel =
1826 (bi->ctl_ch ==
1827 0) ? CHSPEC_CHANNEL(bi->chanspec) : bi->ctl_ch;
1828
1829 if (channel <= CH_MAX_2G_CHANNEL)
1830 iwe.u.freq.m =
1831 ieee80211_dsss_chan_to_freq(channel);
1832 else
1833 iwe.u.freq.m = ieee80211_ofdm_chan_to_freq(
1834 WF_CHAN_FACTOR_5_G/2,
1835 channel);
1836
1837 iwe.u.freq.e = 6;
1838 event =
1839 IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1840 IW_EV_FREQ_LEN);
1841
1842 iwe.cmd = IWEVQUAL;
1843 iwe.u.qual.qual = rssi_to_qual(le16_to_cpu(bi->RSSI));
1844 iwe.u.qual.level = 0x100 + le16_to_cpu(bi->RSSI);
1845 iwe.u.qual.noise = 0x100 + bi->phy_noise;
1846 event =
1847 IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1848 IW_EV_QUAL_LEN);
1849
1850 wl_iw_handle_scanresults_ies(&event, end, info, bi);
1851
1852 iwe.cmd = SIOCGIWENCODE;
1853 if (le16_to_cpu(bi->capability) &
1854 WLAN_CAPABILITY_PRIVACY)
1855 iwe.u.data.flags =
1856 IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1857 else
1858 iwe.u.data.flags = IW_ENCODE_DISABLED;
1859 iwe.u.data.length = 0;
1860 event =
1861 IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1862 (char *)event);
1863
1864 if (bi->rateset.count) {
1865 if (event + IW_MAX_BITRATES * IW_EV_PARAM_LEN >=
1866 end)
1867 return -E2BIG;
1868
1869 value = event + IW_EV_LCP_LEN;
1870 iwe.cmd = SIOCGIWRATE;
1871 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled =
1872 0;
1873 for (j = 0;
1874 j < bi->rateset.count
1875 && j < IW_MAX_BITRATES; j++) {
1876 iwe.u.bitrate.value =
1877 (bi->rateset.rates[j] & 0x7f) *
1878 500000;
1879 value =
1880 IWE_STREAM_ADD_VALUE(info, event,
1881 value, end,
1882 &iwe,
1883 IW_EV_PARAM_LEN);
1884 }
1885 event = value;
1886 }
1887 }
1888 p_buf = p_buf->next;
1889 }
1890
1891 dwrq->length = event - extra;
1892 dwrq->flags = 0;
1893
1894 WL_TRACE("%s return to WE %d bytes APs=%d\n",
1895 __func__, dwrq->length, counter);
1896
1897 if (!dwrq->length)
1898 return -EAGAIN;
1899
1900 return 0;
1901 }
1902 #endif /* defined(WL_IW_USE_ISCAN) */
1903
1904 static int
1905 wl_iw_set_essid(struct net_device *dev,
1906 struct iw_request_info *info,
1907 struct iw_point *dwrq, char *extra)
1908 {
1909 int error;
1910 wl_join_params_t join_params;
1911 int join_params_size;
1912
1913 WL_TRACE("%s: SIOCSIWESSID\n", dev->name);
1914
1915 if (g_set_essid_before_scan)
1916 return -EAGAIN;
1917
1918 memset(&g_ssid, 0, sizeof(g_ssid));
1919
1920 CHECK_EXTRA_FOR_NULL(extra);
1921
1922 if (dwrq->length && extra) {
1923 #if WIRELESS_EXT > 20
1924 g_ssid.SSID_len = min_t(size_t, sizeof(g_ssid.SSID),
1925 dwrq->length);
1926 #else
1927 g_ssid.SSID_len = min_t(size_t, sizeof(g_ssid.SSID),
1928 dwrq->length - 1);
1929 #endif
1930 memcpy(g_ssid.SSID, extra, g_ssid.SSID_len);
1931 } else {
1932 g_ssid.SSID_len = 0;
1933 }
1934 g_ssid.SSID_len = cpu_to_le32(g_ssid.SSID_len);
1935
1936 memset(&join_params, 0, sizeof(join_params));
1937 join_params_size = sizeof(join_params.ssid);
1938
1939 memcpy(&join_params.ssid.SSID, g_ssid.SSID, g_ssid.SSID_len);
1940 join_params.ssid.SSID_len = cpu_to_le32(g_ssid.SSID_len);
1941 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1942
1943 wl_iw_ch_to_chanspec(g_wl_iw_params.target_channel, &join_params,
1944 &join_params_size);
1945
1946 error = dev_wlc_ioctl(dev, WLC_SET_SSID, &join_params,
1947 join_params_size);
1948 if (error)
1949 WL_ERROR("Invalid ioctl data=%d\n", error);
1950
1951 if (g_ssid.SSID_len) {
1952 WL_TRACE("%s: join SSID=%s ch=%d\n",
1953 __func__, g_ssid.SSID, g_wl_iw_params.target_channel);
1954 }
1955 return 0;
1956 }
1957
1958 static int
1959 wl_iw_get_essid(struct net_device *dev,
1960 struct iw_request_info *info,
1961 struct iw_point *dwrq, char *extra)
1962 {
1963 wlc_ssid_t ssid;
1964 int error;
1965
1966 WL_TRACE("%s: SIOCGIWESSID\n", dev->name);
1967
1968 if (!extra)
1969 return -EINVAL;
1970
1971 error = dev_wlc_ioctl(dev, WLC_GET_SSID, &ssid, sizeof(ssid));
1972 if (error) {
1973 WL_ERROR("Error getting the SSID\n");
1974 return error;
1975 }
1976
1977 ssid.SSID_len = le32_to_cpu(ssid.SSID_len);
1978
1979 memcpy(extra, ssid.SSID, ssid.SSID_len);
1980
1981 dwrq->length = ssid.SSID_len;
1982
1983 dwrq->flags = 1;
1984
1985 return 0;
1986 }
1987
1988 static int
1989 wl_iw_set_nick(struct net_device *dev,
1990 struct iw_request_info *info, struct iw_point *dwrq, char *extra)
1991 {
1992 wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
1993
1994 WL_TRACE("%s: SIOCSIWNICKN\n", dev->name);
1995
1996 if (!extra)
1997 return -EINVAL;
1998
1999 if (dwrq->length > sizeof(iw->nickname))
2000 return -E2BIG;
2001
2002 memcpy(iw->nickname, extra, dwrq->length);
2003 iw->nickname[dwrq->length - 1] = '\0';
2004
2005 return 0;
2006 }
2007
2008 static int
2009 wl_iw_get_nick(struct net_device *dev,
2010 struct iw_request_info *info, struct iw_point *dwrq, char *extra)
2011 {
2012 wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
2013
2014 WL_TRACE("%s: SIOCGIWNICKN\n", dev->name);
2015
2016 if (!extra)
2017 return -EINVAL;
2018
2019 strcpy(extra, iw->nickname);
2020 dwrq->length = strlen(extra) + 1;
2021
2022 return 0;
2023 }
2024
2025 static int
2026 wl_iw_set_rate(struct net_device *dev,
2027 struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2028 {
2029 wl_rateset_t rateset;
2030 int error, rate, i, error_bg, error_a;
2031
2032 WL_TRACE("%s: SIOCSIWRATE\n", dev->name);
2033
2034 error = dev_wlc_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
2035 sizeof(rateset));
2036 if (error)
2037 return error;
2038
2039 rateset.count = le32_to_cpu(rateset.count);
2040
2041 if (vwrq->value < 0)
2042 rate = rateset.rates[rateset.count - 1] & 0x7f;
2043 else if (vwrq->value < rateset.count)
2044 rate = rateset.rates[vwrq->value] & 0x7f;
2045 else
2046 rate = vwrq->value / 500000;
2047
2048 if (vwrq->fixed) {
2049 error_bg = dev_wlc_intvar_set(dev, "bg_rate", rate);
2050 error_a = dev_wlc_intvar_set(dev, "a_rate", rate);
2051
2052 if (error_bg && error_a)
2053 return error_bg | error_a;
2054 } else {
2055 error_bg = dev_wlc_intvar_set(dev, "bg_rate", 0);
2056 error_a = dev_wlc_intvar_set(dev, "a_rate", 0);
2057
2058 if (error_bg && error_a)
2059 return error_bg | error_a;
2060
2061 for (i = 0; i < rateset.count; i++)
2062 if ((rateset.rates[i] & 0x7f) > rate)
2063 break;
2064 rateset.count = cpu_to_le32(i);
2065
2066 error = dev_wlc_ioctl(dev, WLC_SET_RATESET, &rateset,
2067 sizeof(rateset));
2068 if (error)
2069 return error;
2070 }
2071
2072 return 0;
2073 }
2074
2075 static int
2076 wl_iw_get_rate(struct net_device *dev,
2077 struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2078 {
2079 int error, rate;
2080
2081 WL_TRACE("%s: SIOCGIWRATE\n", dev->name);
2082
2083 error = dev_wlc_ioctl(dev, WLC_GET_RATE, &rate, sizeof(rate));
2084 if (error)
2085 return error;
2086 rate = le32_to_cpu(rate);
2087 vwrq->value = rate * 500000;
2088
2089 return 0;
2090 }
2091
2092 static int
2093 wl_iw_set_rts(struct net_device *dev,
2094 struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2095 {
2096 int error, rts;
2097
2098 WL_TRACE("%s: SIOCSIWRTS\n", dev->name);
2099
2100 if (vwrq->disabled)
2101 rts = DOT11_DEFAULT_RTS_LEN;
2102 else if (vwrq->value < 0 || vwrq->value > DOT11_DEFAULT_RTS_LEN)
2103 return -EINVAL;
2104 else
2105 rts = vwrq->value;
2106
2107 error = dev_wlc_intvar_set(dev, "rtsthresh", rts);
2108 if (error)
2109 return error;
2110
2111 return 0;
2112 }
2113
2114 static int
2115 wl_iw_get_rts(struct net_device *dev,
2116 struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2117 {
2118 int error, rts;
2119
2120 WL_TRACE("%s: SIOCGIWRTS\n", dev->name);
2121
2122 error = dev_wlc_intvar_get(dev, "rtsthresh", &rts);
2123 if (error)
2124 return error;
2125
2126 vwrq->value = rts;
2127 vwrq->disabled = (rts >= DOT11_DEFAULT_RTS_LEN);
2128 vwrq->fixed = 1;
2129
2130 return 0;
2131 }
2132
2133 static int
2134 wl_iw_set_frag(struct net_device *dev,
2135 struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2136 {
2137 int error, frag;
2138
2139 WL_TRACE("%s: SIOCSIWFRAG\n", dev->name);
2140
2141 if (vwrq->disabled)
2142 frag = DOT11_DEFAULT_FRAG_LEN;
2143 else if (vwrq->value < 0 || vwrq->value > DOT11_DEFAULT_FRAG_LEN)
2144 return -EINVAL;
2145 else
2146 frag = vwrq->value;
2147
2148 error = dev_wlc_intvar_set(dev, "fragthresh", frag);
2149 if (error)
2150 return error;
2151
2152 return 0;
2153 }
2154
2155 static int
2156 wl_iw_get_frag(struct net_device *dev,
2157 struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2158 {
2159 int error, fragthreshold;
2160
2161 WL_TRACE("%s: SIOCGIWFRAG\n", dev->name);
2162
2163 error = dev_wlc_intvar_get(dev, "fragthresh", &fragthreshold);
2164 if (error)
2165 return error;
2166
2167 vwrq->value = fragthreshold;
2168 vwrq->disabled = (fragthreshold >= DOT11_DEFAULT_FRAG_LEN);
2169 vwrq->fixed = 1;
2170
2171 return 0;
2172 }
2173
2174 static int
2175 wl_iw_set_txpow(struct net_device *dev,
2176 struct iw_request_info *info,
2177 struct iw_param *vwrq, char *extra)
2178 {
2179 int error, disable;
2180 u16 txpwrmw;
2181 WL_TRACE("%s: SIOCSIWTXPOW\n", dev->name);
2182
2183 disable = vwrq->disabled ? WL_RADIO_SW_DISABLE : 0;
2184 disable += WL_RADIO_SW_DISABLE << 16;
2185
2186 disable = cpu_to_le32(disable);
2187 error = dev_wlc_ioctl(dev, WLC_SET_RADIO, &disable, sizeof(disable));
2188 if (error)
2189 return error;
2190
2191 if (disable & WL_RADIO_SW_DISABLE)
2192 return 0;
2193
2194 if (!(vwrq->flags & IW_TXPOW_MWATT))
2195 return -EINVAL;
2196
2197 if (vwrq->value < 0)
2198 return 0;
2199
2200 if (vwrq->value > 0xffff)
2201 txpwrmw = 0xffff;
2202 else
2203 txpwrmw = (u16) vwrq->value;
2204
2205 error = dev_wlc_intvar_set(dev, "qtxpower",
2206 (int)(brcmu_mw_to_qdbm(txpwrmw)));
2207 return error;
2208 }
2209
2210 static int
2211 wl_iw_get_txpow(struct net_device *dev,
2212 struct iw_request_info *info,
2213 struct iw_param *vwrq, char *extra)
2214 {
2215 int error, disable, txpwrdbm;
2216 u8 result;
2217
2218 WL_TRACE("%s: SIOCGIWTXPOW\n", dev->name);
2219
2220 error = dev_wlc_ioctl(dev, WLC_GET_RADIO, &disable, sizeof(disable));
2221 if (error)
2222 return error;
2223
2224 error = dev_wlc_intvar_get(dev, "qtxpower", &txpwrdbm);
2225 if (error)
2226 return error;
2227
2228 disable = le32_to_cpu(disable);
2229 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
2230 vwrq->value = (s32) brcmu_qdbm_to_mw(result);
2231 vwrq->fixed = 0;
2232 vwrq->disabled =
2233 (disable & (WL_RADIO_SW_DISABLE | WL_RADIO_HW_DISABLE)) ? 1 : 0;
2234 vwrq->flags = IW_TXPOW_MWATT;
2235
2236 return 0;
2237 }
2238
2239 #if WIRELESS_EXT > 10
2240 static int
2241 wl_iw_set_retry(struct net_device *dev,
2242 struct iw_request_info *info,
2243 struct iw_param *vwrq, char *extra)
2244 {
2245 int error, lrl, srl;
2246
2247 WL_TRACE("%s: SIOCSIWRETRY\n", dev->name);
2248
2249 if (vwrq->disabled || (vwrq->flags & IW_RETRY_LIFETIME))
2250 return -EINVAL;
2251
2252 if (vwrq->flags & IW_RETRY_LIMIT) {
2253
2254 #if WIRELESS_EXT > 20
2255 if ((vwrq->flags & IW_RETRY_LONG)
2256 || (vwrq->flags & IW_RETRY_MAX)
2257 || !((vwrq->flags & IW_RETRY_SHORT)
2258 || (vwrq->flags & IW_RETRY_MIN))) {
2259 #else
2260 if ((vwrq->flags & IW_RETRY_MAX)
2261 || !(vwrq->flags & IW_RETRY_MIN)) {
2262 #endif
2263 lrl = cpu_to_le32(vwrq->value);
2264 error = dev_wlc_ioctl(dev, WLC_SET_LRL, &lrl,
2265 sizeof(lrl));
2266 if (error)
2267 return error;
2268 }
2269 #if WIRELESS_EXT > 20
2270 if ((vwrq->flags & IW_RETRY_SHORT)
2271 || (vwrq->flags & IW_RETRY_MIN)
2272 || !((vwrq->flags & IW_RETRY_LONG)
2273 || (vwrq->flags & IW_RETRY_MAX))) {
2274 #else
2275 if ((vwrq->flags & IW_RETRY_MIN)
2276 || !(vwrq->flags & IW_RETRY_MAX)) {
2277 #endif
2278 srl = cpu_to_le32(vwrq->value);
2279 error = dev_wlc_ioctl(dev, WLC_SET_SRL, &srl,
2280 sizeof(srl));
2281 if (error)
2282 return error;
2283 }
2284 }
2285 return 0;
2286 }
2287
2288 static int
2289 wl_iw_get_retry(struct net_device *dev,
2290 struct iw_request_info *info,
2291 struct iw_param *vwrq, char *extra)
2292 {
2293 int error, lrl, srl;
2294
2295 WL_TRACE("%s: SIOCGIWRETRY\n", dev->name);
2296
2297 vwrq->disabled = 0;
2298
2299 if ((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME)
2300 return -EINVAL;
2301
2302 error = dev_wlc_ioctl(dev, WLC_GET_LRL, &lrl, sizeof(lrl));
2303 if (error)
2304 return error;
2305
2306 error = dev_wlc_ioctl(dev, WLC_GET_SRL, &srl, sizeof(srl));
2307 if (error)
2308 return error;
2309
2310 lrl = le32_to_cpu(lrl);
2311 srl = le32_to_cpu(srl);
2312
2313 if (vwrq->flags & IW_RETRY_MAX) {
2314 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
2315 vwrq->value = lrl;
2316 } else {
2317 vwrq->flags = IW_RETRY_LIMIT;
2318 vwrq->value = srl;
2319 if (srl != lrl)
2320 vwrq->flags |= IW_RETRY_MIN;
2321 }
2322
2323 return 0;
2324 }
2325 #endif /* WIRELESS_EXT > 10 */
2326
2327 static int
2328 wl_iw_set_encode(struct net_device *dev,
2329 struct iw_request_info *info,
2330 struct iw_point *dwrq, char *extra)
2331 {
2332 wl_wsec_key_t key;
2333 int error, val, wsec;
2334
2335 WL_TRACE("%s: SIOCSIWENCODE\n", dev->name);
2336
2337 memset(&key, 0, sizeof(key));
2338
2339 if ((dwrq->flags & IW_ENCODE_INDEX) == 0) {
2340 for (key.index = 0; key.index < DOT11_MAX_DEFAULT_KEYS;
2341 key.index++) {
2342 val = cpu_to_le32(key.index);
2343 error = dev_wlc_ioctl(dev, WLC_GET_KEY_PRIMARY, &val,
2344 sizeof(val));
2345 if (error)
2346 return error;
2347 val = le32_to_cpu(val);
2348 if (val)
2349 break;
2350 }
2351 if (key.index == DOT11_MAX_DEFAULT_KEYS)
2352 key.index = 0;
2353 } else {
2354 key.index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
2355 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
2356 return -EINVAL;
2357 }
2358
2359 if (!extra || !dwrq->length || (dwrq->flags & IW_ENCODE_NOKEY)) {
2360 val = cpu_to_le32(key.index);
2361 error = dev_wlc_ioctl(dev, WLC_SET_KEY_PRIMARY, &val,
2362 sizeof(val));
2363 if (error)
2364 return error;
2365 } else {
2366 key.len = dwrq->length;
2367
2368 if (dwrq->length > sizeof(key.data))
2369 return -EINVAL;
2370
2371 memcpy(key.data, extra, dwrq->length);
2372
2373 key.flags = WL_PRIMARY_KEY;
2374 switch (key.len) {
2375 case WLAN_KEY_LEN_WEP40:
2376 key.algo = CRYPTO_ALGO_WEP1;
2377 break;
2378 case WLAN_KEY_LEN_WEP104:
2379 key.algo = CRYPTO_ALGO_WEP128;
2380 break;
2381 case WLAN_KEY_LEN_TKIP:
2382 key.algo = CRYPTO_ALGO_TKIP;
2383 break;
2384 case WLAN_KEY_LEN_AES_CMAC:
2385 key.algo = CRYPTO_ALGO_AES_CCM;
2386 break;
2387 default:
2388 return -EINVAL;
2389 }
2390
2391 swap_key_from_BE(&key);
2392 error = dev_wlc_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
2393 if (error)
2394 return error;
2395 }
2396
2397 val = (dwrq->flags & IW_ENCODE_DISABLED) ? 0 : WEP_ENABLED;
2398
2399 error = dev_wlc_intvar_get(dev, "wsec", &wsec);
2400 if (error)
2401 return error;
2402
2403 wsec &= ~(WEP_ENABLED);
2404 wsec |= val;
2405
2406 error = dev_wlc_intvar_set(dev, "wsec", wsec);
2407 if (error)
2408 return error;
2409
2410 val = (dwrq->flags & IW_ENCODE_RESTRICTED) ? 1 : 0;
2411 val = cpu_to_le32(val);
2412 error = dev_wlc_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
2413 if (error)
2414 return error;
2415
2416 return 0;
2417 }
2418
2419 static int
2420 wl_iw_get_encode(struct net_device *dev,
2421 struct iw_request_info *info,
2422 struct iw_point *dwrq, char *extra)
2423 {
2424 wl_wsec_key_t key;
2425 int error, val, wsec, auth;
2426
2427 WL_TRACE("%s: SIOCGIWENCODE\n", dev->name);
2428
2429 memset(&key, 0, sizeof(wl_wsec_key_t));
2430
2431 if ((dwrq->flags & IW_ENCODE_INDEX) == 0) {
2432 for (key.index = 0; key.index < DOT11_MAX_DEFAULT_KEYS;
2433 key.index++) {
2434 val = key.index;
2435 error = dev_wlc_ioctl(dev, WLC_GET_KEY_PRIMARY, &val,
2436 sizeof(val));
2437 if (error)
2438 return error;
2439 val = le32_to_cpu(val);
2440 if (val)
2441 break;
2442 }
2443 } else
2444 key.index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
2445
2446 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
2447 key.index = 0;
2448
2449 error = dev_wlc_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
2450 if (error)
2451 return error;
2452
2453 error = dev_wlc_ioctl(dev, WLC_GET_AUTH, &auth, sizeof(auth));
2454 if (error)
2455 return error;
2456
2457 swap_key_to_BE(&key);
2458
2459 wsec = le32_to_cpu(wsec);
2460 auth = le32_to_cpu(auth);
2461 dwrq->length = min_t(u16, WLAN_MAX_KEY_LEN, key.len);
2462
2463 dwrq->flags = key.index + 1;
2464 if (!(wsec & (WEP_ENABLED | TKIP_ENABLED | AES_ENABLED)))
2465 dwrq->flags |= IW_ENCODE_DISABLED;
2466
2467 if (auth)
2468 dwrq->flags |= IW_ENCODE_RESTRICTED;
2469
2470 if (dwrq->length && extra)
2471 memcpy(extra, key.data, dwrq->length);
2472
2473 return 0;
2474 }
2475
2476 static int
2477 wl_iw_set_power(struct net_device *dev,
2478 struct iw_request_info *info,
2479 struct iw_param *vwrq, char *extra)
2480 {
2481 int error, pm;
2482
2483 WL_TRACE("%s: SIOCSIWPOWER\n", dev->name);
2484
2485 pm = vwrq->disabled ? PM_OFF : PM_MAX;
2486
2487 pm = cpu_to_le32(pm);
2488 error = dev_wlc_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm));
2489 if (error)
2490 return error;
2491
2492 return 0;
2493 }
2494
2495 static int
2496 wl_iw_get_power(struct net_device *dev,
2497 struct iw_request_info *info,
2498 struct iw_param *vwrq, char *extra)
2499 {
2500 int error, pm;
2501
2502 WL_TRACE("%s: SIOCGIWPOWER\n", dev->name);
2503
2504 error = dev_wlc_ioctl(dev, WLC_GET_PM, &pm, sizeof(pm));
2505 if (error)
2506 return error;
2507
2508 pm = le32_to_cpu(pm);
2509 vwrq->disabled = pm ? 0 : 1;
2510 vwrq->flags = IW_POWER_ALL_R;
2511
2512 return 0;
2513 }
2514
2515 #if WIRELESS_EXT > 17
2516 static int
2517 wl_iw_set_wpaie(struct net_device *dev,
2518 struct iw_request_info *info, struct iw_point *iwp, char *extra)
2519 {
2520
2521 WL_TRACE("%s: SIOCSIWGENIE\n", dev->name);
2522
2523 CHECK_EXTRA_FOR_NULL(extra);
2524
2525 dev_wlc_bufvar_set(dev, "wpaie", extra, iwp->length);
2526
2527 return 0;
2528 }
2529
2530 static int
2531 wl_iw_get_wpaie(struct net_device *dev,
2532 struct iw_request_info *info, struct iw_point *iwp, char *extra)
2533 {
2534 WL_TRACE("%s: SIOCGIWGENIE\n", dev->name);
2535 iwp->length = 64;
2536 dev_wlc_bufvar_get(dev, "wpaie", extra, iwp->length);
2537 return 0;
2538 }
2539
2540 static int
2541 wl_iw_set_encodeext(struct net_device *dev,
2542 struct iw_request_info *info,
2543 struct iw_point *dwrq, char *extra)
2544 {
2545 wl_wsec_key_t key;
2546 int error;
2547 struct iw_encode_ext *iwe;
2548
2549 WL_TRACE("%s: SIOCSIWENCODEEXT\n", dev->name);
2550
2551 CHECK_EXTRA_FOR_NULL(extra);
2552
2553 memset(&key, 0, sizeof(key));
2554 iwe = (struct iw_encode_ext *)extra;
2555
2556 if (dwrq->flags & IW_ENCODE_DISABLED) {
2557
2558 }
2559
2560 key.index = 0;
2561 if (dwrq->flags & IW_ENCODE_INDEX)
2562 key.index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
2563
2564 key.len = iwe->key_len;
2565
2566 if (!is_multicast_ether_addr(iwe->addr.sa_data))
2567 memcpy(&key.ea, &iwe->addr.sa_data, ETH_ALEN);
2568
2569 if (key.len == 0) {
2570 if (iwe->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
2571 WL_WSEC("Changing the the primary Key to %d\n",
2572 key.index);
2573 key.index = cpu_to_le32(key.index);
2574 error = dev_wlc_ioctl(dev, WLC_SET_KEY_PRIMARY,
2575 &key.index, sizeof(key.index));
2576 if (error)
2577 return error;
2578 } else {
2579 swap_key_from_BE(&key);
2580 dev_wlc_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
2581 }
2582 } else {
2583 if (iwe->key_len > sizeof(key.data))
2584 return -EINVAL;
2585
2586 WL_WSEC("Setting the key index %d\n", key.index);
2587 if (iwe->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
2588 WL_WSEC("key is a Primary Key\n");
2589 key.flags = WL_PRIMARY_KEY;
2590 }
2591
2592 memcpy(key.data, iwe->key, iwe->key_len);
2593
2594 if (iwe->alg == IW_ENCODE_ALG_TKIP) {
2595 u8 keybuf[8];
2596 memcpy(keybuf, &key.data[24], sizeof(keybuf));
2597 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
2598 memcpy(&key.data[16], keybuf, sizeof(keybuf));
2599 }
2600
2601 if (iwe->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
2602 unsigned char *ivptr;
2603 ivptr = (unsigned char *) iwe->rx_seq;
2604 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
2605 (ivptr[3] << 8) | ivptr[2];
2606 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
2607 key.iv_initialized = true;
2608 }
2609
2610 switch (iwe->alg) {
2611 case IW_ENCODE_ALG_NONE:
2612 key.algo = CRYPTO_ALGO_OFF;
2613 break;
2614 case IW_ENCODE_ALG_WEP:
2615 if (iwe->key_len == WLAN_KEY_LEN_WEP40)
2616 key.algo = CRYPTO_ALGO_WEP1;
2617 else
2618 key.algo = CRYPTO_ALGO_WEP128;
2619 break;
2620 case IW_ENCODE_ALG_TKIP:
2621 key.algo = CRYPTO_ALGO_TKIP;
2622 break;
2623 case IW_ENCODE_ALG_CCMP:
2624 key.algo = CRYPTO_ALGO_AES_CCM;
2625 break;
2626 default:
2627 break;
2628 }
2629 swap_key_from_BE(&key);
2630
2631 dhd_wait_pend8021x(dev);
2632
2633 error = dev_wlc_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
2634 if (error)
2635 return error;
2636 }
2637 return 0;
2638 }
2639
2640 #if WIRELESS_EXT > 17
2641 struct {
2642 pmkid_list_t pmkids;
2643 pmkid_t foo[MAXPMKID - 1];
2644 } pmkid_list;
2645
2646 static int
2647 wl_iw_set_pmksa(struct net_device *dev,
2648 struct iw_request_info *info,
2649 struct iw_param *vwrq, char *extra)
2650 {
2651 struct iw_pmksa *iwpmksa;
2652 uint i;
2653 int ret = 0;
2654
2655 WL_WSEC("%s: SIOCSIWPMKSA\n", dev->name);
2656
2657 CHECK_EXTRA_FOR_NULL(extra);
2658
2659 iwpmksa = (struct iw_pmksa *)extra;
2660
2661 if (iwpmksa->cmd == IW_PMKSA_FLUSH) {
2662 WL_WSEC("wl_iw_set_pmksa - IW_PMKSA_FLUSH\n");
2663 memset((char *)&pmkid_list, 0, sizeof(pmkid_list));
2664 }
2665
2666 else if (iwpmksa->cmd == IW_PMKSA_REMOVE) {
2667 {
2668 pmkid_list_t pmkid, *pmkidptr;
2669 uint j;
2670 pmkidptr = &pmkid;
2671
2672 memcpy(&pmkidptr->pmkid[0].BSSID,
2673 &iwpmksa->bssid.sa_data[0],
2674 ETH_ALEN);
2675 memcpy(&pmkidptr->pmkid[0].PMKID,
2676 &iwpmksa->pmkid[0],
2677 WLAN_PMKID_LEN);
2678
2679 WL_WSEC("wl_iw_set_pmksa:IW_PMKSA_REMOVE:PMKID: "
2680 "%pM = ", &pmkidptr->pmkid[0].BSSID);
2681 for (j = 0; j < WLAN_PMKID_LEN; j++)
2682 WL_WSEC("%02x ", pmkidptr->pmkid[0].PMKID[j]);
2683 WL_WSEC("\n");
2684 }
2685
2686 for (i = 0; i < pmkid_list.pmkids.npmkid; i++)
2687 if (!memcmp
2688 (&iwpmksa->bssid.sa_data[0],
2689 &pmkid_list.pmkids.pmkid[i].BSSID, ETH_ALEN))
2690 break;
2691
2692 if ((pmkid_list.pmkids.npmkid > 0)
2693 && (i < pmkid_list.pmkids.npmkid)) {
2694 memset(&pmkid_list.pmkids.pmkid[i], 0, sizeof(pmkid_t));
2695 for (; i < (pmkid_list.pmkids.npmkid - 1); i++) {
2696 memcpy(&pmkid_list.pmkids.pmkid[i].BSSID,
2697 &pmkid_list.pmkids.pmkid[i + 1].BSSID,
2698 ETH_ALEN);
2699 memcpy(&pmkid_list.pmkids.pmkid[i].PMKID,
2700 &pmkid_list.pmkids.pmkid[i + 1].PMKID,
2701 WLAN_PMKID_LEN);
2702 }
2703 pmkid_list.pmkids.npmkid--;
2704 } else
2705 ret = -EINVAL;
2706 }
2707
2708 else if (iwpmksa->cmd == IW_PMKSA_ADD) {
2709 for (i = 0; i < pmkid_list.pmkids.npmkid; i++)
2710 if (!memcmp
2711 (&iwpmksa->bssid.sa_data[0],
2712 &pmkid_list.pmkids.pmkid[i].BSSID, ETH_ALEN))
2713 break;
2714 if (i < MAXPMKID) {
2715 memcpy(&pmkid_list.pmkids.pmkid[i].BSSID,
2716 &iwpmksa->bssid.sa_data[0],
2717 ETH_ALEN);
2718 memcpy(&pmkid_list.pmkids.pmkid[i].PMKID,
2719 &iwpmksa->pmkid[0],
2720 WLAN_PMKID_LEN);
2721 if (i == pmkid_list.pmkids.npmkid)
2722 pmkid_list.pmkids.npmkid++;
2723 } else
2724 ret = -EINVAL;
2725 {
2726 uint j;
2727 uint k;
2728 k = pmkid_list.pmkids.npmkid;
2729 WL_WSEC("wl_iw_set_pmksa,IW_PMKSA_ADD - PMKID: %pM = ",
2730 &pmkid_list.pmkids.pmkid[k].BSSID);
2731 for (j = 0; j < WLAN_PMKID_LEN; j++)
2732 WL_WSEC("%02x ",
2733 pmkid_list.pmkids.pmkid[k].PMKID[j]);
2734 WL_WSEC("\n");
2735 }
2736 }
2737 WL_WSEC("PRINTING pmkid LIST - No of elements %d\n",
2738 pmkid_list.pmkids.npmkid);
2739 for (i = 0; i < pmkid_list.pmkids.npmkid; i++) {
2740 uint j;
2741 WL_WSEC("PMKID[%d]: %pM = ",
2742 i, &pmkid_list.pmkids.pmkid[i].BSSID);
2743 for (j = 0; j < WLAN_PMKID_LEN; j++)
2744 WL_WSEC("%02x ", pmkid_list.pmkids.pmkid[i].PMKID[j]);
2745 WL_WSEC("\n");
2746 }
2747 WL_WSEC("\n");
2748
2749 if (!ret)
2750 ret = dev_wlc_bufvar_set(dev, "pmkid_info", (char *)&pmkid_list,
2751 sizeof(pmkid_list));
2752 return ret;
2753 }
2754 #endif /* WIRELESS_EXT > 17 */
2755
2756 static int
2757 wl_iw_get_encodeext(struct net_device *dev,
2758 struct iw_request_info *info,
2759 struct iw_param *vwrq, char *extra)
2760 {
2761 WL_TRACE("%s: SIOCGIWENCODEEXT\n", dev->name);
2762 return 0;
2763 }
2764
2765 static int
2766 wl_iw_set_wpaauth(struct net_device *dev,
2767 struct iw_request_info *info,
2768 struct iw_param *vwrq, char *extra)
2769 {
2770 int error = 0;
2771 int paramid;
2772 int paramval;
2773 int val = 0;
2774 wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
2775
2776 WL_TRACE("%s: SIOCSIWAUTH\n", dev->name);
2777
2778 paramid = vwrq->flags & IW_AUTH_INDEX;
2779 paramval = vwrq->value;
2780
2781 WL_TRACE("%s: SIOCSIWAUTH, paramid = 0x%0x, paramval = 0x%0x\n",
2782 dev->name, paramid, paramval);
2783
2784 switch (paramid) {
2785 case IW_AUTH_WPA_VERSION:
2786 if (paramval & IW_AUTH_WPA_VERSION_DISABLED)
2787 val = WPA_AUTH_DISABLED;
2788 else if (paramval & (IW_AUTH_WPA_VERSION_WPA))
2789 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
2790 else if (paramval & IW_AUTH_WPA_VERSION_WPA2)
2791 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
2792 WL_INFORM("%s: %d: setting wpa_auth to 0x%0x\n",
2793 __func__, __LINE__, val);
2794 error = dev_wlc_intvar_set(dev, "wpa_auth", val);
2795 if (error)
2796 return error;
2797 break;
2798 case IW_AUTH_CIPHER_PAIRWISE:
2799 case IW_AUTH_CIPHER_GROUP:
2800 if (paramval & (IW_AUTH_CIPHER_WEP40 | IW_AUTH_CIPHER_WEP104))
2801 val = WEP_ENABLED;
2802 if (paramval & IW_AUTH_CIPHER_TKIP)
2803 val = TKIP_ENABLED;
2804 if (paramval & IW_AUTH_CIPHER_CCMP)
2805 val = AES_ENABLED;
2806
2807 if (paramid == IW_AUTH_CIPHER_PAIRWISE) {
2808 iw->pwsec = val;
2809 val |= iw->gwsec;
2810 } else {
2811 iw->gwsec = val;
2812 val |= iw->pwsec;
2813 }
2814
2815 if (iw->privacy_invoked && !val) {
2816 WL_WSEC("%s: %s: 'Privacy invoked' true but clearing wsec, assuming we're a WPS enrollee\n",
2817 dev->name, __func__);
2818 error = dev_wlc_intvar_set(dev, "is_WPS_enrollee",
2819 true);
2820 if (error) {
2821 WL_WSEC("Failed to set is_WPS_enrollee\n");
2822 return error;
2823 }
2824 } else if (val) {
2825 error = dev_wlc_intvar_set(dev, "is_WPS_enrollee",
2826 false);
2827 if (error) {
2828 WL_WSEC("Failed to clear is_WPS_enrollee\n");
2829 return error;
2830 }
2831 }
2832
2833 error = dev_wlc_intvar_set(dev, "wsec", val);
2834 if (error)
2835 return error;
2836
2837 break;
2838
2839 case IW_AUTH_KEY_MGMT:
2840 error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
2841 if (error)
2842 return error;
2843
2844 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
2845 if (paramval & IW_AUTH_KEY_MGMT_PSK)
2846 val = WPA_AUTH_PSK;
2847 else
2848 val = WPA_AUTH_UNSPECIFIED;
2849 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
2850 if (paramval & IW_AUTH_KEY_MGMT_PSK)
2851 val = WPA2_AUTH_PSK;
2852 else
2853 val = WPA2_AUTH_UNSPECIFIED;
2854 }
2855 WL_INFORM("%s: %d: setting wpa_auth to %d\n",
2856 __func__, __LINE__, val);
2857 error = dev_wlc_intvar_set(dev, "wpa_auth", val);
2858 if (error)
2859 return error;
2860
2861 break;
2862 case IW_AUTH_TKIP_COUNTERMEASURES:
2863 dev_wlc_bufvar_set(dev, "tkip_countermeasures",
2864 (char *)&paramval, 1);
2865 break;
2866
2867 case IW_AUTH_80211_AUTH_ALG:
2868 WL_INFORM("Setting the D11auth %d\n", paramval);
2869 if (paramval == IW_AUTH_ALG_OPEN_SYSTEM)
2870 val = 0;
2871 else if (paramval == IW_AUTH_ALG_SHARED_KEY)
2872 val = 1;
2873 else if (paramval ==
2874 (IW_AUTH_ALG_OPEN_SYSTEM | IW_AUTH_ALG_SHARED_KEY))
2875 val = 2;
2876 else
2877 error = 1;
2878 if (!error) {
2879 error = dev_wlc_intvar_set(dev, "auth", val);
2880 if (error)
2881 return error;
2882 }
2883 break;
2884
2885 case IW_AUTH_WPA_ENABLED:
2886 if (paramval == 0) {
2887 iw->pwsec = 0;
2888 iw->gwsec = 0;
2889 error = dev_wlc_intvar_get(dev, "wsec", &val);
2890 if (error)
2891 return error;
2892 if (val & (TKIP_ENABLED | AES_ENABLED)) {
2893 val &= ~(TKIP_ENABLED | AES_ENABLED);
2894 dev_wlc_intvar_set(dev, "wsec", val);
2895 }
2896 val = 0;
2897 WL_INFORM("%s: %d: setting wpa_auth to %d\n",
2898 __func__, __LINE__, val);
2899 dev_wlc_intvar_set(dev, "wpa_auth", 0);
2900 return error;
2901 }
2902 break;
2903
2904 case IW_AUTH_DROP_UNENCRYPTED:
2905 dev_wlc_bufvar_set(dev, "wsec_restrict", (char *)&paramval, 1);
2906 break;
2907
2908 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
2909 dev_wlc_bufvar_set(dev, "rx_unencrypted_eapol",
2910 (char *)&paramval, 1);
2911 break;
2912
2913 #if WIRELESS_EXT > 17
2914 case IW_AUTH_ROAMING_CONTROL:
2915 WL_INFORM("%s: IW_AUTH_ROAMING_CONTROL\n", __func__);
2916 break;
2917 case IW_AUTH_PRIVACY_INVOKED:
2918 {
2919 int wsec;
2920
2921 if (paramval == 0) {
2922 iw->privacy_invoked = false;
2923 error = dev_wlc_intvar_set(dev,
2924 "is_WPS_enrollee", false);
2925 if (error) {
2926 WL_WSEC("Failed to clear iovar is_WPS_enrollee\n");
2927 return error;
2928 }
2929 } else {
2930 iw->privacy_invoked = true;
2931 error = dev_wlc_intvar_get(dev, "wsec", &wsec);
2932 if (error)
2933 return error;
2934
2935 if (!(IW_WSEC_ENABLED(wsec))) {
2936 error = dev_wlc_intvar_set(dev,
2937 "is_WPS_enrollee",
2938 true);
2939 if (error) {
2940 WL_WSEC("Failed to set iovar is_WPS_enrollee\n");
2941 return error;
2942 }
2943 } else {
2944 error = dev_wlc_intvar_set(dev,
2945 "is_WPS_enrollee",
2946 false);
2947 if (error) {
2948 WL_WSEC("Failed to clear is_WPS_enrollee\n");
2949 return error;
2950 }
2951 }
2952 }
2953 break;
2954 }
2955 #endif /* WIRELESS_EXT > 17 */
2956 default:
2957 break;
2958 }
2959 return 0;
2960 }
2961
2962 #define VAL_PSK(_val) (((_val) & WPA_AUTH_PSK) || ((_val) & WPA2_AUTH_PSK))
2963
2964 static int
2965 wl_iw_get_wpaauth(struct net_device *dev,
2966 struct iw_request_info *info,
2967 struct iw_param *vwrq, char *extra)
2968 {
2969 int error;
2970 int paramid;
2971 int paramval = 0;
2972 int val;
2973 wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
2974
2975 WL_TRACE("%s: SIOCGIWAUTH\n", dev->name);
2976
2977 paramid = vwrq->flags & IW_AUTH_INDEX;
2978
2979 switch (paramid) {
2980 case IW_AUTH_WPA_VERSION:
2981 error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
2982 if (error)
2983 return error;
2984 if (val & (WPA_AUTH_NONE | WPA_AUTH_DISABLED))
2985 paramval = IW_AUTH_WPA_VERSION_DISABLED;
2986 else if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED))
2987 paramval = IW_AUTH_WPA_VERSION_WPA;
2988 else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED))
2989 paramval = IW_AUTH_WPA_VERSION_WPA2;
2990 break;
2991 case IW_AUTH_CIPHER_PAIRWISE:
2992 case IW_AUTH_CIPHER_GROUP:
2993 if (paramid == IW_AUTH_CIPHER_PAIRWISE)
2994 val = iw->pwsec;
2995 else
2996 val = iw->gwsec;
2997
2998 paramval = 0;
2999 if (val) {
3000 if (val & WEP_ENABLED)
3001 paramval |=
3002 (IW_AUTH_CIPHER_WEP40 |
3003 IW_AUTH_CIPHER_WEP104);
3004 if (val & TKIP_ENABLED)
3005 paramval |= (IW_AUTH_CIPHER_TKIP);
3006 if (val & AES_ENABLED)
3007 paramval |= (IW_AUTH_CIPHER_CCMP);
3008 } else
3009 paramval = IW_AUTH_CIPHER_NONE;
3010 break;
3011 case IW_AUTH_KEY_MGMT:
3012 error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
3013 if (error)
3014 return error;
3015 if (VAL_PSK(val))
3016 paramval = IW_AUTH_KEY_MGMT_PSK;
3017 else
3018 paramval = IW_AUTH_KEY_MGMT_802_1X;
3019
3020 break;
3021 case IW_AUTH_TKIP_COUNTERMEASURES:
3022 dev_wlc_bufvar_get(dev, "tkip_countermeasures",
3023 (char *)&paramval, 1);
3024 break;
3025
3026 case IW_AUTH_DROP_UNENCRYPTED:
3027 dev_wlc_bufvar_get(dev, "wsec_restrict", (char *)&paramval, 1);
3028 break;
3029
3030 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
3031 dev_wlc_bufvar_get(dev, "rx_unencrypted_eapol",
3032 (char *)&paramval, 1);
3033 break;
3034
3035 case IW_AUTH_80211_AUTH_ALG:
3036 error = dev_wlc_intvar_get(dev, "auth", &val);
3037 if (error)
3038 return error;
3039 if (!val)
3040 paramval = IW_AUTH_ALG_OPEN_SYSTEM;
3041 else
3042 paramval = IW_AUTH_ALG_SHARED_KEY;
3043 break;
3044 case IW_AUTH_WPA_ENABLED:
3045 error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
3046 if (error)
3047 return error;
3048 if (val)
3049 paramval = true;
3050 else
3051 paramval = false;
3052 break;
3053 #if WIRELESS_EXT > 17
3054 case IW_AUTH_ROAMING_CONTROL:
3055 WL_ERROR("%s: IW_AUTH_ROAMING_CONTROL\n", __func__);
3056 break;
3057 case IW_AUTH_PRIVACY_INVOKED:
3058 paramval = iw->privacy_invoked;
3059 break;
3060
3061 #endif
3062 }
3063 vwrq->value = paramval;
3064 return 0;
3065 }
3066 #endif /* WIRELESS_EXT > 17 */
3067
3068 static const iw_handler wl_iw_handler[] = {
3069 (iw_handler) wl_iw_config_commit,
3070 (iw_handler) wl_iw_get_name,
3071 (iw_handler) NULL,
3072 (iw_handler) NULL,
3073 (iw_handler) wl_iw_set_freq,
3074 (iw_handler) wl_iw_get_freq,
3075 (iw_handler) wl_iw_set_mode,
3076 (iw_handler) wl_iw_get_mode,
3077 (iw_handler) NULL,
3078 (iw_handler) NULL,
3079 (iw_handler) NULL,
3080 (iw_handler) wl_iw_get_range,
3081 (iw_handler) NULL,
3082 (iw_handler) NULL,
3083 (iw_handler) NULL,
3084 (iw_handler) NULL,
3085 (iw_handler) wl_iw_set_spy,
3086 (iw_handler) wl_iw_get_spy,
3087 (iw_handler) NULL,
3088 (iw_handler) NULL,
3089 (iw_handler) wl_iw_set_wap,
3090 (iw_handler) wl_iw_get_wap,
3091 #if WIRELESS_EXT > 17
3092 (iw_handler) wl_iw_mlme,
3093 #else
3094 (iw_handler) NULL,
3095 #endif
3096 #if defined(WL_IW_USE_ISCAN)
3097 (iw_handler) wl_iw_iscan_get_aplist,
3098 #else
3099 (iw_handler) wl_iw_get_aplist,
3100 #endif
3101 #if WIRELESS_EXT > 13
3102 #if defined(WL_IW_USE_ISCAN)
3103 (iw_handler) wl_iw_iscan_set_scan,
3104 (iw_handler) wl_iw_iscan_get_scan,
3105 #else
3106 (iw_handler) wl_iw_set_scan,
3107 (iw_handler) wl_iw_get_scan,
3108 #endif
3109 #else
3110 (iw_handler) NULL,
3111 (iw_handler) NULL,
3112 #endif /* WIRELESS_EXT > 13 */
3113 (iw_handler) wl_iw_set_essid,
3114 (iw_handler) wl_iw_get_essid,
3115 (iw_handler) wl_iw_set_nick,
3116 (iw_handler) wl_iw_get_nick,
3117 (iw_handler) NULL,
3118 (iw_handler) NULL,
3119 (iw_handler) wl_iw_set_rate,
3120 (iw_handler) wl_iw_get_rate,
3121 (iw_handler) wl_iw_set_rts,
3122 (iw_handler) wl_iw_get_rts,
3123 (iw_handler) wl_iw_set_frag,
3124 (iw_handler) wl_iw_get_frag,
3125 (iw_handler) wl_iw_set_txpow,
3126 (iw_handler) wl_iw_get_txpow,
3127 #if WIRELESS_EXT > 10
3128 (iw_handler) wl_iw_set_retry,
3129 (iw_handler) wl_iw_get_retry,
3130 #endif
3131 (iw_handler) wl_iw_set_encode,
3132 (iw_handler) wl_iw_get_encode,
3133 (iw_handler) wl_iw_set_power,
3134 (iw_handler) wl_iw_get_power,
3135 #if WIRELESS_EXT > 17
3136 (iw_handler) NULL,
3137 (iw_handler) NULL,
3138 (iw_handler) wl_iw_set_wpaie,
3139 (iw_handler) wl_iw_get_wpaie,
3140 (iw_handler) wl_iw_set_wpaauth,
3141 (iw_handler) wl_iw_get_wpaauth,
3142 (iw_handler) wl_iw_set_encodeext,
3143 (iw_handler) wl_iw_get_encodeext,
3144 (iw_handler) wl_iw_set_pmksa,
3145 #endif /* WIRELESS_EXT > 17 */
3146 };
3147
3148 #if WIRELESS_EXT > 12
3149
3150 const struct iw_handler_def wl_iw_handler_def = {
3151 .num_standard = ARRAY_SIZE(wl_iw_handler),
3152 .standard = (iw_handler *) wl_iw_handler,
3153 .num_private = 0,
3154 .num_private_args = 0,
3155 .private = 0,
3156 .private_args = 0,
3157
3158 #if WIRELESS_EXT >= 19
3159 .get_wireless_stats = NULL,
3160 #endif
3161 };
3162 #endif /* WIRELESS_EXT > 12 */
3163
3164 int wl_iw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3165 {
3166 struct iwreq *wrq = (struct iwreq *)rq;
3167 struct iw_request_info info;
3168 iw_handler handler;
3169 char *extra = NULL;
3170 int token_size = 1, max_tokens = 0, ret = 0;
3171
3172 WL_TRACE("\n%s, cmd:%x alled via dhd->do_ioctl()entry point\n",
3173 __func__, cmd);
3174 if (cmd < SIOCIWFIRST ||
3175 IW_IOCTL_IDX(cmd) >= ARRAY_SIZE(wl_iw_handler)) {
3176 WL_ERROR("%s: error in cmd=%x : out of range\n",
3177 __func__, cmd);
3178 return -EOPNOTSUPP;
3179 }
3180
3181 handler = wl_iw_handler[IW_IOCTL_IDX(cmd)];
3182 if (!handler) {
3183 WL_ERROR("%s: error in cmd=%x : not supported\n",
3184 __func__, cmd);
3185 return -EOPNOTSUPP;
3186 }
3187
3188 switch (cmd) {
3189
3190 case SIOCSIWESSID:
3191 case SIOCGIWESSID:
3192 case SIOCSIWNICKN:
3193 case SIOCGIWNICKN:
3194 max_tokens = IW_ESSID_MAX_SIZE + 1;
3195 break;
3196
3197 case SIOCSIWENCODE:
3198 case SIOCGIWENCODE:
3199 #if WIRELESS_EXT > 17
3200 case SIOCSIWENCODEEXT:
3201 case SIOCGIWENCODEEXT:
3202 #endif
3203 max_tokens = wrq->u.data.length;
3204 break;
3205
3206 case SIOCGIWRANGE:
3207 max_tokens = sizeof(struct iw_range) + 500;
3208 break;
3209
3210 case SIOCGIWAPLIST:
3211 token_size =
3212 sizeof(struct sockaddr) + sizeof(struct iw_quality);
3213 max_tokens = IW_MAX_AP;
3214 break;
3215
3216 #if WIRELESS_EXT > 13
3217 case SIOCGIWSCAN:
3218 #if defined(WL_IW_USE_ISCAN)
3219 if (g_iscan)
3220 max_tokens = wrq->u.data.length;
3221 else
3222 #endif
3223 max_tokens = IW_SCAN_MAX_DATA;
3224 break;
3225 #endif /* WIRELESS_EXT > 13 */
3226
3227 case SIOCSIWSPY:
3228 token_size = sizeof(struct sockaddr);
3229 max_tokens = IW_MAX_SPY;
3230 break;
3231
3232 case SIOCGIWSPY:
3233 token_size =
3234 sizeof(struct sockaddr) + sizeof(struct iw_quality);
3235 max_tokens = IW_MAX_SPY;
3236 break;
3237
3238 #if WIRELESS_EXT > 17
3239 case SIOCSIWPMKSA:
3240 case SIOCSIWGENIE:
3241 #endif
3242 case SIOCSIWPRIV:
3243 max_tokens = wrq->u.data.length;
3244 break;
3245 }
3246
3247 if (max_tokens && wrq->u.data.pointer) {
3248 if (wrq->u.data.length > max_tokens) {
3249 WL_ERROR("%s: error in cmd=%x wrq->u.data.length=%d > max_tokens=%d\n",
3250 __func__, cmd, wrq->u.data.length, max_tokens);
3251 return -E2BIG;
3252 }
3253 extra = kmalloc(max_tokens * token_size, GFP_KERNEL);
3254 if (!extra)
3255 return -ENOMEM;
3256
3257 if (copy_from_user
3258 (extra, wrq->u.data.pointer,
3259 wrq->u.data.length * token_size)) {
3260 kfree(extra);
3261 return -EFAULT;
3262 }
3263 }
3264
3265 info.cmd = cmd;
3266 info.flags = 0;
3267
3268 ret = handler(dev, &info, &wrq->u, extra);
3269
3270 if (extra) {
3271 if (copy_to_user
3272 (wrq->u.data.pointer, extra,
3273 wrq->u.data.length * token_size)) {
3274 kfree(extra);
3275 return -EFAULT;
3276 }
3277
3278 kfree(extra);
3279 }
3280
3281 return ret;
3282 }
3283
3284 bool
3285 wl_iw_conn_status_str(u32 event_type, u32 status, u32 reason,
3286 char *stringBuf, uint buflen)
3287 {
3288 typedef struct conn_fail_event_map_t {
3289 u32 inEvent;
3290 u32 inStatus;
3291 u32 inReason;
3292 const char *outName;
3293 const char *outCause;
3294 } conn_fail_event_map_t;
3295
3296 #define WL_IW_DONT_CARE 9999
3297 const conn_fail_event_map_t event_map[] = {
3298 {WLC_E_SET_SSID, WLC_E_STATUS_SUCCESS, WL_IW_DONT_CARE,
3299 "Conn", "Success"},
3300 {WLC_E_SET_SSID, WLC_E_STATUS_NO_NETWORKS, WL_IW_DONT_CARE,
3301 "Conn", "NoNetworks"},
3302 {WLC_E_SET_SSID, WLC_E_STATUS_FAIL, WL_IW_DONT_CARE,
3303 "Conn", "ConfigMismatch"},
3304 {WLC_E_PRUNE, WL_IW_DONT_CARE, WLC_E_PRUNE_ENCR_MISMATCH,
3305 "Conn", "EncrypMismatch"},
3306 {WLC_E_PRUNE, WL_IW_DONT_CARE, WLC_E_RSN_MISMATCH,
3307 "Conn", "RsnMismatch"},
3308 {WLC_E_AUTH, WLC_E_STATUS_TIMEOUT, WL_IW_DONT_CARE,
3309 "Conn", "AuthTimeout"},
3310 {WLC_E_AUTH, WLC_E_STATUS_FAIL, WL_IW_DONT_CARE,
3311 "Conn", "AuthFail"},
3312 {WLC_E_AUTH, WLC_E_STATUS_NO_ACK, WL_IW_DONT_CARE,
3313 "Conn", "AuthNoAck"},
3314 {WLC_E_REASSOC, WLC_E_STATUS_FAIL, WL_IW_DONT_CARE,
3315 "Conn", "ReassocFail"},
3316 {WLC_E_REASSOC, WLC_E_STATUS_TIMEOUT, WL_IW_DONT_CARE,
3317 "Conn", "ReassocTimeout"},
3318 {WLC_E_REASSOC, WLC_E_STATUS_ABORT, WL_IW_DONT_CARE,
3319 "Conn", "ReassocAbort"},
3320 {WLC_E_PSK_SUP, WLC_SUP_KEYED, WL_IW_DONT_CARE,
3321 "Sup", "ConnSuccess"},
3322 {WLC_E_PSK_SUP, WL_IW_DONT_CARE, WL_IW_DONT_CARE,
3323 "Sup", "WpaHandshakeFail"},
3324 {WLC_E_DEAUTH_IND, WL_IW_DONT_CARE, WL_IW_DONT_CARE,
3325 "Conn", "Deauth"},
3326 {WLC_E_DISASSOC_IND, WL_IW_DONT_CARE, WL_IW_DONT_CARE,
3327 "Conn", "DisassocInd"},
3328 {WLC_E_DISASSOC, WL_IW_DONT_CARE, WL_IW_DONT_CARE,
3329 "Conn", "Disassoc"}
3330 };
3331
3332 const char *name = "";
3333 const char *cause = NULL;
3334 int i;
3335
3336 for (i = 0; i < sizeof(event_map) / sizeof(event_map[0]); i++) {
3337 const conn_fail_event_map_t *row = &event_map[i];
3338 if (row->inEvent == event_type &&
3339 (row->inStatus == status
3340 || row->inStatus == WL_IW_DONT_CARE)
3341 && (row->inReason == reason
3342 || row->inReason == WL_IW_DONT_CARE)) {
3343 name = row->outName;
3344 cause = row->outCause;
3345 break;
3346 }
3347 }
3348
3349 if (cause) {
3350 memset(stringBuf, 0, buflen);
3351 snprintf(stringBuf, buflen, "%s %s %02d %02d",
3352 name, cause, status, reason);
3353 WL_INFORM("Connection status: %s\n", stringBuf);
3354 return true;
3355 } else {
3356 return false;
3357 }
3358 }
3359
3360 #if WIRELESS_EXT > 14
3361
3362 static bool
3363 wl_iw_check_conn_fail(wl_event_msg_t *e, char *stringBuf, uint buflen)
3364 {
3365 u32 event = be32_to_cpu(e->event_type);
3366 u32 status = be32_to_cpu(e->status);
3367 u32 reason = be32_to_cpu(e->reason);
3368
3369 if (wl_iw_conn_status_str(event, status, reason, stringBuf, buflen)) {
3370 return true;
3371 } else
3372 return false;
3373 }
3374 #endif
3375
3376 #ifndef IW_CUSTOM_MAX
3377 #define IW_CUSTOM_MAX 256
3378 #endif
3379
3380 void wl_iw_event(struct net_device *dev, wl_event_msg_t *e, void *data)
3381 {
3382 #if WIRELESS_EXT > 13
3383 union iwreq_data wrqu;
3384 char extra[IW_CUSTOM_MAX + 1];
3385 int cmd = 0;
3386 u32 event_type = be32_to_cpu(e->event_type);
3387 u16 flags = be16_to_cpu(e->flags);
3388 u32 datalen = be32_to_cpu(e->datalen);
3389 u32 status = be32_to_cpu(e->status);
3390 wl_iw_t *iw;
3391 u32 toto;
3392 memset(&wrqu, 0, sizeof(wrqu));
3393 memset(extra, 0, sizeof(extra));
3394 iw = 0;
3395
3396 if (!dev) {
3397 WL_ERROR("%s: dev is null\n", __func__);
3398 return;
3399 }
3400
3401 iw = *(wl_iw_t **) netdev_priv(dev);
3402
3403 WL_TRACE("%s: dev=%s event=%d\n", __func__, dev->name, event_type);
3404
3405 switch (event_type) {
3406 case WLC_E_TXFAIL:
3407 cmd = IWEVTXDROP;
3408 memcpy(wrqu.addr.sa_data, &e->addr, ETH_ALEN);
3409 wrqu.addr.sa_family = ARPHRD_ETHER;
3410 break;
3411 #if WIRELESS_EXT > 14
3412 case WLC_E_JOIN:
3413 case WLC_E_ASSOC_IND:
3414 case WLC_E_REASSOC_IND:
3415 memcpy(wrqu.addr.sa_data, &e->addr, ETH_ALEN);
3416 wrqu.addr.sa_family = ARPHRD_ETHER;
3417 cmd = IWEVREGISTERED;
3418 break;
3419 case WLC_E_DEAUTH_IND:
3420 case WLC_E_DISASSOC_IND:
3421 cmd = SIOCGIWAP;
3422 memset(wrqu.addr.sa_data, 0, ETH_ALEN);
3423 wrqu.addr.sa_family = ARPHRD_ETHER;
3424 memset(&extra, 0, ETH_ALEN);
3425 break;
3426 case WLC_E_LINK:
3427 case WLC_E_NDIS_LINK:
3428 cmd = SIOCGIWAP;
3429 if (!(flags & WLC_EVENT_MSG_LINK)) {
3430 memset(wrqu.addr.sa_data, 0, ETH_ALEN);
3431 memset(&extra, 0, ETH_ALEN);
3432 } else {
3433 memcpy(wrqu.addr.sa_data, &e->addr, ETH_ALEN);
3434 WL_TRACE("Link UP\n");
3435
3436 }
3437 wrqu.addr.sa_family = ARPHRD_ETHER;
3438 break;
3439 case WLC_E_ACTION_FRAME:
3440 cmd = IWEVCUSTOM;
3441 if (datalen + 1 <= sizeof(extra)) {
3442 wrqu.data.length = datalen + 1;
3443 extra[0] = WLC_E_ACTION_FRAME;
3444 memcpy(&extra[1], data, datalen);
3445 WL_TRACE("WLC_E_ACTION_FRAME len %d\n",
3446 wrqu.data.length);
3447 }
3448 break;
3449
3450 case WLC_E_ACTION_FRAME_COMPLETE:
3451 cmd = IWEVCUSTOM;
3452 memcpy(&toto, data, 4);
3453 if (sizeof(status) + 1 <= sizeof(extra)) {
3454 wrqu.data.length = sizeof(status) + 1;
3455 extra[0] = WLC_E_ACTION_FRAME_COMPLETE;
3456 memcpy(&extra[1], &status, sizeof(status));
3457 WL_TRACE("wl_iw_event status %d PacketId %d\n", status,
3458 toto);
3459 WL_TRACE("WLC_E_ACTION_FRAME_COMPLETE len %d\n",
3460 wrqu.data.length);
3461 }
3462 break;
3463 #endif /* WIRELESS_EXT > 14 */
3464 #if WIRELESS_EXT > 17
3465 case WLC_E_MIC_ERROR:
3466 {
3467 struct iw_michaelmicfailure *micerrevt =
3468 (struct iw_michaelmicfailure *)&extra;
3469 cmd = IWEVMICHAELMICFAILURE;
3470 wrqu.data.length = sizeof(struct iw_michaelmicfailure);
3471 if (flags & WLC_EVENT_MSG_GROUP)
3472 micerrevt->flags |= IW_MICFAILURE_GROUP;
3473 else
3474 micerrevt->flags |= IW_MICFAILURE_PAIRWISE;
3475 memcpy(micerrevt->src_addr.sa_data, &e->addr,
3476 ETH_ALEN);
3477 micerrevt->src_addr.sa_family = ARPHRD_ETHER;
3478
3479 break;
3480 }
3481 case WLC_E_PMKID_CACHE:
3482 {
3483 if (data) {
3484 struct iw_pmkid_cand *iwpmkidcand =
3485 (struct iw_pmkid_cand *)&extra;
3486 pmkid_cand_list_t *pmkcandlist;
3487 pmkid_cand_t *pmkidcand;
3488 int count;
3489
3490 cmd = IWEVPMKIDCAND;
3491 pmkcandlist = data;
3492 count = get_unaligned_be32(&pmkcandlist->
3493 npmkid_cand);
3494 ASSERT(count >= 0);
3495 wrqu.data.length = sizeof(struct iw_pmkid_cand);
3496 pmkidcand = pmkcandlist->pmkid_cand;
3497 while (count) {
3498 memset(iwpmkidcand, 0,
3499 sizeof(struct iw_pmkid_cand));
3500 if (pmkidcand->preauth)
3501 iwpmkidcand->flags |=
3502 IW_PMKID_CAND_PREAUTH;
3503 memcpy(&iwpmkidcand->bssid.sa_data,
3504 &pmkidcand->BSSID,
3505 ETH_ALEN);
3506 #ifndef SANDGATE2G
3507 wireless_send_event(dev, cmd, &wrqu,
3508 extra);
3509 #endif
3510 pmkidcand++;
3511 count--;
3512 }
3513 }
3514 return;
3515 }
3516 #endif /* WIRELESS_EXT > 17 */
3517
3518 case WLC_E_SCAN_COMPLETE:
3519 #if defined(WL_IW_USE_ISCAN)
3520 if ((g_iscan) && (g_iscan->sysioc_tsk) &&
3521 (g_iscan->iscan_state != ISCAN_STATE_IDLE)) {
3522 up(&g_iscan->sysioc_sem);
3523 } else {
3524 cmd = SIOCGIWSCAN;
3525 wrqu.data.length = strlen(extra);
3526 WL_TRACE("Event WLC_E_SCAN_COMPLETE from specific scan %d\n",
3527 g_iscan->iscan_state);
3528 }
3529 #else
3530 cmd = SIOCGIWSCAN;
3531 wrqu.data.length = strlen(extra);
3532 WL_TRACE("Event WLC_E_SCAN_COMPLETE\n");
3533 #endif
3534 break;
3535
3536 case WLC_E_PFN_NET_FOUND:
3537 {
3538 wlc_ssid_t *ssid;
3539 ssid = (wlc_ssid_t *) data;
3540 WL_ERROR("%s Event WLC_E_PFN_NET_FOUND, send %s up : find %s len=%d\n",
3541 __func__, PNO_EVENT_UP,
3542 ssid->SSID, ssid->SSID_len);
3543 cmd = IWEVCUSTOM;
3544 memset(&wrqu, 0, sizeof(wrqu));
3545 strcpy(extra, PNO_EVENT_UP);
3546 wrqu.data.length = strlen(extra);
3547 }
3548 break;
3549
3550 default:
3551 WL_TRACE("Unknown Event %d: ignoring\n", event_type);
3552 break;
3553 }
3554 #ifndef SANDGATE2G
3555 if (cmd) {
3556 if (cmd == SIOCGIWSCAN)
3557 wireless_send_event(dev, cmd, &wrqu, NULL);
3558 else
3559 wireless_send_event(dev, cmd, &wrqu, extra);
3560 }
3561 #endif
3562
3563 #if WIRELESS_EXT > 14
3564 memset(extra, 0, sizeof(extra));
3565 if (wl_iw_check_conn_fail(e, extra, sizeof(extra))) {
3566 cmd = IWEVCUSTOM;
3567 wrqu.data.length = strlen(extra);
3568 #ifndef SANDGATE2G
3569 wireless_send_event(dev, cmd, &wrqu, extra);
3570 #endif
3571 }
3572 #endif /* WIRELESS_EXT > 14 */
3573 #endif /* WIRELESS_EXT > 13 */
3574 }
3575
3576 int wl_iw_attach(struct net_device *dev, void *dhdp)
3577 {
3578 int params_size;
3579 wl_iw_t *iw;
3580 #if defined(WL_IW_USE_ISCAN)
3581 iscan_info_t *iscan = NULL;
3582
3583 if (!dev)
3584 return 0;
3585
3586 memset(&g_wl_iw_params, 0, sizeof(wl_iw_extra_params_t));
3587
3588 #ifdef CSCAN
3589 params_size =
3590 (WL_SCAN_PARAMS_FIXED_SIZE + offsetof(wl_iscan_params_t, params)) +
3591 (WL_NUMCHANNELS * sizeof(u16)) +
3592 WL_SCAN_PARAMS_SSID_MAX * sizeof(wlc_ssid_t);
3593 #else
3594 params_size =
3595 (WL_SCAN_PARAMS_FIXED_SIZE + offsetof(wl_iscan_params_t, params));
3596 #endif
3597 iscan = kzalloc(sizeof(iscan_info_t), GFP_KERNEL);
3598
3599 if (!iscan)
3600 return -ENOMEM;
3601
3602 iscan->iscan_ex_params_p = kmalloc(params_size, GFP_KERNEL);
3603 if (!iscan->iscan_ex_params_p) {
3604 kfree(iscan);
3605 return -ENOMEM;
3606 }
3607 iscan->iscan_ex_param_size = params_size;
3608 iscan->sysioc_tsk = NULL;
3609
3610 g_iscan = iscan;
3611 iscan->dev = dev;
3612 iscan->iscan_state = ISCAN_STATE_IDLE;
3613
3614 iscan->timer_ms = 3000;
3615 init_timer(&iscan->timer);
3616 iscan->timer.data = (unsigned long) iscan;
3617 iscan->timer.function = wl_iw_timerfunc;
3618
3619 sema_init(&iscan->sysioc_sem, 0);
3620 iscan->sysioc_tsk = kthread_run(_iscan_sysioc_thread, iscan,
3621 "_iscan_sysioc");
3622 if (IS_ERR(iscan->sysioc_tsk)) {
3623 iscan->sysioc_tsk = NULL;
3624 return -ENOMEM;
3625 }
3626 #endif /* defined(WL_IW_USE_ISCAN) */
3627
3628 iw = *(wl_iw_t **) netdev_priv(dev);
3629 iw->pub = (dhd_pub_t *) dhdp;
3630 MUTEX_LOCK_INIT(iw->pub);
3631 MUTEX_LOCK_WL_SCAN_SET_INIT();
3632 #ifdef SOFTAP
3633 priv_dev = dev;
3634 MUTEX_LOCK_SOFTAP_SET_INIT(iw->pub);
3635 #endif
3636 g_scan = kzalloc(G_SCAN_RESULTS, GFP_KERNEL);
3637 if (!g_scan)
3638 return -ENOMEM;
3639
3640 g_scan_specified_ssid = 0;
3641
3642 return 0;
3643 }
3644
3645 void wl_iw_detach(void)
3646 {
3647 #if defined(WL_IW_USE_ISCAN)
3648 iscan_buf_t *buf;
3649 iscan_info_t *iscan = g_iscan;
3650
3651 if (!iscan)
3652 return;
3653 if (iscan->sysioc_tsk) {
3654 send_sig(SIGTERM, iscan->sysioc_tsk, 1);
3655 kthread_stop(iscan->sysioc_tsk);
3656 iscan->sysioc_tsk = NULL;
3657 }
3658
3659 MUTEX_LOCK_WL_SCAN_SET();
3660 while (iscan->list_hdr) {
3661 buf = iscan->list_hdr->next;
3662 kfree(iscan->list_hdr);
3663 iscan->list_hdr = buf;
3664 }
3665 MUTEX_UNLOCK_WL_SCAN_SET();
3666 kfree(iscan->iscan_ex_params_p);
3667 kfree(iscan);
3668 g_iscan = NULL;
3669 #endif /* WL_IW_USE_ISCAN */
3670
3671 kfree(g_scan);
3672
3673 g_scan = NULL;
3674 }
3675
3676 #if defined(BCMDBG)
3677 void osl_assert(char *exp, char *file, int line)
3678 {
3679 char tempbuf[256];
3680 char *basename;
3681
3682 basename = strrchr(file, '/');
3683 /* skip the '/' */
3684 if (basename)
3685 basename++;
3686
3687 if (!basename)
3688 basename = file;
3689
3690 snprintf(tempbuf, 256,
3691 "assertion \"%s\" failed: file \"%s\", line %d\n", exp,
3692 basename, line);
3693
3694 /*
3695 * Print assert message and give it time to
3696 * be written to /var/log/messages
3697 */
3698 if (!in_interrupt()) {
3699 const int delay = 3;
3700 printk(KERN_ERR "%s", tempbuf);
3701 printk(KERN_ERR "panic in %d seconds\n", delay);
3702 set_current_state(TASK_INTERRUPTIBLE);
3703 schedule_timeout(delay * HZ);
3704 }
3705
3706 switch (g_assert_type) {
3707 case 0:
3708 panic(KERN_ERR "%s", tempbuf);
3709 break;
3710 case 1:
3711 printk(KERN_ERR "%s", tempbuf);
3712 BUG();
3713 break;
3714 case 2:
3715 printk(KERN_ERR "%s", tempbuf);
3716 break;
3717 default:
3718 break;
3719 }
3720 }
3721 #endif /* defined(BCMDBG) */
Linux kernel - Deliverables
This page took 0.135473 seconds and 5 git commands to generate.