1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/types.h>
17#include <linux/etherdevice.h>
18#include <linux/if_arp.h>
19#include <asm/uaccess.h>
20#include <linux/ctype.h>
21#include "unifi_priv.h"
22#include <linux/rtnetlink.h>
23
24#define CHECK_INITED(_priv) \
25 do { \
26 if (_priv->init_progress != UNIFI_INIT_COMPLETED) { \
27 unifi_trace(_priv, UDBG2, "%s unifi not ready, failing wext call\n", __FUNCTION__); \
28 return -ENODEV; \
29 } \
30 } while (0)
31
32
33#ifndef ANDROID_BUILD
34#define CSR_WIFI_WEXT_HANG_WORKAROUND
35#endif
36
37#ifdef CSR_WIFI_WEXT_HANG_WORKAROUND
38# define UF_RTNL_LOCK() rtnl_lock()
39# define UF_RTNL_UNLOCK() rtnl_unlock()
40#else
41# define UF_RTNL_LOCK()
42# define UF_RTNL_UNLOCK()
43#endif
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67static int
68wext_freq_to_channel(int m, int e)
69{
70 int mhz;
71
72 mhz = m;
73 while (e < 6) {
74 mhz /= 10;
75 e++;
76 }
77 while (e > 6) {
78 mhz *= 10;
79 e--;
80 }
81
82 if (mhz >= 5000) {
83 return ((mhz - 5000) / 5);
84 }
85
86 if (mhz == 2482) {
87 return 14;
88 }
89
90 if (mhz >= 2407) {
91 return ((mhz - 2407) / 5);
92 }
93
94 return 0;
95}
96
97static int
98channel_to_mhz(int ch, int dot11a)
99{
100
101 if (ch == 0) return 0;
102 if (ch > 200) return 0;
103
104
105 if (dot11a) {
106 return (5000 + (5 * ch));
107 }
108
109
110 if (ch == 14) {
111 return 2484;
112 }
113
114 if ((ch < 14) && (ch > 0)) {
115 return (2407 + (5 * ch));
116 }
117
118 return 0;
119}
120#ifdef CSR_SUPPORT_WEXT_AP
121void uf_sme_wext_ap_set_defaults(unifi_priv_t *priv)
122{
123 memcpy(priv->ap_config.ssid.ssid,"defaultssid",sizeof("defaultssid"));
124
125 priv->ap_config.ssid.length = 8;
126 priv->ap_config.channel = 6;
127 priv->ap_config.if_index = 1;
128 priv->ap_config.credentials.authType = 0;
129 priv->ap_config.max_connections=8;
130
131 priv->group_sec_config.apGroupkeyTimeout = 0;
132 priv->group_sec_config.apStrictGtkRekey = 0;
133 priv->group_sec_config.apGmkTimeout = 0;
134 priv->group_sec_config.apResponseTimeout = 100;
135 priv->group_sec_config.apRetransLimit = 3;
136
137
138
139 priv->ap_mac_config.preamble = CSR_WIFI_SME_USE_LONG_PREAMBLE;
140 priv->ap_mac_config.shortSlotTimeEnabled = FALSE;
141 priv->ap_mac_config.ctsProtectionType=CSR_WIFI_SME_CTS_PROTECTION_AUTOMATIC;
142
143 priv->ap_mac_config.wmmEnabled = TRUE;
144 priv->ap_mac_config.wmmApParams[0].cwMin=4;
145 priv->ap_mac_config.wmmApParams[0].cwMax=10;
146 priv->ap_mac_config.wmmApParams[0].aifs=3;
147 priv->ap_mac_config.wmmApParams[0].txopLimit=0;
148 priv->ap_mac_config.wmmApParams[0].admissionControlMandatory=FALSE;
149 priv->ap_mac_config.wmmApParams[1].cwMin=4;
150 priv->ap_mac_config.wmmApParams[1].cwMax=10;
151 priv->ap_mac_config.wmmApParams[1].aifs=7;
152 priv->ap_mac_config.wmmApParams[1].txopLimit=0;
153 priv->ap_mac_config.wmmApParams[1].admissionControlMandatory=FALSE;
154 priv->ap_mac_config.wmmApParams[2].cwMin=3;
155 priv->ap_mac_config.wmmApParams[2].cwMax=4;
156 priv->ap_mac_config.wmmApParams[2].aifs=1;
157 priv->ap_mac_config.wmmApParams[2].txopLimit=94;
158 priv->ap_mac_config.wmmApParams[2].admissionControlMandatory=FALSE;
159 priv->ap_mac_config.wmmApParams[3].cwMin=2;
160 priv->ap_mac_config.wmmApParams[3].cwMax=3;
161 priv->ap_mac_config.wmmApParams[3].aifs=1;
162 priv->ap_mac_config.wmmApParams[3].txopLimit=47;
163 priv->ap_mac_config.wmmApParams[3].admissionControlMandatory=FALSE;
164
165 priv->ap_mac_config.wmmApBcParams[0].cwMin=4;
166 priv->ap_mac_config.wmmApBcParams[0].cwMax=10;
167 priv->ap_mac_config.wmmApBcParams[0].aifs=3;
168 priv->ap_mac_config.wmmApBcParams[0].txopLimit=0;
169 priv->ap_mac_config.wmmApBcParams[0].admissionControlMandatory=FALSE;
170 priv->ap_mac_config.wmmApBcParams[1].cwMin=4;
171 priv->ap_mac_config.wmmApBcParams[1].cwMax=10;
172 priv->ap_mac_config.wmmApBcParams[1].aifs=7;
173 priv->ap_mac_config.wmmApBcParams[1].txopLimit=0;
174 priv->ap_mac_config.wmmApBcParams[1].admissionControlMandatory=FALSE;
175 priv->ap_mac_config.wmmApBcParams[2].cwMin=3;
176 priv->ap_mac_config.wmmApBcParams[2].cwMax=4;
177 priv->ap_mac_config.wmmApBcParams[2].aifs=2;
178 priv->ap_mac_config.wmmApBcParams[2].txopLimit=94;
179 priv->ap_mac_config.wmmApBcParams[2].admissionControlMandatory=FALSE;
180 priv->ap_mac_config.wmmApBcParams[3].cwMin=2;
181 priv->ap_mac_config.wmmApBcParams[3].cwMax=3;
182 priv->ap_mac_config.wmmApBcParams[3].aifs=2;
183 priv->ap_mac_config.wmmApBcParams[3].txopLimit=47;
184 priv->ap_mac_config.wmmApBcParams[3].admissionControlMandatory=FALSE;
185
186 priv->ap_mac_config.accessType=CSR_WIFI_AP_ACCESS_TYPE_NONE;
187 priv->ap_mac_config.macAddressListCount=0;
188 priv->ap_mac_config.macAddressList=NULL;
189
190 priv->ap_mac_config.apHtParams.rxStbc=1;
191 priv->ap_mac_config.apHtParams.rifsModeAllowed=TRUE;
192 priv->ap_mac_config.apHtParams.greenfieldSupported=FALSE;
193 priv->ap_mac_config.apHtParams.shortGi20MHz=TRUE;
194 priv->ap_mac_config.apHtParams.htProtection=0;
195 priv->ap_mac_config.apHtParams.dualCtsProtection=FALSE;
196
197 priv->ap_mac_config.phySupportedBitmap =
198 (CSR_WIFI_SME_AP_PHY_SUPPORT_B|CSR_WIFI_SME_AP_PHY_SUPPORT_G|CSR_WIFI_SME_AP_PHY_SUPPORT_N);
199 priv->ap_mac_config.beaconInterval= 100;
200 priv->ap_mac_config.dtimPeriod=3;
201 priv->ap_mac_config.maxListenInterval=0x00ff;
202
203
204 priv->ap_mac_config.supportedRatesCount =
205 uf_configure_supported_rates(priv->ap_mac_config.supportedRates,priv->ap_mac_config.phySupportedBitmap);
206}
207#endif
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223void
224uf_sme_wext_set_defaults(unifi_priv_t *priv)
225{
226 memset(&priv->connection_config, 0, sizeof(CsrWifiSmeConnectionConfig));
227
228 priv->connection_config.bssType = CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE;
229 priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
230 priv->connection_config.encryptionModeMask = CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE;
231 priv->connection_config.privacyMode = CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED;
232 priv->connection_config.wmmQosInfo = 0xFF;
233 priv->connection_config.ifIndex = CSR_WIFI_SME_RADIO_IF_BOTH;
234 priv->connection_config.adhocJoinOnly = FALSE;
235 priv->connection_config.adhocChannel = 6;
236
237 priv->wep_tx_key_index = 0;
238
239 priv->wext_wireless_stats.qual.qual = 0;
240 priv->wext_wireless_stats.qual.level = 0;
241 priv->wext_wireless_stats.qual.noise = 0;
242 priv->wext_wireless_stats.qual.updated = 0x70;
243#ifdef CSR_SUPPORT_WEXT_AP
244
245 uf_sme_wext_ap_set_defaults(priv);
246#endif
247
248
249}
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287static int
288iwprivsdefs(struct net_device *dev, struct iw_request_info *info,
289 union iwreq_data *wrqu, char *extra)
290{
291 int r;
292 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
293 unifi_priv_t *priv = interfacePriv->privPtr;
294 CsrWifiSmeMibConfig mibConfig;
295 CsrWifiSmePowerConfig powerConfig;
296
297 unifi_trace(priv, UDBG1, "iwprivs80211defaults: reload defaults\n");
298
299 uf_sme_wext_set_defaults(priv);
300
301
302 r = sme_mgt_mib_config_get(priv, &mibConfig);
303 if (r) {
304 unifi_error(priv, "iwprivs80211defaults: Get CsrWifiSmeMibConfigValue failed.\n");
305 return r;
306 }
307 mibConfig.dot11RtsThreshold = 2347;
308 mibConfig.dot11FragmentationThreshold = 2346;
309 r = sme_mgt_mib_config_set(priv, &mibConfig);
310 if (r) {
311 unifi_error(priv, "iwprivs80211defaults: Set CsrWifiSmeMibConfigValue failed.\n");
312 return r;
313 }
314
315 powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW;
316 powerConfig.listenIntervalTu = 100;
317 powerConfig.rxDtims = 1;
318
319 r = sme_mgt_power_config_set(priv, &powerConfig);
320 if (r) {
321 unifi_error(priv, "iwprivs80211defaults: Set unifi_PowerConfigValue failed.\n");
322 return r;
323 }
324
325 return 0;
326}
327
328static int
329iwprivs80211ps(struct net_device *dev, struct iw_request_info *info,
330 union iwreq_data *wrqu, char *extra)
331{
332 int r = 0;
333 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
334 unifi_priv_t *priv = interfacePriv->privPtr;
335
336 int ps_mode = (int)(*extra);
337 CsrWifiSmePowerConfig powerConfig;
338
339 unifi_trace(priv, UDBG1, "iwprivs80211ps: power save mode = %d\n", ps_mode);
340
341 r = sme_mgt_power_config_get(priv, &powerConfig);
342 if (r) {
343 unifi_error(priv, "iwprivs80211ps: Get unifi_PowerConfigValue failed.\n");
344 return r;
345 }
346
347 switch (ps_mode) {
348 case CSR_PMM_ACTIVE_MODE:
349 powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW;
350 break;
351 case CSR_PMM_POWER_SAVE:
352 powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH;
353 break;
354 case CSR_PMM_FAST_POWER_SAVE:
355 powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_MED;
356 break;
357 default:
358 powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_AUTO;
359 break;
360 }
361
362 r = sme_mgt_power_config_set(priv, &powerConfig);
363 if (r) {
364 unifi_error(priv, "iwprivs80211ps: Set unifi_PowerConfigValue failed.\n");
365 }
366
367 return r;
368}
369
370static int
371iwprivg80211ps(struct net_device *dev, struct iw_request_info *info,
372 union iwreq_data *wrqu, char *extra)
373{
374 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
375 unifi_priv_t *priv = interfacePriv->privPtr;
376
377 CsrWifiSmePowerConfig powerConfig;
378 int r;
379
380 r = sme_mgt_power_config_get(priv, &powerConfig);
381 if (r) {
382 unifi_error(priv, "iwprivg80211ps: Get 802.11 power mode failed.\n");
383 return r;
384 }
385
386 switch (powerConfig.powerSaveLevel) {
387 case CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW:
388 snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
389 "Power save mode: %d (Active)",
390 powerConfig.powerSaveLevel);
391 break;
392 case CSR_WIFI_SME_POWER_SAVE_LEVEL_MED:
393 snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
394 "Power save mode: %d (Fast)",
395 powerConfig.powerSaveLevel);
396 break;
397 case CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH:
398 snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
399 "Power save mode: %d (Full)",
400 powerConfig.powerSaveLevel);
401 break;
402 case CSR_WIFI_SME_POWER_SAVE_LEVEL_AUTO:
403 snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
404 "Power save mode: %d (Auto)",
405 powerConfig.powerSaveLevel);
406 break;
407 default:
408 snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
409 "Power save mode: %d (Unknown)",
410 powerConfig.powerSaveLevel);
411 break;
412 }
413
414 wrqu->data.length = strlen(extra) + 1;
415
416 return 0;
417}
418
419static int
420iwprivssmedebug(struct net_device *dev, struct iw_request_info *info,
421 union iwreq_data *wrqu, char *extra)
422{
423
424#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE)
425 unifi_debug_buf_dump();
426#endif
427
428 return 0;
429}
430
431#ifdef CSR_SUPPORT_WEXT_AP
432#define PARAM_TYPE_INT 0
433#define PARAM_TYPE_STRING 1
434#define CSR_WIFI_MAX_SSID_LEN 32
435#define CSR_WIFI_MAX_SEC_LEN 16
436#define CSR_WIFI_MAX_KEY_LEN 65
437
438static int hex_look_up(char x)
439{
440 if(x>='0' && x<='9')
441 return (x-48);
442 if(x>= 'a' && x <= 'f')
443 return (x-87);
444 return -1;
445}
446
447static int power (int a, int b)
448{
449 int i;
450 int num =1;
451 for(i=0;i<b;i++)
452 num *=a;
453 return num;
454}
455
456static int decode_parameter_from_string(unifi_priv_t* priv, char **str_ptr,
457 const char *token, int param_type,
458 void *dst, int param_max_len)
459{
460 u8 int_str[7] = "0";
461 u32 param_str_len;
462 u8 *param_str_begin,*param_str_end;
463 u8 *orig_str = *str_ptr;
464
465 if (!strncmp(*str_ptr, token, strlen(token))) {
466 strsep(str_ptr, "=,");
467 param_str_begin = *str_ptr;
468 strsep(str_ptr, "=,");
469 if (*str_ptr == NULL) {
470 param_str_len = strlen(param_str_begin);
471 } else {
472 param_str_end = *str_ptr-1;
473 param_str_len = param_str_end - param_str_begin;
474 }
475 unifi_trace(priv,UDBG2,"'token:%s', len:%d, ", token, param_str_len);
476 if (param_str_len > param_max_len) {
477 unifi_notice(priv,"extracted param len:%d is > MAX:%d\n",param_str_len, param_max_len);
478 param_str_len = param_max_len;
479 }
480 switch (param_type) {
481 case PARAM_TYPE_INT:
482 {
483 u32 *pdst_int = dst,num =0;
484 int i,j=0;
485 if (param_str_len > sizeof(int_str)) {
486 param_str_len = sizeof(int_str);
487 }
488 memcpy(int_str, param_str_begin, param_str_len);
489 for(i = param_str_len; i>0;i--) {
490 if(int_str[i-1] >= '0' && int_str[i-1] <='9') {
491 num += ((int_str[i-1]-'0')*power(10,j));
492 j++;
493 } else {
494 unifi_error(priv,"decode_parameter_from_string:not a number %c\n",(int_str[i-1]));
495 return -1;
496 }
497 }
498 *pdst_int = num;
499 unifi_trace(priv,UDBG2,"decode_parameter_from_string:decoded int = %d\n",*pdst_int);
500 }
501 break;
502 default:
503 memcpy(dst, param_str_begin, param_str_len);
504 *((char *)dst + param_str_len) = 0;
505 unifi_trace(priv,UDBG2,"decode_parameter_from_string:decoded string = %s\n",(char *)dst);
506 break;
507 }
508 } else {
509 unifi_error(priv,"decode_parameter_from_string: Token:%s not found in %s \n",token,orig_str);
510 return -1;
511 }
512 return 0;
513}
514static int store_ap_advanced_config_from_string(unifi_priv_t *priv, char *param_str)
515{
516 char * str_ptr=param_str;
517 int ret = 0,tmp_var;
518 char phy_mode[6];
519 CsrWifiSmeApMacConfig * ap_mac_config = &priv->ap_mac_config;
520
521
522 ret = decode_parameter_from_string(priv, &str_ptr, "BI=",
523 PARAM_TYPE_INT, &tmp_var, 5);
524 if(ret) {
525 unifi_error(priv,"store_ap_advanced_config_from_string: BI not found\n");
526 return -1;
527 }
528 ap_mac_config->beaconInterval = tmp_var;
529 ret = decode_parameter_from_string(priv, &str_ptr, "DTIM_PER=",
530 PARAM_TYPE_INT, &tmp_var, 5);
531 if(ret) {
532 unifi_error(priv,"store_ap_advanced_config_from_string: DTIM_PER not found\n");
533 return -1;
534 }
535 ap_mac_config->dtimPeriod = tmp_var;
536 ret = decode_parameter_from_string(priv, &str_ptr, "WMM=",
537 PARAM_TYPE_INT, &tmp_var, 5);
538 if(ret) {
539 unifi_error(priv,"store_ap_advanced_config_from_string: WMM not found\n");
540 return -1;
541 }
542 ap_mac_config->wmmEnabled = tmp_var;
543 ret = decode_parameter_from_string(priv, &str_ptr, "PHY=",
544 PARAM_TYPE_STRING, phy_mode, 5);
545 if(ret) {
546 unifi_error(priv,"store_ap_advanced_config_from_string: PHY not found\n");
547 } else {
548 if(strstr(phy_mode,"b")){
549 ap_mac_config->phySupportedBitmap = CSR_WIFI_SME_AP_PHY_SUPPORT_B;
550 }
551 if(strstr(phy_mode,"g")) {
552 ap_mac_config->phySupportedBitmap |= CSR_WIFI_SME_AP_PHY_SUPPORT_G;
553 }
554 if(strstr(phy_mode,"n")) {
555 ap_mac_config->phySupportedBitmap |= CSR_WIFI_SME_AP_PHY_SUPPORT_N;
556 }
557 ap_mac_config->supportedRatesCount =
558 uf_configure_supported_rates(ap_mac_config->supportedRates, ap_mac_config->phySupportedBitmap);
559 }
560 return ret;
561}
562
563static int store_ap_config_from_string( unifi_priv_t * priv,char *param_str)
564
565{
566 char *str_ptr = param_str;
567 char sub_cmd[16];
568 char sec[CSR_WIFI_MAX_SEC_LEN];
569 char key[CSR_WIFI_MAX_KEY_LEN];
570 int ret = 0,tmp_var;
571 CsrWifiSmeApConfig_t *ap_config = &priv->ap_config;
572 CsrWifiSmeApMacConfig * ap_mac_config = &priv->ap_mac_config;
573 memset(sub_cmd, 0, sizeof(sub_cmd));
574 if(!strstr(param_str,"END")) {
575 unifi_error(priv,"store_ap_config_from_string:Invalid config string:%s\n",param_str);
576 return -1;
577 }
578 if (decode_parameter_from_string(priv,&str_ptr, "ASCII_CMD=",
579 PARAM_TYPE_STRING, sub_cmd, 6) != 0) {
580 return -1;
581 }
582 if (strncmp(sub_cmd, "AP_CFG", 6)) {
583
584 if(!strncmp(sub_cmd ,"ADVCFG", 6)) {
585 return store_ap_advanced_config_from_string(priv, str_ptr);
586 }
587 unifi_error(priv,"store_ap_config_from_string: sub_cmd:%s != 'AP_CFG or ADVCFG'!\n", sub_cmd);
588 return -1;
589 }
590 memset(ap_config, 0, sizeof(CsrWifiSmeApConfig_t));
591 ret = decode_parameter_from_string(priv,&str_ptr, "SSID=",
592 PARAM_TYPE_STRING, ap_config->ssid.ssid,
593 CSR_WIFI_MAX_SSID_LEN);
594 if(ret) {
595 unifi_error(priv,"store_ap_config_from_string: SSID not found\n");
596 return -1;
597 }
598 ap_config->ssid.length = strlen(ap_config->ssid.ssid);
599
600 ret = decode_parameter_from_string(priv, &str_ptr, "SEC=",
601 PARAM_TYPE_STRING, sec, CSR_WIFI_MAX_SEC_LEN);
602 if(ret) {
603 unifi_error(priv,"store_ap_config_from_string: SEC not found\n");
604 return -1;
605 }
606 ret = decode_parameter_from_string(priv,&str_ptr, "KEY=",
607 PARAM_TYPE_STRING, key, CSR_WIFI_MAX_KEY_LEN);
608 if(!strcasecmp(sec,"open")) {
609 unifi_trace(priv,UDBG2,"store_ap_config_from_string: security open");
610 ap_config->credentials.authType = CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM;
611 if(ret) {
612 unifi_notice(priv,"store_ap_config_from_string: KEY not found:fine with Open\n");
613 }
614 }
615 else if(!strcasecmp(sec,"wpa2-psk")) {
616 int i,j=0;
617 CsrWifiNmeApAuthPers *pers =
618 ((CsrWifiNmeApAuthPers *)&(ap_config->credentials.nmeAuthType.authTypePersonal));
619 u8 *psk = pers->authPers_credentials.psk.psk;
620
621 unifi_trace(priv,UDBG2,"store_ap_config_from_string: security WPA2");
622 if(ret) {
623 unifi_error(priv,"store_ap_config_from_string: KEY not found for WPA2\n");
624 return -1;
625 }
626 ap_config->credentials.authType = CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL;
627 pers->authSupport = CSR_WIFI_SME_RSN_AUTH_WPA2PSK;
628 pers->rsnCapabilities =0;
629 pers->wapiCapabilities =0;
630 pers->pskOrPassphrase=CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK;
631 pers->authPers_credentials.psk.encryptionMode =
632 (CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_CCMP |CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_CCMP) ;
633 for(i=0;i<32;i++){
634 psk[i] = (16*hex_look_up(key[j]))+hex_look_up(key[j+1]);
635 j+=2;
636 }
637
638 } else {
639 unifi_notice(priv,"store_ap_config_from_string: Unknown security: Assuming Open");
640 ap_config->credentials.authType = CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM;
641 return -1;
642 }
643
644
645 ret = decode_parameter_from_string(priv,&str_ptr, "CHANNEL=", PARAM_TYPE_INT, &tmp_var, 5);
646 if(ret)
647 return -1;
648 ap_config->channel = tmp_var;
649 ret = decode_parameter_from_string(priv,&str_ptr, "PREAMBLE=", PARAM_TYPE_INT, &tmp_var, 5);
650 if(ret)
651 return -1;
652 ap_mac_config->preamble = tmp_var;
653 ret = decode_parameter_from_string(priv,&str_ptr, "MAX_SCB=", PARAM_TYPE_INT, &tmp_var, 5);
654 ap_config->max_connections = tmp_var;
655 return ret;
656}
657
658static int
659iwprivsapstart(struct net_device *dev, struct iw_request_info *info,
660 union iwreq_data *wrqu, char *extra)
661{
662 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
663 unifi_priv_t *priv = interfacePriv->privPtr;
664 int r;
665
666 unifi_trace(priv, UDBG1, "iwprivsapstart\n" );
667 r = sme_ap_start(priv,interfacePriv->InterfaceTag,&priv->ap_config);
668 if(r) {
669 unifi_error(priv,"iwprivsapstart AP START failed : %d\n",-r);
670 }
671 return r;
672}
673
674static int
675iwprivsapconfig(struct net_device *dev, struct iw_request_info *info,
676 union iwreq_data *wrqu, char *extra)
677{
678 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
679 unifi_priv_t *priv = interfacePriv->privPtr;
680 char *cfg_str = NULL;
681 int r;
682
683 unifi_trace(priv, UDBG1, "iwprivsapconfig\n" );
684 if (wrqu->data.length != 0) {
685 char *str;
686 if (!(cfg_str = kmalloc(wrqu->data.length+1, GFP_KERNEL)))
687 {
688 return -ENOMEM;
689 }
690 if (copy_from_user(cfg_str, wrqu->data.pointer, wrqu->data.length)) {
691 kfree(cfg_str);
692 return -EFAULT;
693 }
694 cfg_str[wrqu->data.length] = 0;
695 unifi_trace(priv,UDBG2,"length:%d\n",wrqu->data.length);
696 unifi_trace(priv,UDBG2,"AP configuration string:%s\n",cfg_str);
697 str = cfg_str;
698 if ((r = store_ap_config_from_string(priv,str))) {
699 unifi_error(priv, "iwprivsapconfig:Failed to decode the string %d\n",r);
700 kfree(cfg_str);
701 return -EIO;
702
703 }
704 } else {
705 unifi_error(priv,"iwprivsapconfig argument length = 0 \n");
706 return -EIO;
707 }
708 r = sme_ap_config(priv, &priv->ap_mac_config, &priv->group_sec_config);
709 if(r) {
710 unifi_error(priv,"iwprivsapstop AP Config failed : %d\n",-r);
711 } else if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
712 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
713 unifi_trace(priv, UDBG1, "iwprivsapconfig: Starting the AP");
714 r = sme_ap_start(priv,interfacePriv->InterfaceTag,&priv->ap_config);
715 if(r) {
716 unifi_error(priv,"iwprivsapstart AP START failed : %d\n",-r);
717 }
718 }
719 kfree(cfg_str);
720 return r;
721}
722
723static int
724iwprivsapstop(struct net_device *dev, struct iw_request_info *info,
725 union iwreq_data *wrqu, char *extra)
726{
727 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
728 unifi_priv_t *priv = interfacePriv->privPtr;
729 int r;
730 u16 interface_tag = interfacePriv->InterfaceTag;
731
732 unifi_trace(priv, UDBG1, "iwprivsapstop\n" );
733 r = sme_ap_stop(priv,interface_tag);
734 if(r) {
735 unifi_error(priv,"iwprivsapstop AP STOP failed : %d\n",-r);
736 }
737 return r;
738}
739
740#ifdef ANDROID_BUILD
741static int
742iwprivsapfwreload(struct net_device *dev, struct iw_request_info *info,
743 union iwreq_data *wrqu, char *extra)
744{
745 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
746 unifi_priv_t *priv = interfacePriv->privPtr;
747
748 unifi_trace(priv, UDBG1, "iwprivsapfwreload\n" );
749 return 0;
750}
751
752static int
753iwprivsstackstart(struct net_device *dev, struct iw_request_info *info,
754 union iwreq_data *wrqu, char *extra)
755{
756 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
757 unifi_priv_t *priv = interfacePriv->privPtr;
758 unifi_trace(priv, UDBG1, "iwprivsstackstart\n" );
759 return 0;
760}
761
762static int
763iwprivsstackstop(struct net_device *dev, struct iw_request_info *info,
764 union iwreq_data *wrqu, char *extra)
765{
766 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
767 unifi_priv_t *priv = interfacePriv->privPtr;
768 int r = 0;
769 u16 interface_tag = interfacePriv->InterfaceTag;
770
771 unifi_trace(priv, UDBG1, "iwprivsstackstop\n" );
772
773 switch(interfacePriv->interfaceMode) {
774 case CSR_WIFI_ROUTER_CTRL_MODE_STA:
775 case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
776 case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
777 r = sme_mgt_disconnect(priv);
778 break;
779 case CSR_WIFI_ROUTER_CTRL_MODE_AP:
780 case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
781 r = sme_ap_stop(priv,interface_tag);
782 break;
783 default :
784 break;
785 }
786
787 if(r) {
788 unifi_error(priv,"iwprivsstackstop Stack stop failed : %d\n",-r);
789 }
790 return 0;
791}
792#endif
793#endif
794
795#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
796static int
797iwprivsconfwapi(struct net_device *dev, struct iw_request_info *info,
798 union iwreq_data *wrqu, char *extra)
799{
800 u8 enable;
801 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
802 unifi_priv_t *priv = interfacePriv->privPtr;
803
804 unifi_trace(priv, UDBG1, "iwprivsconfwapi\n" );
805
806 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
807 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
808 unifi_error(priv, "iwprivsconfwapi: not permitted in Mode %d\n",
809 interfacePriv->interfaceMode);
810 return -EPERM;
811 }
812
813 enable = *(u8*)(extra);
814
815 if (enable) {
816 priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
817 priv->connection_config.authModeMask |= (CSR_WIFI_SME_AUTH_MODE_WAPI_WAIPSK | CSR_WIFI_SME_AUTH_MODE_WAPI_WAI);
818 priv->connection_config.encryptionModeMask |=
819 CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_SMS4 | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_SMS4;
820 } else {
821 priv->connection_config.authModeMask &= ~(CSR_WIFI_SME_AUTH_MODE_WAPI_WAIPSK | CSR_WIFI_SME_AUTH_MODE_WAPI_WAI);
822 priv->connection_config.encryptionModeMask &=
823 ~(CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_SMS4 | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_SMS4);
824 }
825
826 return 0;
827}
828
829static int
830iwprivswpikey(struct net_device *dev, struct iw_request_info *info,
831 union iwreq_data *wrqu, char *extra)
832{
833 int r = 0, i;
834 CsrWifiSmeKey key;
835 unifiio_wapi_key_t inKey;
836 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
837 unifi_priv_t *priv = interfacePriv->privPtr;
838
839 unifi_trace(priv, UDBG1, "iwprivswpikey\n" );
840
841 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
842 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
843 unifi_error(priv, "iwprivswpikey: not permitted in Mode %d\n",
844 interfacePriv->interfaceMode);
845 return -EPERM;
846 }
847
848 inKey = *(unifiio_wapi_key_t*)(extra);
849
850 if (inKey.unicastKey) {
851 key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
852 } else {
853 key.keyType = CSR_WIFI_SME_KEY_TYPE_GROUP;
854 }
855
856 key.keyIndex = inKey.keyIndex;
857
858
859 for (i = 0; i < 16; i+= 2)
860 {
861 key.keyRsc[i/2] = inKey.keyRsc[i+1] << 8 | inKey.keyRsc[i];
862 }
863
864 memcpy(key.address.a, inKey.address, 6);
865 key.keyLength = 32;
866 memcpy(key.key, inKey.key, 32);
867 key.authenticator = 0;
868 key.wepTxKey = 0;
869
870 unifi_trace(priv, UDBG1, "keyType = %d, keyIndex = %d, wepTxKey = %d, keyRsc = %x:%x, auth = %d, address = %x:%x, "
871 "keylength = %d, key = %x:%x\n", key.keyType, key.keyIndex, key.wepTxKey,
872 key.keyRsc[0], key.keyRsc[7], key.authenticator,
873 key.address.a[0], key.address.a[5], key.keyLength, key.key[0],
874 key.key[15]);
875
876 r = sme_mgt_key(priv, &key, CSR_WIFI_SME_LIST_ACTION_ADD);
877 if (r) {
878 unifi_error(priv, "SETKEYS request was rejected with result %d\n", r);
879 return convert_sme_error(r);
880 }
881
882 return r;
883}
884#endif
885
886
887static int
888unifi_giwname(struct net_device *dev, struct iw_request_info *info,
889 union iwreq_data *wrqu, char *extra)
890{
891 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
892 unifi_priv_t *priv = interfacePriv->privPtr;
893 char *name = wrqu->name;
894 unifi_trace(priv, UDBG2, "unifi_giwname\n");
895
896 if (priv->if_index == CSR_INDEX_5G) {
897 strcpy(name, "IEEE 802.11-a");
898 } else {
899 strcpy(name, "IEEE 802.11-bgn");
900 }
901 return 0;
902}
903
904
905static int
906unifi_siwfreq(struct net_device *dev, struct iw_request_info *info,
907 union iwreq_data *wrqu, char *extra)
908{
909 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
910 unifi_priv_t *priv = interfacePriv->privPtr;
911 struct iw_freq *freq = (struct iw_freq *)wrqu;
912
913 unifi_trace(priv, UDBG2, "unifi_siwfreq\n");
914
915 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
916 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
917 unifi_error(priv, "unifi_siwfreq: not permitted in Mode %d\n",
918 interfacePriv->interfaceMode);
919 return -EPERM;
920 }
921
922
923
924
925
926
927 if ((freq->e == 0) && (freq->m <= 1000)) {
928 priv->connection_config.adhocChannel = freq->m;
929 } else {
930 priv->connection_config.adhocChannel = wext_freq_to_channel(freq->m, freq->e);
931 }
932
933 return 0;
934}
935
936
937static int
938unifi_giwfreq(struct net_device *dev, struct iw_request_info *info,
939 union iwreq_data *wrqu, char *extra)
940{
941 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
942 unifi_priv_t *priv = interfacePriv->privPtr;
943 struct iw_freq *freq = (struct iw_freq *)wrqu;
944 int err = 0;
945 CsrWifiSmeConnectionInfo connectionInfo;
946
947 unifi_trace(priv, UDBG2, "unifi_giwfreq\n");
948 CHECK_INITED(priv);
949
950 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
951 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
952 unifi_error(priv, "unifi_giwfreq: not permitted in Mode %d\n",
953 interfacePriv->interfaceMode);
954 return -EPERM;
955 }
956
957
958 UF_RTNL_UNLOCK();
959 err = sme_mgt_connection_info_get(priv, &connectionInfo);
960 UF_RTNL_LOCK();
961
962 freq->m = channel_to_mhz(connectionInfo.channelNumber,
963 (connectionInfo.networkType80211 == CSR_WIFI_SME_RADIO_IF_GHZ_5_0));
964 freq->e = 6;
965
966 return convert_sme_error(err);
967}
968
969
970static int
971unifi_siwmode(struct net_device *dev, struct iw_request_info *info,
972 union iwreq_data *wrqu, char *extra)
973{
974 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
975 unifi_priv_t *priv = interfacePriv->privPtr;
976
977 unifi_trace(priv, UDBG2, "unifi_siwmode\n");
978
979 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
980 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
981 unifi_error(priv, "unifi_siwmode: not permitted in Mode %d\n",
982 interfacePriv->interfaceMode);
983 return -EPERM;
984 }
985
986
987 switch(wrqu->mode) {
988 case IW_MODE_ADHOC:
989 priv->connection_config.bssType = CSR_WIFI_SME_BSS_TYPE_ADHOC;
990 break;
991 case IW_MODE_INFRA:
992 priv->connection_config.bssType = CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE;
993 break;
994 case IW_MODE_AUTO:
995 priv->connection_config.bssType = CSR_WIFI_SME_BSS_TYPE_ANY_BSS;
996 break;
997 default:
998 unifi_notice(priv, "Unknown IW MODE value.\n");
999 }
1000
1001
1002 priv->connection_config.ssid.length = 0;
1003 memset(priv->connection_config.bssid.a, 0xFF, ETH_ALEN);
1004
1005 return 0;
1006}
1007
1008
1009
1010static int
1011unifi_giwmode(struct net_device *dev, struct iw_request_info *info,
1012 union iwreq_data *wrqu, char *extra)
1013{
1014 int r = 0;
1015 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1016 unifi_priv_t *priv = interfacePriv->privPtr;
1017 CsrWifiSmeConnectionConfig connectionConfig;
1018
1019 unifi_trace(priv, UDBG2, "unifi_giwmode\n");
1020 CHECK_INITED(priv);
1021
1022 unifi_trace(priv, UDBG2, "unifi_giwmode: Exisitng mode = 0x%x\n",
1023 interfacePriv->interfaceMode);
1024 switch(interfacePriv->interfaceMode) {
1025 case CSR_WIFI_ROUTER_CTRL_MODE_STA:
1026 case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
1027 wrqu->mode = IW_MODE_INFRA;
1028 break;
1029 case CSR_WIFI_ROUTER_CTRL_MODE_AP:
1030 case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
1031 wrqu->mode = IW_MODE_MASTER;
1032 break;
1033 case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
1034 wrqu->mode = IW_MODE_ADHOC;
1035 break;
1036 case CSR_WIFI_ROUTER_CTRL_MODE_P2P:
1037 case CSR_WIFI_ROUTER_CTRL_MODE_NONE:
1038 UF_RTNL_UNLOCK();
1039 r = sme_mgt_connection_config_get(priv, &connectionConfig);
1040 UF_RTNL_LOCK();
1041 if (r == 0) {
1042 switch(connectionConfig.bssType) {
1043 case CSR_WIFI_SME_BSS_TYPE_ADHOC:
1044 wrqu->mode = IW_MODE_ADHOC;
1045 break;
1046 case CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE:
1047 wrqu->mode = IW_MODE_INFRA;
1048 break;
1049 default:
1050 wrqu->mode = IW_MODE_AUTO;
1051 unifi_notice(priv, "Unknown IW MODE value.\n");
1052 }
1053 }
1054 break;
1055 default:
1056 wrqu->mode = IW_MODE_AUTO;
1057 unifi_notice(priv, "Unknown IW MODE value.\n");
1058
1059 }
1060 unifi_trace(priv, UDBG4, "unifi_giwmode: mode = 0x%x\n", wrqu->mode);
1061 return r;
1062}
1063
1064
1065
1066static int
1067unifi_giwrange(struct net_device *dev, struct iw_request_info *info,
1068 union iwreq_data *wrqu, char *extra)
1069{
1070 struct iw_point *dwrq = &wrqu->data;
1071 struct iw_range *range = (struct iw_range *) extra;
1072 int i;
1073
1074 unifi_trace(NULL, UDBG2, "unifi_giwrange\n");
1075
1076 dwrq->length = sizeof(struct iw_range);
1077 memset(range, 0, sizeof(*range));
1078 range->min_nwid = 0x0000;
1079 range->max_nwid = 0x0000;
1080
1081
1082
1083
1084
1085
1086
1087 range->max_qual.qual = 40;
1088 range->max_qual.level = -120;
1089 range->max_qual.noise = -120;
1090
1091
1092
1093 i = 0;
1094#if WIRELESS_EXT > 15
1095 range->bitrate[i++] = 2 * 500000;
1096 range->bitrate[i++] = 4 * 500000;
1097 range->bitrate[i++] = 11 * 500000;
1098 range->bitrate[i++] = 22 * 500000;
1099 range->bitrate[i++] = 12 * 500000;
1100 range->bitrate[i++] = 18 * 500000;
1101 range->bitrate[i++] = 24 * 500000;
1102 range->bitrate[i++] = 36 * 500000;
1103 range->bitrate[i++] = 48 * 500000;
1104 range->bitrate[i++] = 72 * 500000;
1105 range->bitrate[i++] = 96 * 500000;
1106 range->bitrate[i++] = 108 * 500000;
1107#else
1108 range->bitrate[i++] = 2 * 500000;
1109 range->bitrate[i++] = 4 * 500000;
1110 range->bitrate[i++] = 11 * 500000;
1111 range->bitrate[i++] = 22 * 500000;
1112 range->bitrate[i++] = 24 * 500000;
1113 range->bitrate[i++] = 48 * 500000;
1114 range->bitrate[i++] = 96 * 500000;
1115 range->bitrate[i++] = 108 * 500000;
1116#endif
1117 range->num_bitrates = i;
1118
1119 range->max_encoding_tokens = NUM_WEPKEYS;
1120 range->num_encoding_sizes = 2;
1121 range->encoding_size[0] = 5;
1122 range->encoding_size[1] = 13;
1123
1124 range->we_version_source = 20;
1125 range->we_version_compiled = WIRELESS_EXT;
1126
1127
1128 range->num_channels = 14;
1129
1130 range->num_frequency = 14;
1131 for (i = 0; (i < range->num_frequency) && (i < IW_MAX_FREQUENCIES); i++) {
1132 int chan = i + 1;
1133 range->freq[i].i = chan;
1134 range->freq[i].m = channel_to_mhz(chan, 0);
1135 range->freq[i].e = 6;
1136 }
1137 if ((i+3) < IW_MAX_FREQUENCIES) {
1138 range->freq[i].i = 36;
1139 range->freq[i].m = channel_to_mhz(36, 1);
1140 range->freq[i].e = 6;
1141 range->freq[i+1].i = 40;
1142 range->freq[i+1].m = channel_to_mhz(40, 1);
1143 range->freq[i+1].e = 6;
1144 range->freq[i+2].i = 44;
1145 range->freq[i+2].m = channel_to_mhz(44, 1);
1146 range->freq[i+2].e = 6;
1147 range->freq[i+3].i = 48;
1148 range->freq[i+3].m = channel_to_mhz(48, 1);
1149 range->freq[i+3].e = 6;
1150 }
1151
1152#if WIRELESS_EXT > 16
1153
1154 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
1155 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
1156 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
1157 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
1158 range->event_capa[1] = IW_EVENT_CAPA_K_1;
1159 range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVTXDROP) |
1160 IW_EVENT_CAPA_MASK(IWEVCUSTOM) |
1161 IW_EVENT_CAPA_MASK(IWEVREGISTERED) |
1162 IW_EVENT_CAPA_MASK(IWEVEXPIRED));
1163#endif
1164
1165#if WIRELESS_EXT > 17
1166 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
1167 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
1168#endif
1169
1170
1171 return 0;
1172}
1173
1174
1175static int
1176unifi_siwap(struct net_device *dev, struct iw_request_info *info,
1177 union iwreq_data *wrqu, char *extra)
1178{
1179 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1180 unifi_priv_t *priv = interfacePriv->privPtr;
1181 int err = 0;
1182
1183 CHECK_INITED(priv);
1184
1185 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
1186 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
1187 unifi_error(priv, "unifi_siwap: not permitted in Mode %d\n",
1188 interfacePriv->interfaceMode);
1189 return -EPERM;
1190 }
1191
1192
1193 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER) {
1194 return -EINVAL;
1195 }
1196
1197 unifi_trace(priv, UDBG1, "unifi_siwap: asked for %pM\n",
1198 wrqu->ap_addr.sa_data);
1199
1200 if (is_zero_ether_addr(wrqu->ap_addr.sa_data)) {
1201 priv->ignore_bssid_join = FALSE;
1202 err = sme_mgt_disconnect(priv);
1203 if (err) {
1204 unifi_trace(priv, UDBG4, "unifi_siwap: Disconnect failed, status %d\n", err);
1205 }
1206 return 0;
1207 }
1208
1209 if (priv->ignore_bssid_join) {
1210 unifi_trace(priv, UDBG4, "unifi_siwap: ignoring second join\n");
1211 priv->ignore_bssid_join = FALSE;
1212 } else {
1213 memcpy(priv->connection_config.bssid.a, wrqu->ap_addr.sa_data, ETH_ALEN);
1214 unifi_trace(priv, UDBG1, "unifi_siwap: Joining %X:%X:%X:%X:%X:%X\n",
1215 priv->connection_config.bssid.a[0],
1216 priv->connection_config.bssid.a[1],
1217 priv->connection_config.bssid.a[2],
1218 priv->connection_config.bssid.a[3],
1219 priv->connection_config.bssid.a[4],
1220 priv->connection_config.bssid.a[5]);
1221 err = sme_mgt_connect(priv);
1222 if (err) {
1223 unifi_error(priv, "unifi_siwap: Join failed, status %d\n", err);
1224 return convert_sme_error(err);
1225 }
1226 }
1227
1228 return 0;
1229}
1230
1231
1232static int
1233unifi_giwap(struct net_device *dev, struct iw_request_info *info,
1234 union iwreq_data *wrqu, char *extra)
1235{
1236 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1237 unifi_priv_t *priv = interfacePriv->privPtr;
1238 CsrWifiSmeConnectionInfo connectionInfo;
1239 int r = 0;
1240 u8 *bssid;
1241
1242 CHECK_INITED(priv);
1243 unifi_trace(priv, UDBG2, "unifi_giwap\n");
1244
1245 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
1246 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
1247 unifi_error(priv, "iwprivswpikey: not permitted in Mode %d\n",
1248 interfacePriv->interfaceMode);
1249 return -EPERM;
1250 }
1251
1252 UF_RTNL_UNLOCK();
1253 r = sme_mgt_connection_info_get(priv, &connectionInfo);
1254 UF_RTNL_LOCK();
1255
1256 if (r == 0) {
1257 bssid = connectionInfo.bssid.a;
1258 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
1259 unifi_trace(priv, UDBG4, "unifi_giwap: BSSID = %pM\n", bssid);
1260
1261 memcpy(wrqu->ap_addr.sa_data, bssid, ETH_ALEN);
1262 } else {
1263 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
1264 }
1265
1266 return 0;
1267}
1268
1269
1270static int
1271unifi_siwscan(struct net_device *dev, struct iw_request_info *info,
1272 union iwreq_data *wrqu, char *extra)
1273{
1274 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1275 unifi_priv_t *priv = interfacePriv->privPtr;
1276 int r;
1277 CsrWifiSsid scan_ssid;
1278 unsigned char *channel_list = NULL;
1279 int chans_good = 0;
1280#if WIRELESS_EXT > 17
1281 struct iw_point *data = &wrqu->data;
1282 struct iw_scan_req *req = (struct iw_scan_req *) extra;
1283#endif
1284
1285 CHECK_INITED(priv);
1286
1287 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
1288 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
1289 unifi_error(priv, "unifi_siwscan: not permitted in Mode %d\n",
1290 interfacePriv->interfaceMode);
1291 return -EPERM;
1292 }
1293
1294
1295#if WIRELESS_EXT > 17
1296
1297 if (req) {
1298 if ((req->num_channels > 0) && (req->num_channels < IW_MAX_FREQUENCIES)) {
1299 channel_list = kmalloc(req->num_channels, GFP_KERNEL);
1300 if (channel_list) {
1301 int i;
1302 for (i = 0; i < req->num_channels; i++) {
1303
1304 int ch = wext_freq_to_channel(req->channel_list[i].m,
1305 req->channel_list[i].e);
1306 if (ch) {
1307 channel_list[chans_good++] = ch;
1308 }
1309 }
1310 unifi_trace(priv, UDBG1,
1311 "SIWSCAN: Scanning %d channels\n", chans_good);
1312 } else {
1313
1314 unifi_error(priv, "SIWSCAN: Can't alloc channel_list (%d)\n",
1315 req->num_channels);
1316 }
1317 }
1318 }
1319
1320 if (req && (data->flags & IW_SCAN_THIS_ESSID)) {
1321 memcpy(scan_ssid.ssid, req->essid, req->essid_len);
1322 scan_ssid.length = req->essid_len;
1323 unifi_trace(priv, UDBG1,
1324 "SIWSCAN: Scanning for %.*s\n",
1325 scan_ssid.length, scan_ssid.ssid);
1326 } else
1327#endif
1328 {
1329 unifi_trace(priv, UDBG1, "SIWSCAN: Scanning for all APs\n");
1330 scan_ssid.length = 0;
1331 }
1332
1333 r = sme_mgt_scan_full(priv, &scan_ssid, chans_good, channel_list);
1334 if (r) {
1335 unifi_error(priv, "SIWSCAN: Scan returned error %d\n", r);
1336 } else {
1337 unifi_trace(priv, UDBG1, "SIWSCAN: Scan done\n");
1338 wext_send_scan_results_event(priv);
1339 }
1340
1341 if (channel_list) {
1342 kfree(channel_list);
1343 }
1344
1345 return r;
1346
1347}
1348
1349
1350static const unsigned char *
1351unifi_find_info_element(int id, const unsigned char *info, int len)
1352{
1353 const unsigned char *ie = info;
1354
1355 while (len > 1)
1356 {
1357 int e_id, e_len;
1358 e_id = ie[0];
1359 e_len = ie[1];
1360
1361
1362 if (e_id == id)
1363 {
1364 return ie;
1365 }
1366
1367 len -= (e_len + 2);
1368 ie += (e_len + 2);
1369 }
1370
1371 return NULL;
1372}
1373
1374
1375
1376
1377
1378
1379int
1380unifi_translate_scan(struct net_device *dev,
1381 struct iw_request_info *info,
1382 char *current_ev, char *end_buf,
1383 CsrWifiSmeScanResult *scan_data,
1384 int scan_index)
1385{
1386 struct iw_event iwe;
1387 unsigned char *info_elems;
1388 int info_elem_len;
1389 const unsigned char *elem;
1390 u16 capabilities;
1391 int signal, noise, snr;
1392 char *start_buf = current_ev;
1393 char *current_val;
1394 int i, r;
1395
1396 info_elems = scan_data->informationElements;
1397 info_elem_len = scan_data->informationElementsLength;
1398
1399 if (!scan_data->informationElementsLength || !scan_data->informationElements) {
1400 unifi_error(NULL, "*** NULL SCAN IEs ***\n");
1401 return -EIO;
1402 }
1403
1404
1405 capabilities = scan_data->capabilityInformation;
1406
1407 unifi_trace(NULL, UDBG5, "Capabilities: 0x%x\n", capabilities);
1408
1409
1410 memset(&iwe, 0, sizeof(iwe));
1411 iwe.cmd = SIOCGIWAP;
1412 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1413 memcpy(iwe.u.ap_addr.sa_data, scan_data->bssid.a, ETH_ALEN);
1414 iwe.len = IW_EV_ADDR_LEN;
1415 r = uf_iwe_stream_add_event(info, start_buf, end_buf, &iwe, IW_EV_ADDR_LEN);
1416 if (r < 0) {
1417 return r;
1418 }
1419 start_buf += r;
1420
1421
1422
1423
1424
1425 elem = unifi_find_info_element(IE_SSID_ID, info_elems, info_elem_len);
1426 if (elem) {
1427 int e_len = elem[1];
1428 const unsigned char *e_ptr = elem + 2;
1429 unsigned char buf[33];
1430
1431 memset(&iwe, 0, sizeof(iwe));
1432 iwe.cmd = SIOCGIWESSID;
1433 iwe.u.essid.length = e_len;
1434 if (iwe.u.essid.length > 32) {
1435 iwe.u.essid.length = 32;
1436 }
1437 iwe.u.essid.flags = scan_index;
1438 memcpy(buf, e_ptr, iwe.u.essid.length);
1439 buf[iwe.u.essid.length] = '\0';
1440 r = uf_iwe_stream_add_point(info, start_buf, end_buf, &iwe, buf);
1441 if (r < 0) {
1442 return r;
1443 }
1444 start_buf += r;
1445
1446 }
1447
1448
1449 memset(&iwe, 0, sizeof(iwe));
1450 iwe.cmd = SIOCGIWMODE;
1451 if (scan_data->bssType == CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE) {
1452 iwe.u.mode = IW_MODE_INFRA;
1453 } else {
1454 iwe.u.mode = IW_MODE_ADHOC;
1455 }
1456 iwe.len = IW_EV_UINT_LEN;
1457 r = uf_iwe_stream_add_event(info, start_buf, end_buf, &iwe, IW_EV_UINT_LEN);
1458 if (r < 0) {
1459 return r;
1460 }
1461 start_buf += r;
1462
1463
1464 memset(&iwe, 0, sizeof(iwe));
1465 iwe.cmd = SIOCGIWFREQ;
1466 iwe.u.freq.m = scan_data->channelFrequency;
1467 iwe.u.freq.e = 6;
1468 r = uf_iwe_stream_add_event(info, start_buf, end_buf, &iwe, IW_EV_FREQ_LEN);
1469 if (r < 0) {
1470 return r;
1471 }
1472 start_buf += r;
1473
1474
1475
1476 iwe.cmd = IWEVQUAL;
1477
1478
1479
1480
1481
1482
1483 signal = scan_data->rssi;
1484
1485 snr = (scan_data->snr > 0) ? scan_data->snr : 0;
1486 snr = (snr < 255) ? snr : 255;
1487 noise = signal - snr;
1488
1489
1490 signal = (signal < 63) ? signal : 63;
1491 signal = (signal > -192) ? signal : -192;
1492
1493
1494 noise = (noise < 63) ? noise : 63;
1495 noise = (noise > -192) ? noise : -192;
1496
1497
1498 signal = ( signal < 0 ) ? signal + 0x100 : signal;
1499 noise = ( noise < 0 ) ? noise + 0x100 : noise;
1500
1501 iwe.u.qual.level = (u8)signal;
1502 iwe.u.qual.noise = (u8)noise;
1503 iwe.u.qual.qual = snr;
1504 iwe.u.qual.updated = 0;
1505#if WIRELESS_EXT > 16
1506 iwe.u.qual.updated |= IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_UPDATED |
1507 IW_QUAL_QUAL_UPDATED;
1508#if WIRELESS_EXT > 18
1509 iwe.u.qual.updated |= IW_QUAL_DBM;
1510#endif
1511#endif
1512 r = uf_iwe_stream_add_event(info, start_buf, end_buf, &iwe, IW_EV_QUAL_LEN);
1513 if (r < 0) {
1514 return r;
1515 }
1516 start_buf += r;
1517
1518
1519 iwe.cmd = SIOCGIWENCODE;
1520 if (capabilities & SIG_CAP_PRIVACY) {
1521 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1522 } else {
1523 iwe.u.data.flags = IW_ENCODE_DISABLED;
1524 }
1525 iwe.u.data.length = 0;
1526 iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
1527 r = uf_iwe_stream_add_point(info, start_buf, end_buf, &iwe, "");
1528 if (r < 0) {
1529 return r;
1530 }
1531 start_buf += r;
1532
1533
1534
1535
1536
1537
1538 current_val = start_buf + IW_EV_LCP_LEN;
1539
1540 iwe.cmd = SIOCGIWRATE;
1541
1542 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
1543
1544 elem = unifi_find_info_element(IE_SUPPORTED_RATES_ID,
1545 info_elems, info_elem_len);
1546 if (elem) {
1547 int e_len = elem[1];
1548 const unsigned char *e_ptr = elem + 2;
1549
1550
1551
1552
1553
1554
1555 for (i = 0; i < e_len; i++) {
1556 if (e_ptr[i] == 0) {
1557 break;
1558 }
1559
1560 iwe.u.bitrate.value = ((e_ptr[i] & 0x7f) * 500000);
1561
1562 r = uf_iwe_stream_add_value(info, start_buf, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
1563 if (r < 0) {
1564 return r;
1565 }
1566 current_val +=r;
1567
1568 }
1569 }
1570 elem = unifi_find_info_element(IE_EXTENDED_SUPPORTED_RATES_ID,
1571 info_elems, info_elem_len);
1572 if (elem) {
1573 int e_len = elem[1];
1574 const unsigned char *e_ptr = elem + 2;
1575
1576
1577
1578
1579
1580
1581 for (i = 0; i < e_len; i++) {
1582 if (e_ptr[i] == 0) {
1583 break;
1584 }
1585
1586 iwe.u.bitrate.value = ((e_ptr[i] & 0x7f) * 500000);
1587
1588 r = uf_iwe_stream_add_value(info, start_buf, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
1589 if (r < 0) {
1590 return r;
1591 }
1592 current_val +=r;
1593 }
1594 }
1595
1596 if ((current_val - start_buf) > IW_EV_LCP_LEN) {
1597 start_buf = current_val;
1598 }
1599
1600
1601#if WIRELESS_EXT > 17
1602 memset(&iwe, 0, sizeof(iwe));
1603 iwe.cmd = IWEVGENIE;
1604 iwe.u.data.length = info_elem_len;
1605
1606 r = uf_iwe_stream_add_point(info, start_buf, end_buf, &iwe, info_elems);
1607 if (r < 0) {
1608 return r;
1609 }
1610
1611 start_buf += r;
1612#endif
1613
1614 return (start_buf - current_ev);
1615}
1616
1617
1618
1619static int
1620unifi_giwscan(struct net_device *dev, struct iw_request_info *info,
1621 union iwreq_data *wrqu, char *extra)
1622{
1623 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1624 unifi_priv_t *priv = interfacePriv->privPtr;
1625 struct iw_point *dwrq = &wrqu->data;
1626 int r;
1627
1628 CHECK_INITED(priv);
1629
1630 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
1631 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
1632 unifi_error(priv, "unifi_giwscan: not permitted in Mode %d\n",
1633 interfacePriv->interfaceMode);
1634 return -EPERM;
1635 }
1636
1637
1638 unifi_trace(priv, UDBG1,
1639 "unifi_giwscan: buffer (%d bytes) \n",
1640 dwrq->length);
1641 UF_RTNL_UNLOCK();
1642 r = sme_mgt_scan_results_get_async(priv, info, extra, dwrq->length);
1643 UF_RTNL_LOCK();
1644 if (r < 0) {
1645 unifi_trace(priv, UDBG1,
1646 "unifi_giwscan: buffer (%d bytes) not big enough.\n",
1647 dwrq->length);
1648 return r;
1649 }
1650
1651 dwrq->length = r;
1652 dwrq->flags = 0;
1653
1654 return 0;
1655}
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676static int
1677unifi_siwessid(struct net_device *dev, struct iw_request_info *info,
1678 struct iw_point *data, char *essid)
1679{
1680 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1681 unifi_priv_t *priv = interfacePriv->privPtr;
1682 int len;
1683 int err = 0;
1684
1685 CHECK_INITED(priv);
1686
1687 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
1688 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
1689 unifi_error(priv, "unifi_siwessid: not permitted in Mode %d\n",
1690 interfacePriv->interfaceMode);
1691 return -EPERM;
1692 }
1693
1694
1695 len = 0;
1696 if (data->flags & 1) {
1697
1698 len = data->length;
1699 if (len > UNIFI_MAX_SSID_LEN) {
1700 len = UNIFI_MAX_SSID_LEN;
1701 }
1702 }
1703
1704#ifdef UNIFI_DEBUG
1705 {
1706 char essid_str[UNIFI_MAX_SSID_LEN+1];
1707 int i;
1708
1709 for (i = 0; i < len; i++) {
1710 essid_str[i] = (isprint(essid[i]) ? essid[i] : '?');
1711 }
1712 essid_str[i] = '\0';
1713
1714 unifi_trace(priv, UDBG1, "unifi_siwessid: asked for '%*s' (%d)\n", len, essid_str, len);
1715 unifi_trace(priv, UDBG2, " with authModeMask = %d", priv->connection_config.authModeMask);
1716 }
1717#endif
1718
1719 memset(priv->connection_config.bssid.a, 0xFF, ETH_ALEN);
1720 if (len) {
1721 if (essid[len - 1] == 0) {
1722 len --;
1723 }
1724
1725 memcpy(priv->connection_config.ssid.ssid, essid, len);
1726 priv->connection_config.ssid.length = len;
1727
1728 } else {
1729 priv->connection_config.ssid.length = 0;
1730 }
1731
1732 UF_RTNL_UNLOCK();
1733 err = sme_mgt_connect(priv);
1734 UF_RTNL_LOCK();
1735 if (err) {
1736 unifi_error(priv, "unifi_siwessid: Join failed, status %d\n", err);
1737 return convert_sme_error(err);
1738 }
1739
1740 return 0;
1741}
1742
1743
1744static int
1745unifi_giwessid(struct net_device *dev, struct iw_request_info *info,
1746 union iwreq_data *wrqu, char *essid)
1747{
1748 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1749 unifi_priv_t *priv = interfacePriv->privPtr;
1750 struct iw_point *data = &wrqu->essid;
1751 CsrWifiSmeConnectionInfo connectionInfo;
1752 int r = 0;
1753
1754 unifi_trace(priv, UDBG2, "unifi_giwessid\n");
1755 CHECK_INITED(priv);
1756
1757 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
1758 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
1759 unifi_error(priv, "unifi_giwessid: not permitted in Mode %d\n",
1760 interfacePriv->interfaceMode);
1761 return -EPERM;
1762 }
1763
1764 UF_RTNL_UNLOCK();
1765 r = sme_mgt_connection_info_get(priv, &connectionInfo);
1766 UF_RTNL_LOCK();
1767
1768 if (r == 0) {
1769 data->length = connectionInfo.ssid.length;
1770 strncpy(essid,
1771 connectionInfo.ssid.ssid,
1772 data->length);
1773 data->flags = 1;
1774
1775 unifi_trace(priv, UDBG2, "unifi_giwessid: %.*s\n",
1776 data->length, essid);
1777 }
1778
1779
1780 return 0;
1781}
1782
1783
1784static int
1785unifi_siwrate(struct net_device *dev, struct iw_request_info *info,
1786 union iwreq_data *wrqu, char *extra)
1787{
1788 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1789 unifi_priv_t *priv = interfacePriv->privPtr;
1790 struct iw_param *args = &wrqu->bitrate;
1791 CsrWifiSmeMibConfig mibConfig;
1792 int r;
1793
1794 CHECK_INITED(priv);
1795 unifi_trace(priv, UDBG2, "unifi_siwrate\n");
1796
1797
1798
1799
1800
1801
1802
1803
1804 UF_RTNL_UNLOCK();
1805 r = sme_mgt_mib_config_get(priv, &mibConfig);
1806 UF_RTNL_LOCK();
1807 if (r) {
1808 unifi_error(priv, "unifi_siwrate: Get CsrWifiSmeMibConfigValue failed.\n");
1809 return r;
1810 }
1811
1812
1813
1814 mibConfig.unifiFixTxDataRate = 0;
1815
1816 if (args->value != -1) {
1817 mibConfig.unifiFixTxDataRate = args->value / 500000;
1818 }
1819
1820
1821 if (args->fixed == 1) {
1822 mibConfig.unifiFixMaxTxDataRate = 0;
1823 } else {
1824 mibConfig.unifiFixMaxTxDataRate = 1;
1825 }
1826 UF_RTNL_UNLOCK();
1827 r = sme_mgt_mib_config_set(priv, &mibConfig);
1828 UF_RTNL_LOCK();
1829 if (r) {
1830 unifi_error(priv, "unifi_siwrate: Set CsrWifiSmeMibConfigValue failed.\n");
1831 return r;
1832 }
1833
1834
1835 return 0;
1836}
1837
1838
1839
1840static int
1841unifi_giwrate(struct net_device *dev, struct iw_request_info *info,
1842 union iwreq_data *wrqu, char *extra)
1843{
1844 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1845 unifi_priv_t *priv = interfacePriv->privPtr;
1846 struct iw_param *args = &wrqu->bitrate;
1847 int r;
1848 int bitrate, flag;
1849 CsrWifiSmeMibConfig mibConfig;
1850 CsrWifiSmeConnectionStats connectionStats;
1851
1852 unifi_trace(priv, UDBG2, "unifi_giwrate\n");
1853 CHECK_INITED(priv);
1854
1855 flag = 0;
1856 bitrate = 0;
1857 UF_RTNL_UNLOCK();
1858 r = sme_mgt_mib_config_get(priv, &mibConfig);
1859 UF_RTNL_LOCK();
1860 if (r) {
1861 unifi_error(priv, "unifi_giwrate: Get CsrWifiSmeMibConfigValue failed.\n");
1862 return r;
1863 }
1864
1865 bitrate = mibConfig.unifiFixTxDataRate;
1866 flag = mibConfig.unifiFixMaxTxDataRate;
1867
1868
1869 if (bitrate == 0) {
1870 UF_RTNL_UNLOCK();
1871 r = sme_mgt_connection_stats_get(priv, &connectionStats);
1872 UF_RTNL_LOCK();
1873
1874 if (r == 0) {
1875 bitrate = connectionStats.unifiTxDataRate;
1876 }
1877 }
1878
1879 args->value = bitrate * 500000;
1880 args->fixed = !flag;
1881
1882 return 0;
1883}
1884
1885
1886static int
1887unifi_siwrts(struct net_device *dev, struct iw_request_info *info,
1888 union iwreq_data *wrqu, char *extra)
1889{
1890 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1891 unifi_priv_t *priv = interfacePriv->privPtr;
1892 int val = wrqu->rts.value;
1893 int r = 0;
1894 CsrWifiSmeMibConfig mibConfig;
1895
1896 unifi_trace(priv, UDBG2, "unifi_siwrts\n");
1897 CHECK_INITED(priv);
1898
1899 if (wrqu->rts.disabled) {
1900 val = 2347;
1901 }
1902
1903 if ( (val < 0) || (val > 2347) )
1904 {
1905 return -EINVAL;
1906 }
1907
1908
1909 UF_RTNL_UNLOCK();
1910 r = sme_mgt_mib_config_get(priv, &mibConfig);
1911 UF_RTNL_LOCK();
1912 if (r) {
1913 unifi_error(priv, "unifi_siwrts: Get CsrWifiSmeMibConfigValue failed.\n");
1914 return r;
1915 }
1916 mibConfig.dot11RtsThreshold = val;
1917 UF_RTNL_UNLOCK();
1918 r = sme_mgt_mib_config_set(priv, &mibConfig);
1919 UF_RTNL_LOCK();
1920 if (r) {
1921 unifi_error(priv, "unifi_siwrts: Set CsrWifiSmeMibConfigValue failed.\n");
1922 return r;
1923 }
1924
1925 return 0;
1926}
1927
1928
1929static int
1930unifi_giwrts(struct net_device *dev, struct iw_request_info *info,
1931 union iwreq_data *wrqu, char *extra)
1932{
1933 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1934 unifi_priv_t *priv = interfacePriv->privPtr;
1935 int r;
1936 int rts_thresh;
1937 CsrWifiSmeMibConfig mibConfig;
1938
1939 unifi_trace(priv, UDBG2, "unifi_giwrts\n");
1940 CHECK_INITED(priv);
1941
1942 UF_RTNL_UNLOCK();
1943 r = sme_mgt_mib_config_get(priv, &mibConfig);
1944 UF_RTNL_LOCK();
1945 if (r) {
1946 unifi_error(priv, "unifi_giwrts: Get CsrWifiSmeMibConfigValue failed.\n");
1947 return r;
1948 }
1949
1950 rts_thresh = mibConfig.dot11RtsThreshold;
1951 if (rts_thresh > 2347) {
1952 rts_thresh = 2347;
1953 }
1954
1955 wrqu->rts.value = rts_thresh;
1956 wrqu->rts.disabled = (rts_thresh == 2347);
1957 wrqu->rts.fixed = 1;
1958
1959 return 0;
1960}
1961
1962
1963static int
1964unifi_siwfrag(struct net_device *dev, struct iw_request_info *info,
1965 union iwreq_data *wrqu, char *extra)
1966{
1967 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
1968 unifi_priv_t *priv = interfacePriv->privPtr;
1969 int val = wrqu->frag.value;
1970 int r = 0;
1971 CsrWifiSmeMibConfig mibConfig;
1972
1973 unifi_trace(priv, UDBG2, "unifi_siwfrag\n");
1974 CHECK_INITED(priv);
1975
1976 if (wrqu->frag.disabled)
1977 val = 2346;
1978
1979 if ( (val < 256) || (val > 2347) )
1980 return -EINVAL;
1981
1982
1983 UF_RTNL_UNLOCK();
1984 r = sme_mgt_mib_config_get(priv, &mibConfig);
1985 UF_RTNL_LOCK();
1986 if (r) {
1987 unifi_error(priv, "unifi_siwfrag: Get CsrWifiSmeMibConfigValue failed.\n");
1988 return r;
1989 }
1990
1991 mibConfig.dot11FragmentationThreshold = (val & ~0x1);
1992 UF_RTNL_UNLOCK();
1993 r = sme_mgt_mib_config_set(priv, &mibConfig);
1994 UF_RTNL_LOCK();
1995 if (r) {
1996 unifi_error(priv, "unifi_siwfrag: Set CsrWifiSmeMibConfigValue failed.\n");
1997 return r;
1998 }
1999
2000 return 0;
2001}
2002
2003
2004static int
2005unifi_giwfrag(struct net_device *dev, struct iw_request_info *info,
2006 union iwreq_data *wrqu, char *extra)
2007{
2008 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2009 unifi_priv_t *priv = interfacePriv->privPtr;
2010 int r;
2011 int frag_thresh;
2012 CsrWifiSmeMibConfig mibConfig;
2013
2014 unifi_trace(priv, UDBG2, "unifi_giwfrag\n");
2015 CHECK_INITED(priv);
2016
2017 UF_RTNL_UNLOCK();
2018 r = sme_mgt_mib_config_get(priv, &mibConfig);
2019 UF_RTNL_LOCK();
2020 if (r) {
2021 unifi_error(priv, "unifi_giwfrag: Get CsrWifiSmeMibConfigValue failed.\n");
2022 return r;
2023 }
2024
2025 frag_thresh = mibConfig.dot11FragmentationThreshold;
2026
2027
2028 wrqu->frag.value = frag_thresh;
2029 wrqu->frag.disabled = (frag_thresh >= 2346);
2030 wrqu->frag.fixed = 1;
2031
2032 return 0;
2033}
2034
2035
2036static int
2037unifi_siwencode(struct net_device *dev, struct iw_request_info *info,
2038 union iwreq_data *wrqu, char *extra)
2039{
2040 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2041 unifi_priv_t *priv = interfacePriv->privPtr;
2042 struct iw_point *erq = &wrqu->encoding;
2043 int index;
2044 int rc = 0;
2045 int privacy = -1;
2046 CsrWifiSmeKey sme_key;
2047
2048 unifi_trace(priv, UDBG2, "unifi_siwencode\n");
2049
2050 CHECK_INITED(priv);
2051
2052 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
2053 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
2054 unifi_error(priv, "unifi_siwencode: not permitted in Mode %d\n",
2055 interfacePriv->interfaceMode);
2056 return -EPERM;
2057 }
2058
2059
2060
2061
2062
2063
2064
2065
2066 index = (erq->flags & IW_ENCODE_INDEX);
2067 if ((index < 0) || (index > 4)) {
2068 unifi_error(priv, "unifi_siwencode: Request to set an invalid key (index:%d)", index);
2069 return -EINVAL;
2070 }
2071
2072
2073
2074
2075
2076
2077 if (erq->length > 0) {
2078
2079
2080 if ((erq->length > LARGE_KEY_SIZE) || (erq->length < SMALL_KEY_SIZE)) {
2081 unifi_error(priv, "unifi_siwencode: Request to set an invalid key (length:%d)",
2082 erq->length);
2083 return -EINVAL;
2084 }
2085
2086
2087 if ((index < 1) || (index > 4)) {
2088
2089 if (!priv->wep_tx_key_index) {
2090 priv->wep_tx_key_index = 1;
2091 }
2092 index = priv->wep_tx_key_index;
2093 }
2094
2095
2096 if (!priv->wep_tx_key_index) {
2097 priv->wep_tx_key_index = index;
2098 }
2099
2100 unifi_trace(priv, UDBG1, "Tx key Index is %d\n", priv->wep_tx_key_index);
2101
2102 privacy = 1;
2103
2104
2105 if ((erq->flags & IW_ENCODE_NOKEY) == 0) {
2106
2107 unifi_trace(priv, UDBG1, "New %s key (len=%d, index=%d)\n",
2108 (priv->wep_tx_key_index == index) ? "tx" : "",
2109 erq->length, index);
2110
2111 sme_key.wepTxKey = (priv->wep_tx_key_index == index);
2112 if (priv->wep_tx_key_index == index) {
2113 sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
2114 } else {
2115 sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_GROUP;
2116 }
2117
2118 sme_key.keyIndex = (index - 1);
2119 sme_key.keyLength = erq->length;
2120 sme_key.authenticator = 0;
2121 memset(sme_key.address.a, 0xFF, ETH_ALEN);
2122 memcpy(sme_key.key, extra, erq->length);
2123
2124 UF_RTNL_UNLOCK();
2125 rc = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_ADD);
2126 UF_RTNL_LOCK();
2127 if (rc) {
2128 unifi_error(priv, "unifi_siwencode: Set key failed (%d)", rc);
2129 return convert_sme_error(rc);
2130 }
2131
2132
2133 priv->wep_keys[index - 1].len = erq->length;
2134 memcpy(priv->wep_keys[index - 1].key, extra, erq->length);
2135 }
2136 } else {
2137
2138
2139
2140
2141 if (index != 0) {
2142 unifi_trace(priv, UDBG1, "Tx key Index is %d\n", index - 1);
2143
2144
2145 priv->wep_tx_key_index = index;
2146
2147 sme_key.wepTxKey = 1;
2148 sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
2149
2150
2151 sme_key.keyIndex = (index - 1);
2152 sme_key.keyLength = 0;
2153 sme_key.authenticator = 0;
2154 UF_RTNL_UNLOCK();
2155 rc = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_ADD);
2156 UF_RTNL_LOCK();
2157 if (rc) {
2158 unifi_error(priv, "unifi_siwencode: Set key failed (%d)", rc);
2159 return convert_sme_error(rc);
2160 }
2161
2162
2163 privacy = 1;
2164 }
2165 }
2166
2167
2168 if (erq->flags & IW_ENCODE_DISABLED) {
2169
2170 unifi_trace(priv, UDBG1, "disable WEP encryption\n");
2171 privacy = 0;
2172
2173 priv->wep_tx_key_index = 0;
2174
2175 unifi_trace(priv, UDBG1, "IW_ENCODE_DISABLED: CSR_WIFI_SME_AUTH_MODE_80211_OPEN\n");
2176 priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
2177 }
2178
2179 if (erq->flags & IW_ENCODE_RESTRICTED) {
2180
2181 unifi_trace(priv, UDBG1, "IW_ENCODE_RESTRICTED: CSR_WIFI_SME_AUTH_MODE_80211_SHARED\n");
2182 priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_SHARED;
2183
2184
2185 privacy = 1;
2186 }
2187 if (erq->flags & IW_ENCODE_OPEN) {
2188 unifi_trace(priv, UDBG1, "IW_ENCODE_OPEN: CSR_WIFI_SME_AUTH_MODE_80211_OPEN\n");
2189 priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
2190 }
2191
2192
2193 if (privacy != -1) {
2194 priv->connection_config.privacyMode = privacy ? CSR_WIFI_SME_80211_PRIVACY_MODE_ENABLED : CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED;
2195 priv->connection_config.encryptionModeMask = privacy ? (CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP40 |
2196 CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP104 |
2197 CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40 |
2198 CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104) :
2199 CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE;
2200 }
2201
2202 return convert_sme_error(rc);
2203
2204}
2205
2206
2207
2208static int
2209unifi_giwencode(struct net_device *dev, struct iw_request_info *info,
2210 union iwreq_data *wrqu, char *extra)
2211{
2212 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2213 unifi_priv_t *priv = interfacePriv->privPtr;
2214 struct iw_point *erq = &wrqu->encoding;
2215
2216 unifi_trace(priv, UDBG2, "unifi_giwencode\n");
2217
2218 CHECK_INITED(priv);
2219
2220 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
2221 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
2222 unifi_error(priv, "unifi_giwencode: not permitted in Mode %d\n",
2223 interfacePriv->interfaceMode);
2224 return -EPERM;
2225 }
2226
2227
2228 if (priv->connection_config.authModeMask == CSR_WIFI_SME_AUTH_MODE_80211_SHARED) {
2229 erq->flags = IW_ENCODE_RESTRICTED;
2230 }
2231 else {
2232 if (priv->connection_config.privacyMode == CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED) {
2233 erq->flags = IW_ENCODE_DISABLED;
2234 } else {
2235 erq->flags = IW_ENCODE_OPEN;
2236 }
2237 }
2238
2239 erq->length = 0;
2240
2241 if (erq->flags != IW_ENCODE_DISABLED) {
2242 int index = priv->wep_tx_key_index;
2243
2244 if ((index > 0) && (index <= NUM_WEPKEYS)) {
2245 erq->flags |= (index & IW_ENCODE_INDEX);
2246 erq->length = priv->wep_keys[index - 1].len;
2247 memcpy(extra, priv->wep_keys[index - 1].key, erq->length);
2248 } else {
2249 unifi_notice(priv, "unifi_giwencode: Surprise, do not have a valid key index (%d)\n",
2250 index);
2251 }
2252 }
2253
2254 return 0;
2255}
2256
2257
2258static int
2259unifi_siwpower(struct net_device *dev, struct iw_request_info *info,
2260 union iwreq_data *wrqu, char *extra)
2261{
2262 struct iw_param *args = &wrqu->power;
2263 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2264 unifi_priv_t *priv = interfacePriv->privPtr;
2265 int listen_interval, wake_for_dtim;
2266 int r = 0;
2267 CsrWifiSmePowerConfig powerConfig;
2268
2269 unifi_trace(priv, UDBG2, "unifi_siwpower\n");
2270
2271 CHECK_INITED(priv);
2272
2273 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
2274 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
2275 unifi_error(priv, "unifi_siwpower: not permitted in Mode %d\n",
2276 interfacePriv->interfaceMode);
2277 return -EPERM;
2278 }
2279
2280 UF_RTNL_UNLOCK();
2281 r = sme_mgt_power_config_get(priv, &powerConfig);
2282 UF_RTNL_LOCK();
2283 if (r) {
2284 unifi_error(priv, "unifi_siwpower: Get unifi_PowerConfigValue failed.\n");
2285 return r;
2286 }
2287
2288 listen_interval = -1;
2289 wake_for_dtim = -1;
2290 if (args->disabled) {
2291 powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW;
2292 }
2293 else
2294 {
2295 powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH;
2296
2297 switch (args->flags & IW_POWER_TYPE) {
2298 case 0:
2299
2300 break;
2301 case IW_POWER_PERIOD:
2302 listen_interval = args->value / 1000;
2303 break;
2304 default:
2305 return -EINVAL;
2306 }
2307
2308 switch (args->flags & IW_POWER_MODE) {
2309 case 0:
2310
2311 break;
2312 case IW_POWER_UNICAST_R:
2313
2314 wake_for_dtim = 0;
2315 break;
2316 case IW_POWER_ALL_R:
2317
2318 wake_for_dtim = 1;
2319 break;
2320 default:
2321 return -EINVAL;
2322 }
2323 }
2324
2325 if (listen_interval > 0) {
2326 powerConfig.listenIntervalTu = listen_interval;
2327 unifi_trace(priv, UDBG4, "unifi_siwpower: new Listen Interval = %d.\n",
2328 powerConfig.listenIntervalTu);
2329 }
2330
2331 if (wake_for_dtim >= 0) {
2332 powerConfig.rxDtims = wake_for_dtim;
2333 }
2334 UF_RTNL_UNLOCK();
2335 r = sme_mgt_power_config_set(priv, &powerConfig);
2336 UF_RTNL_LOCK();
2337 if (r) {
2338 unifi_error(priv, "unifi_siwpower: Set unifi_PowerConfigValue failed.\n");
2339 return r;
2340 }
2341
2342 return 0;
2343}
2344
2345
2346static int
2347unifi_giwpower(struct net_device *dev, struct iw_request_info *info,
2348 union iwreq_data *wrqu, char *extra)
2349{
2350 struct iw_param *args = &wrqu->power;
2351 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2352 unifi_priv_t *priv = interfacePriv->privPtr;
2353 CsrWifiSmePowerConfig powerConfig;
2354 int r;
2355
2356 unifi_trace(priv, UDBG2, "unifi_giwpower\n");
2357
2358 CHECK_INITED(priv);
2359
2360 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
2361 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
2362 unifi_error(priv, "unifi_giwpower: not permitted in Mode %d\n",
2363 interfacePriv->interfaceMode);
2364 return -EPERM;
2365 }
2366
2367
2368 args->flags = 0;
2369 UF_RTNL_UNLOCK();
2370 r = sme_mgt_power_config_get(priv, &powerConfig);
2371 UF_RTNL_LOCK();
2372 if (r) {
2373 unifi_error(priv, "unifi_giwpower: Get unifi_PowerConfigValue failed.\n");
2374 return r;
2375 }
2376
2377 unifi_trace(priv, UDBG4, "unifi_giwpower: mode=%d\n",
2378 powerConfig.powerSaveLevel);
2379
2380 args->disabled = (powerConfig.powerSaveLevel == CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW);
2381 if (args->disabled) {
2382 args->flags = 0;
2383 return 0;
2384 }
2385
2386 args->value = powerConfig.listenIntervalTu * 1000;
2387 args->flags |= IW_POWER_PERIOD;
2388
2389 if (powerConfig.rxDtims) {
2390 args->flags |= IW_POWER_ALL_R;
2391 } else {
2392 args->flags |= IW_POWER_UNICAST_R;
2393 }
2394
2395 return 0;
2396}
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416static int
2417unifi_siwcommit(struct net_device *dev, struct iw_request_info *info,
2418 union iwreq_data *wrqu, char *extra)
2419{
2420 return 0;
2421}
2422
2423
2424
2425static int
2426unifi_siwmlme(struct net_device *dev, struct iw_request_info *info,
2427 union iwreq_data *wrqu, char *extra)
2428{
2429 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2430 unifi_priv_t *priv = interfacePriv->privPtr;
2431 struct iw_mlme *mlme = (struct iw_mlme *)extra;
2432
2433 unifi_trace(priv, UDBG2, "unifi_siwmlme\n");
2434 CHECK_INITED(priv);
2435
2436 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
2437 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
2438 unifi_error(priv, "unifi_siwmlme: not permitted in Mode %d\n",
2439 interfacePriv->interfaceMode);
2440 return -EPERM;
2441 }
2442
2443
2444 switch (mlme->cmd) {
2445 case IW_MLME_DEAUTH:
2446 case IW_MLME_DISASSOC:
2447 UF_RTNL_UNLOCK();
2448 sme_mgt_disconnect(priv);
2449 UF_RTNL_LOCK();
2450 break;
2451 default:
2452 return -EOPNOTSUPP;
2453 }
2454
2455 return 0;
2456}
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483static int
2484unifi_siwgenie(struct net_device *dev, struct iw_request_info *info,
2485 union iwreq_data *wrqu, char *extra)
2486{
2487 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2488 unifi_priv_t *priv = interfacePriv->privPtr;
2489 int len;
2490
2491 unifi_trace(priv, UDBG2, "unifi_siwgenie\n");
2492
2493 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
2494 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
2495 unifi_error(priv, "unifi_siwgenie: not permitted in Mode %d\n",
2496 interfacePriv->interfaceMode);
2497 return -EPERM;
2498 }
2499
2500
2501 if ( priv->connection_config.mlmeAssociateReqInformationElements) {
2502 kfree( priv->connection_config.mlmeAssociateReqInformationElements);
2503 }
2504 priv->connection_config.mlmeAssociateReqInformationElementsLength = 0;
2505 priv->connection_config.mlmeAssociateReqInformationElements = NULL;
2506
2507 len = wrqu->data.length;
2508 if (len == 0) {
2509 return 0;
2510 }
2511
2512 priv->connection_config.mlmeAssociateReqInformationElements = kmalloc(len, GFP_KERNEL);
2513 if (priv->connection_config.mlmeAssociateReqInformationElements == NULL) {
2514 return -ENOMEM;
2515 }
2516
2517 priv->connection_config.mlmeAssociateReqInformationElementsLength = len;
2518 memcpy( priv->connection_config.mlmeAssociateReqInformationElements, extra, len);
2519
2520 return 0;
2521}
2522
2523
2524static int
2525unifi_giwgenie(struct net_device *dev, struct iw_request_info *info,
2526 union iwreq_data *wrqu, char *extra)
2527{
2528 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2529 unifi_priv_t *priv = interfacePriv->privPtr;
2530 int len;
2531
2532 unifi_trace(priv, UDBG2, "unifi_giwgenie\n");
2533
2534 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
2535 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
2536 unifi_error(priv, "unifi_giwgenie: not permitted in Mode %d\n",
2537 interfacePriv->interfaceMode);
2538 return -EPERM;
2539 }
2540
2541
2542 len = priv->connection_config.mlmeAssociateReqInformationElementsLength;
2543
2544 if (len == 0) {
2545 wrqu->data.length = 0;
2546 return 0;
2547 }
2548
2549 if (wrqu->data.length < len) {
2550 return -E2BIG;
2551 }
2552
2553 wrqu->data.length = len;
2554 memcpy(extra, priv->connection_config.mlmeAssociateReqInformationElements, len);
2555
2556 return 0;
2557}
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575static int
2576_unifi_siwauth(struct net_device *dev, struct iw_request_info *info,
2577 union iwreq_data *wrqu, char *extra)
2578{
2579 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2580 unifi_priv_t *priv = interfacePriv->privPtr;
2581 CsrWifiSmeAuthModeMask new_auth;
2582
2583 unifi_trace(priv, UDBG2, "unifi_siwauth\n");
2584
2585 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
2586 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
2587 unifi_error(priv, "unifi_siwauth: not permitted in Mode %d\n",
2588 interfacePriv->interfaceMode);
2589 return -EPERM;
2590 }
2591
2592
2593
2594
2595
2596
2597
2598 switch (wrqu->param.flags & IW_AUTH_INDEX) {
2599
2600 case IW_AUTH_WPA_ENABLED:
2601 unifi_trace(priv, UDBG1, "IW_AUTH_WPA_ENABLED: %d\n", wrqu->param.value);
2602
2603 if (wrqu->param.value == 0) {
2604 unifi_trace(priv, UDBG5, "IW_AUTH_WPA_ENABLED: CSR_WIFI_SME_AUTH_MODE_80211_OPEN\n");
2605 priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
2606 }
2607 break;
2608
2609 case IW_AUTH_PRIVACY_INVOKED:
2610 unifi_trace(priv, UDBG1, "IW_AUTH_PRIVACY_INVOKED: %d\n", wrqu->param.value);
2611
2612 priv->connection_config.privacyMode = wrqu->param.value ? CSR_WIFI_SME_80211_PRIVACY_MODE_ENABLED : CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED;
2613 if (wrqu->param.value == CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED)
2614 {
2615 priv->connection_config.encryptionModeMask = CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE;
2616 }
2617 break;
2618
2619 case IW_AUTH_80211_AUTH_ALG:
2620
2621
2622
2623
2624
2625 new_auth = 0;
2626 if (wrqu->param.value & IW_AUTH_ALG_OPEN_SYSTEM) {
2627 unifi_trace(priv, UDBG1, "IW_AUTH_80211_AUTH_ALG: %d (IW_AUTH_ALG_OPEN_SYSTEM)\n", wrqu->param.value);
2628 new_auth |= CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
2629 }
2630 if (wrqu->param.value & IW_AUTH_ALG_SHARED_KEY) {
2631 unifi_trace(priv, UDBG1, "IW_AUTH_80211_AUTH_ALG: %d (IW_AUTH_ALG_SHARED_KEY)\n", wrqu->param.value);
2632 new_auth |= CSR_WIFI_SME_AUTH_MODE_80211_SHARED;
2633 }
2634 if (wrqu->param.value & IW_AUTH_ALG_LEAP) {
2635
2636 unifi_trace(priv, UDBG1, "IW_AUTH_80211_AUTH_ALG: %d (IW_AUTH_ALG_LEAP)\n", wrqu->param.value);
2637 new_auth |= CSR_WIFI_SME_AUTH_MODE_8021X_OTHER1X;
2638 }
2639 if (new_auth == 0) {
2640 unifi_trace(priv, UDBG1, "IW_AUTH_80211_AUTH_ALG: invalid value %d\n",
2641 wrqu->param.value);
2642 return -EINVAL;
2643 } else {
2644 priv->connection_config.authModeMask = new_auth;
2645 }
2646 break;
2647
2648 case IW_AUTH_WPA_VERSION:
2649 unifi_trace(priv, UDBG1, "IW_AUTH_WPA_VERSION: %d\n", wrqu->param.value);
2650 priv->ignore_bssid_join = TRUE;
2651
2652
2653
2654
2655
2656
2657 if (!(wrqu->param.value & IW_AUTH_WPA_VERSION_DISABLED)) {
2658
2659 priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
2660
2661 if (wrqu->param.value & IW_AUTH_WPA_VERSION_WPA) {
2662 unifi_trace(priv, UDBG4, "IW_AUTH_WPA_VERSION: WPA, WPA-PSK\n");
2663 priv->connection_config.authModeMask |= (CSR_WIFI_SME_AUTH_MODE_8021X_WPA | CSR_WIFI_SME_AUTH_MODE_8021X_WPAPSK);
2664 }
2665 if (wrqu->param.value & IW_AUTH_WPA_VERSION_WPA2) {
2666 unifi_trace(priv, UDBG4, "IW_AUTH_WPA_VERSION: WPA2, WPA2-PSK\n");
2667 priv->connection_config.authModeMask |= (CSR_WIFI_SME_AUTH_MODE_8021X_WPA2 | CSR_WIFI_SME_AUTH_MODE_8021X_WPA2PSK);
2668 }
2669 }
2670 break;
2671
2672 case IW_AUTH_CIPHER_PAIRWISE:
2673 unifi_trace(priv, UDBG1, "IW_AUTH_CIPHER_PAIRWISE: %d\n", wrqu->param.value);
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683 priv->connection_config.encryptionModeMask = CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE;
2684
2685 if (wrqu->param.value & IW_AUTH_CIPHER_WEP40) {
2686 priv->connection_config.encryptionModeMask |=
2687 CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP40 | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40;
2688 }
2689 if (wrqu->param.value & IW_AUTH_CIPHER_WEP104) {
2690 priv->connection_config.encryptionModeMask |=
2691 CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP104 | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104;
2692 }
2693 if (wrqu->param.value & IW_AUTH_CIPHER_TKIP) {
2694 priv->connection_config.encryptionModeMask |=
2695 CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_TKIP | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_TKIP;
2696 }
2697 if (wrqu->param.value & IW_AUTH_CIPHER_CCMP) {
2698 priv->connection_config.encryptionModeMask |=
2699 CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_CCMP | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_CCMP;
2700 }
2701
2702 break;
2703
2704 case IW_AUTH_CIPHER_GROUP:
2705 unifi_trace(priv, UDBG1, "IW_AUTH_CIPHER_GROUP: %d\n", wrqu->param.value);
2706
2707
2708
2709
2710
2711
2712 priv->connection_config.encryptionModeMask &= ~(CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40 |
2713 CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104 |
2714 CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_TKIP |
2715 CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_CCMP);
2716 if (wrqu->param.value & IW_AUTH_CIPHER_WEP40) {
2717 priv->connection_config.encryptionModeMask |= CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40;
2718 }
2719 if (wrqu->param.value & IW_AUTH_CIPHER_WEP104) {
2720 priv->connection_config.encryptionModeMask |= CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104;
2721 }
2722 if (wrqu->param.value & IW_AUTH_CIPHER_TKIP) {
2723 priv->connection_config.encryptionModeMask |= CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_TKIP;
2724 }
2725 if (wrqu->param.value & IW_AUTH_CIPHER_CCMP) {
2726 priv->connection_config.encryptionModeMask |= CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_CCMP;
2727 }
2728
2729 break;
2730
2731 case IW_AUTH_KEY_MGMT:
2732 unifi_trace(priv, UDBG1, "IW_AUTH_KEY_MGMT: %d\n", wrqu->param.value);
2733
2734
2735
2736
2737 if (priv->connection_config.authModeMask & (CSR_WIFI_SME_AUTH_MODE_8021X_WPA | CSR_WIFI_SME_AUTH_MODE_8021X_WPAPSK)) {
2738
2739 if (wrqu->param.value == IW_AUTH_KEY_MGMT_802_1X) {
2740 priv->connection_config.authModeMask &= ~CSR_WIFI_SME_AUTH_MODE_8021X_WPAPSK;
2741 }
2742 if (wrqu->param.value == IW_AUTH_KEY_MGMT_PSK) {
2743 priv->connection_config.authModeMask &= ~CSR_WIFI_SME_AUTH_MODE_8021X_WPA;
2744 }
2745 unifi_trace(priv, UDBG5, "IW_AUTH_KEY_MGMT: WPA: %d\n",
2746 priv->connection_config.authModeMask);
2747 }
2748 if (priv->connection_config.authModeMask & (CSR_WIFI_SME_AUTH_MODE_8021X_WPA2 | CSR_WIFI_SME_AUTH_MODE_8021X_WPA2PSK)) {
2749
2750 if (wrqu->param.value == IW_AUTH_KEY_MGMT_802_1X) {
2751 priv->connection_config.authModeMask &= ~CSR_WIFI_SME_AUTH_MODE_8021X_WPA2PSK;
2752 }
2753 if (wrqu->param.value == IW_AUTH_KEY_MGMT_PSK) {
2754 priv->connection_config.authModeMask &= ~CSR_WIFI_SME_AUTH_MODE_8021X_WPA2;
2755 }
2756 unifi_trace(priv, UDBG5, "IW_AUTH_KEY_MGMT: WPA2: %d\n",
2757 priv->connection_config.authModeMask);
2758 }
2759
2760 break;
2761 case IW_AUTH_TKIP_COUNTERMEASURES:
2762
2763
2764
2765
2766 unifi_trace(priv, UDBG1, "IW_AUTH_TKIP_COUNTERMEASURES: %d\n", wrqu->param.value);
2767 break;
2768
2769 case IW_AUTH_DROP_UNENCRYPTED:
2770
2771
2772
2773
2774
2775
2776
2777 unifi_trace(priv, UDBG1, "IW_AUTH_DROP_UNENCRYPTED: %d\n", wrqu->param.value);
2778 break;
2779
2780 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
2781
2782
2783
2784
2785
2786
2787
2788 unifi_trace(priv, UDBG1, "IW_AUTH_RX_UNENCRYPTED_EAPOL: %d\n", wrqu->param.value);
2789 break;
2790
2791 case IW_AUTH_ROAMING_CONTROL:
2792 unifi_trace(priv, UDBG1, "IW_AUTH_ROAMING_CONTROL: %d\n", wrqu->param.value);
2793 break;
2794
2795 default:
2796 unifi_trace(priv, UDBG1, "Unsupported auth param %d to 0x%X\n",
2797 wrqu->param.flags & IW_AUTH_INDEX,
2798 wrqu->param.value);
2799 return -EOPNOTSUPP;
2800 }
2801
2802 unifi_trace(priv, UDBG2, "authModeMask = %d", priv->connection_config.authModeMask);
2803
2804 return 0;
2805}
2806
2807
2808static int
2809unifi_siwauth(struct net_device *dev, struct iw_request_info *info,
2810 union iwreq_data *wrqu, char *extra)
2811{
2812 int err = 0;
2813
2814 UF_RTNL_UNLOCK();
2815 err = _unifi_siwauth(dev, info, wrqu, extra);
2816 UF_RTNL_LOCK();
2817
2818 return err;
2819}
2820
2821
2822static int
2823unifi_giwauth(struct net_device *dev, struct iw_request_info *info,
2824 union iwreq_data *wrqu, char *extra)
2825{
2826 unifi_trace(NULL, UDBG2, "unifi_giwauth\n");
2827 return -EOPNOTSUPP;
2828}
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850static int
2851_unifi_siwencodeext(struct net_device *dev, struct iw_request_info *info,
2852 union iwreq_data *wrqu, char *extra)
2853{
2854 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
2855 unifi_priv_t *priv = interfacePriv->privPtr;
2856 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
2857 int r = 0;
2858 unsigned char *keydata;
2859 unsigned char tkip_key[32];
2860 int keyid;
2861 unsigned char *a = (unsigned char *)ext->addr.sa_data;
2862 CsrWifiSmeKey sme_key;
2863 CsrWifiSmeKeyType key_type;
2864
2865 CHECK_INITED(priv);
2866
2867 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
2868 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
2869 unifi_error(priv, "unifi_siwencodeext: not permitted in Mode %d\n",
2870 interfacePriv->interfaceMode);
2871 return -EPERM;
2872 }
2873
2874
2875 unifi_trace(priv, UDBG1, "siwencodeext: flags=0x%X, alg=%d, ext_flags=0x%X, len=%d, index=%d,\n",
2876 wrqu->encoding.flags, ext->alg, ext->ext_flags,
2877 ext->key_len, (wrqu->encoding.flags & IW_ENCODE_INDEX));
2878 unifi_trace(priv, UDBG3, " addr=%pM\n", a);
2879
2880 if ((ext->key_len == 0) && (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)) {
2881
2882
2883 unifi_trace(priv, UDBG1, KERN_ERR "unifi_siwencodeext: NYI should change tx key id here!!\n");
2884 return -ENOTSUPP;
2885 }
2886
2887 memset(&sme_key, 0, sizeof(sme_key));
2888
2889 keydata = (unsigned char *)(ext + 1);
2890 keyid = (wrqu->encoding.flags & IW_ENCODE_INDEX);
2891
2892
2893
2894
2895
2896 if (ext->alg == IW_ENCODE_ALG_NONE) {
2897
2898 unifi_trace(priv, UDBG1, "Deleting %s key %d\n",
2899 (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) ? "GROUP" : "PAIRWISE",
2900 keyid);
2901
2902 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
2903 sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_GROUP;
2904 } else {
2905 sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
2906 }
2907 sme_key.keyIndex = (keyid - 1);
2908 sme_key.keyLength = 0;
2909 sme_key.authenticator = 0;
2910 memcpy(sme_key.address.a, a, ETH_ALEN);
2911 UF_RTNL_UNLOCK();
2912 r = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_REMOVE);
2913 UF_RTNL_LOCK();
2914 if (r) {
2915 unifi_error(priv, "Delete key request was rejected with result %d\n", r);
2916 return convert_sme_error(r);
2917 }
2918
2919 return 0;
2920 }
2921
2922
2923
2924
2925
2926
2927 if (ext->alg == IW_ENCODE_ALG_WEP) {
2928
2929
2930
2931 if (!((ext->key_len == 5) || (ext->key_len == 13))) {
2932 unifi_trace(priv, UDBG1, KERN_ERR "Invalid length for WEP key: %d\n", ext->key_len);
2933 return -EINVAL;
2934 }
2935
2936 unifi_trace(priv, UDBG1, "Setting WEP key %d tx:%d\n",
2937 keyid, ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY);
2938
2939 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
2940 sme_key.wepTxKey = TRUE;
2941 sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
2942 } else {
2943 sme_key.wepTxKey = FALSE;
2944 sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_GROUP;
2945 }
2946 sme_key.keyIndex = (keyid - 1);
2947 sme_key.keyLength = ext->key_len;
2948 sme_key.authenticator = 0;
2949 memset(sme_key.address.a, 0xFF, ETH_ALEN);
2950 memcpy(sme_key.key, keydata, ext->key_len);
2951 UF_RTNL_UNLOCK();
2952 r = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_ADD);
2953 UF_RTNL_LOCK();
2954 if (r) {
2955 unifi_error(priv, "siwencodeext: Set key failed (%d)", r);
2956 return convert_sme_error(r);
2957 }
2958
2959 return 0;
2960 }
2961
2962
2963
2964
2965
2966
2967 if (ext->key_len > 32) {
2968 return -EINVAL;
2969 }
2970
2971
2972
2973
2974
2975 if ((ext->alg == IW_ENCODE_ALG_TKIP) && (ext->key_len == 32)) {
2976 memcpy(tkip_key, keydata, 16);
2977 memcpy(tkip_key + 16, keydata + 24, 8);
2978 memcpy(tkip_key + 24, keydata + 16, 8);
2979 keydata = tkip_key;
2980 }
2981
2982 key_type = (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) ?
2983 CSR_WIFI_SME_KEY_TYPE_GROUP :
2984 CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
2985
2986 sme_key.keyType = key_type;
2987 sme_key.keyIndex = (keyid - 1);
2988 sme_key.keyLength = ext->key_len;
2989 sme_key.authenticator = 0;
2990 memcpy(sme_key.address.a, ext->addr.sa_data, ETH_ALEN);
2991 if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
2992
2993 unifi_trace(priv, UDBG5, "RSC first 6 bytes = %*phC\n",
2994 6, ext->rx_seq);
2995
2996
2997 sme_key.keyRsc[0] = ext->rx_seq[1] << 8 | ext->rx_seq[0];
2998 sme_key.keyRsc[1] = ext->rx_seq[3] << 8 | ext->rx_seq[2];
2999 sme_key.keyRsc[2] = ext->rx_seq[5] << 8 | ext->rx_seq[4];
3000 sme_key.keyRsc[3] = ext->rx_seq[7] << 8 | ext->rx_seq[6];
3001
3002 }
3003
3004 memcpy(sme_key.key, keydata, ext->key_len);
3005 UF_RTNL_UNLOCK();
3006 r = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_ADD);
3007 UF_RTNL_LOCK();
3008 if (r) {
3009 unifi_error(priv, "SETKEYS request was rejected with result %d\n", r);
3010 return convert_sme_error(r);
3011 }
3012
3013 return r;
3014}
3015
3016
3017static int
3018unifi_siwencodeext(struct net_device *dev, struct iw_request_info *info,
3019 union iwreq_data *wrqu, char *extra)
3020{
3021 int err = 0;
3022
3023 err = _unifi_siwencodeext(dev, info, wrqu, extra);
3024
3025 return err;
3026}
3027
3028
3029static int
3030unifi_giwencodeext(struct net_device *dev, struct iw_request_info *info,
3031 union iwreq_data *wrqu, char *extra)
3032{
3033 return -EOPNOTSUPP;
3034}
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057#define UNIFI_PMKID_KEY_SIZE 16
3058static int
3059unifi_siwpmksa(struct net_device *dev, struct iw_request_info *info,
3060 union iwreq_data *wrqu, char *extra)
3061{
3062 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
3063 unifi_priv_t *priv = interfacePriv->privPtr;
3064 struct iw_pmksa *pmksa = (struct iw_pmksa *)extra;
3065 CsrResult r = 0;
3066 CsrWifiSmePmkidList pmkid_list;
3067 CsrWifiSmePmkid pmkid;
3068 CsrWifiSmeListAction action;
3069
3070 CHECK_INITED(priv);
3071
3072 if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
3073 interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
3074 unifi_error(priv, "unifi_siwpmksa: not permitted in Mode %d\n",
3075 interfacePriv->interfaceMode);
3076 return -EPERM;
3077 }
3078
3079
3080 unifi_trace(priv, UDBG1, "SIWPMKSA: cmd %d, %pM\n", pmksa->cmd,
3081 pmksa->bssid.sa_data);
3082
3083 pmkid_list.pmkids = NULL;
3084 switch (pmksa->cmd) {
3085 case IW_PMKSA_ADD:
3086 pmkid_list.pmkids = &pmkid;
3087 action = CSR_WIFI_SME_LIST_ACTION_ADD;
3088 pmkid_list.pmkidsCount = 1;
3089 memcpy(pmkid.bssid.a, pmksa->bssid.sa_data, ETH_ALEN);
3090 memcpy(pmkid.pmkid, pmksa->pmkid, UNIFI_PMKID_KEY_SIZE);
3091 break;
3092 case IW_PMKSA_REMOVE:
3093 pmkid_list.pmkids = &pmkid;
3094 action = CSR_WIFI_SME_LIST_ACTION_REMOVE;
3095 pmkid_list.pmkidsCount = 1;
3096 memcpy(pmkid.bssid.a, pmksa->bssid.sa_data, ETH_ALEN);
3097 memcpy(pmkid.pmkid, pmksa->pmkid, UNIFI_PMKID_KEY_SIZE);
3098 break;
3099 case IW_PMKSA_FLUSH:
3100
3101 pmkid_list.pmkidsCount = 0;
3102 action = CSR_WIFI_SME_LIST_ACTION_FLUSH;
3103 break;
3104 default:
3105 unifi_notice(priv, "SIWPMKSA: Unknown command (0x%x)\n", pmksa->cmd);
3106 return -EINVAL;
3107 }
3108
3109
3110 UF_RTNL_UNLOCK();
3111 r = sme_mgt_pmkid(priv, action, &pmkid_list);
3112 UF_RTNL_LOCK();
3113 if (r) {
3114 unifi_error(priv, "SIWPMKSA: Set PMKID's Failed.\n");
3115 }
3116
3117 return r;
3118
3119}
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135struct iw_statistics *
3136unifi_get_wireless_stats(struct net_device *dev)
3137{
3138 netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
3139 unifi_priv_t *priv = interfacePriv->privPtr;
3140
3141 if (priv->init_progress != UNIFI_INIT_COMPLETED) {
3142 return NULL;
3143 }
3144
3145 return &priv->wext_wireless_stats;
3146}
3147
3148
3149
3150
3151
3152
3153static const struct iw_priv_args unifi_private_args[] = {
3154
3155 { SIOCIWS80211POWERSAVEPRIV, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
3156 IW_PRIV_TYPE_NONE, "iwprivs80211ps" },
3157 { SIOCIWG80211POWERSAVEPRIV, IW_PRIV_TYPE_NONE,
3158 IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IWPRIV_POWER_SAVE_MAX_STRING, "iwprivg80211ps" },
3159 { SIOCIWS80211RELOADDEFAULTSPRIV, IW_PRIV_TYPE_NONE,
3160 IW_PRIV_TYPE_NONE, "iwprivsdefs" },
3161 { SIOCIWSSMEDEBUGPRIV, IW_PRIV_TYPE_CHAR | IWPRIV_SME_DEBUG_MAX_STRING, IW_PRIV_TYPE_NONE, "iwprivssmedebug" },
3162#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
3163 { SIOCIWSCONFWAPIPRIV, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
3164 IW_PRIV_TYPE_NONE, "iwprivsconfwapi" },
3165 { SIOCIWSWAPIKEYPRIV, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(unifiio_wapi_key_t),
3166 IW_PRIV_TYPE_NONE, "iwprivswpikey" },
3167#endif
3168#ifdef CSR_SUPPORT_WEXT_AP
3169 { SIOCIWSAPCFGPRIV, IW_PRIV_TYPE_CHAR | 256, IW_PRIV_TYPE_NONE, "AP_SET_CFG" },
3170 { SIOCIWSAPSTARTPRIV, 0,IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED|IWPRIV_SME_MAX_STRING,"AP_BSS_START" },
3171 { SIOCIWSAPSTOPPRIV, IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|0,
3172 IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|0, "AP_BSS_STOP" },
3173#ifdef ANDROID_BUILD
3174 { SIOCIWSFWRELOADPRIV, IW_PRIV_TYPE_CHAR |256,
3175 IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|0, "WL_FW_RELOAD" },
3176 { SIOCIWSSTACKSTART, 0,
3177 IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|IWPRIV_SME_MAX_STRING, "START" },
3178 { SIOCIWSSTACKSTOP, 0,
3179 IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|IWPRIV_SME_MAX_STRING, "STOP" },
3180#endif
3181#endif
3182};
3183
3184static const iw_handler unifi_handler[] =
3185{
3186 (iw_handler) unifi_siwcommit,
3187 (iw_handler) unifi_giwname,
3188 (iw_handler) NULL,
3189 (iw_handler) NULL,
3190 (iw_handler) unifi_siwfreq,
3191 (iw_handler) unifi_giwfreq,
3192 (iw_handler) unifi_siwmode,
3193 (iw_handler) unifi_giwmode,
3194 (iw_handler) NULL,
3195 (iw_handler) NULL,
3196 (iw_handler) NULL,
3197 (iw_handler) unifi_giwrange,
3198 (iw_handler) NULL,
3199 (iw_handler) NULL,
3200 (iw_handler) NULL,
3201 (iw_handler) NULL,
3202 (iw_handler) NULL,
3203 (iw_handler) NULL,
3204 (iw_handler) NULL,
3205 (iw_handler) NULL,
3206 (iw_handler) unifi_siwap,
3207 (iw_handler) unifi_giwap,
3208#if WIRELESS_EXT > 17
3209
3210 unifi_siwmlme,
3211#else
3212 (iw_handler) NULL,
3213#endif
3214 (iw_handler) NULL,
3215 (iw_handler) unifi_siwscan,
3216 (iw_handler) unifi_giwscan,
3217 (iw_handler) unifi_siwessid,
3218 (iw_handler) unifi_giwessid,
3219 (iw_handler) NULL,
3220 (iw_handler) NULL,
3221 (iw_handler) NULL,
3222 (iw_handler) NULL,
3223 unifi_siwrate,
3224 unifi_giwrate,
3225 unifi_siwrts,
3226 unifi_giwrts,
3227 unifi_siwfrag,
3228 unifi_giwfrag,
3229 (iw_handler) NULL,
3230 (iw_handler) NULL,
3231 (iw_handler) NULL,
3232 (iw_handler) NULL,
3233 unifi_siwencode,
3234 unifi_giwencode,
3235 unifi_siwpower,
3236 unifi_giwpower,
3237#if WIRELESS_EXT > 17
3238 (iw_handler) NULL,
3239 (iw_handler) NULL,
3240
3241
3242 unifi_siwgenie,
3243 unifi_giwgenie,
3244
3245
3246 unifi_siwauth,
3247 unifi_giwauth,
3248
3249
3250 unifi_siwencodeext,
3251 unifi_giwencodeext,
3252
3253
3254 unifi_siwpmksa,
3255 (iw_handler) NULL,
3256#endif
3257};
3258
3259
3260static const iw_handler unifi_private_handler[] =
3261{
3262 iwprivs80211ps,
3263 iwprivg80211ps,
3264 iwprivsdefs,
3265 (iw_handler) NULL,
3266#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
3267 iwprivsconfwapi,
3268 (iw_handler) NULL,
3269 iwprivswpikey,
3270#else
3271 (iw_handler) NULL,
3272 (iw_handler) NULL,
3273 (iw_handler) NULL,
3274#endif
3275 (iw_handler) NULL,
3276 iwprivssmedebug,
3277#ifdef CSR_SUPPORT_WEXT_AP
3278 (iw_handler) NULL,
3279 iwprivsapconfig,
3280 (iw_handler) NULL,
3281 iwprivsapstart,
3282 (iw_handler) NULL,
3283 iwprivsapstop,
3284 (iw_handler) NULL,
3285#ifdef ANDROID_BUILD
3286 iwprivsapfwreload,
3287 (iw_handler) NULL,
3288 iwprivsstackstart,
3289 (iw_handler) NULL,
3290 iwprivsstackstop,
3291#else
3292 (iw_handler) NULL,
3293 (iw_handler) NULL,
3294 (iw_handler) NULL,
3295 (iw_handler) NULL,
3296 (iw_handler) NULL,
3297#endif
3298#else
3299 (iw_handler) NULL,
3300 (iw_handler) NULL,
3301 (iw_handler) NULL,
3302 (iw_handler) NULL,
3303 (iw_handler) NULL,
3304 (iw_handler) NULL,
3305 (iw_handler) NULL,
3306 (iw_handler) NULL,
3307 (iw_handler) NULL,
3308 (iw_handler) NULL,
3309 (iw_handler) NULL,
3310 (iw_handler) NULL,
3311#endif
3312};
3313
3314struct iw_handler_def unifi_iw_handler_def =
3315{
3316 .num_standard = sizeof(unifi_handler) / sizeof(iw_handler),
3317 .num_private = sizeof(unifi_private_handler) / sizeof(iw_handler),
3318 .num_private_args = sizeof(unifi_private_args) / sizeof(struct iw_priv_args),
3319 .standard = (iw_handler *) unifi_handler,
3320 .private = (iw_handler *) unifi_private_handler,
3321 .private_args = (struct iw_priv_args *) unifi_private_args,
3322#if IW_HANDLER_VERSION >= 6
3323 .get_wireless_stats = unifi_get_wireless_stats,
3324#endif
3325};
3326
3327
3328
