projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / ath6kl / os / linux / wireless_ext.c
1 //------------------------------------------------------------------------------
2 // Copyright (c) 2004-2010 Atheros Communications Inc.
3 // All rights reserved.
4 //
5 //
6 //
7 // Permission to use, copy, modify, and/or distribute this software for any
8 // purpose with or without fee is hereby granted, provided that the above
9 // copyright notice and this permission notice appear in all copies.
10 //
11 // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 //
19 //
20 //
21 // Author(s): ="Atheros"
22 //------------------------------------------------------------------------------
23
24 #include "ar6000_drv.h"
25
26 #define IWE_STREAM_ADD_EVENT(p1, p2, p3, p4, p5) \
27 iwe_stream_add_event((p1), (p2), (p3), (p4), (p5))
28
29 #define IWE_STREAM_ADD_POINT(p1, p2, p3, p4, p5) \
30 iwe_stream_add_point((p1), (p2), (p3), (p4), (p5))
31
32 #define IWE_STREAM_ADD_VALUE(p1, p2, p3, p4, p5, p6) \
33 iwe_stream_add_value((p1), (p2), (p3), (p4), (p5), (p6))
34
35 static void ar6000_set_quality(struct iw_quality *iq, A_INT8 rssi);
36 extern unsigned int wmitimeout;
37 extern A_WAITQUEUE_HEAD arEvent;
38
39 #if WIRELESS_EXT > 14
40 /*
41 * Encode a WPA or RSN information element as a custom
42 * element using the hostap format.
43 */
44 static u_int
45 encode_ie(void *buf, size_t bufsize,
46 const u_int8_t *ie, size_t ielen,
47 const char *leader, size_t leader_len)
48 {
49 u_int8_t *p;
50 int i;
51
52 if (bufsize < leader_len)
53 return 0;
54 p = buf;
55 memcpy(p, leader, leader_len);
56 bufsize -= leader_len;
57 p += leader_len;
58 for (i = 0; i < ielen && bufsize > 2; i++)
59 {
60 p += sprintf((char*)p, "%02x", ie[i]);
61 bufsize -= 2;
62 }
63 return (i == ielen ? p - (u_int8_t *)buf : 0);
64 }
65 #endif /* WIRELESS_EXT > 14 */
66
67 static A_UINT8
68 get_bss_phy_capability(bss_t *bss)
69 {
70 A_UINT8 capability = 0;
71 struct ieee80211_common_ie *cie = &bss->ni_cie;
72 #define CHAN_IS_11A(x) (!((x >= 2412) && (x <= 2484)))
73 if (CHAN_IS_11A(cie->ie_chan)) {
74 if (cie->ie_htcap) {
75 capability = WMI_11NA_CAPABILITY;
76 } else {
77 capability = WMI_11A_CAPABILITY;
78 }
79 } else if ((cie->ie_erp) || (cie->ie_xrates)) {
80 if (cie->ie_htcap) {
81 capability = WMI_11NG_CAPABILITY;
82 } else {
83 capability = WMI_11G_CAPABILITY;
84 }
85 }
86 return capability;
87 }
88
89 void
90 ar6000_scan_node(void *arg, bss_t *ni)
91 {
92 struct iw_event iwe;
93 #if WIRELESS_EXT > 14
94 char buf[256];
95 #endif
96 struct ar_giwscan_param *param;
97 A_CHAR *current_ev;
98 A_CHAR *end_buf;
99 struct ieee80211_common_ie *cie;
100 A_CHAR *current_val;
101 A_INT32 j;
102 A_UINT32 rate_len, data_len = 0;
103
104 param = (struct ar_giwscan_param *)arg;
105
106 current_ev = param->current_ev;
107 end_buf = param->end_buf;
108
109 cie = &ni->ni_cie;
110
111 if ((end_buf - current_ev) > IW_EV_ADDR_LEN)
112 {
113 A_MEMZERO(&iwe, sizeof(iwe));
114 iwe.cmd = SIOCGIWAP;
115 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
116 A_MEMCPY(iwe.u.ap_addr.sa_data, ni->ni_macaddr, 6);
117 current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
118 &iwe, IW_EV_ADDR_LEN);
119 }
120 param->bytes_needed += IW_EV_ADDR_LEN;
121
122 data_len = cie->ie_ssid[1] + IW_EV_POINT_LEN;
123 if ((end_buf - current_ev) > data_len)
124 {
125 A_MEMZERO(&iwe, sizeof(iwe));
126 iwe.cmd = SIOCGIWESSID;
127 iwe.u.data.flags = 1;
128 iwe.u.data.length = cie->ie_ssid[1];
129 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
130 &iwe, (char*)&cie->ie_ssid[2]);
131 }
132 param->bytes_needed += data_len;
133
134 if (cie->ie_capInfo & (IEEE80211_CAPINFO_ESS|IEEE80211_CAPINFO_IBSS)) {
135 if ((end_buf - current_ev) > IW_EV_UINT_LEN)
136 {
137 A_MEMZERO(&iwe, sizeof(iwe));
138 iwe.cmd = SIOCGIWMODE;
139 iwe.u.mode = cie->ie_capInfo & IEEE80211_CAPINFO_ESS ?
140 IW_MODE_MASTER : IW_MODE_ADHOC;
141 current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
142 &iwe, IW_EV_UINT_LEN);
143 }
144 param->bytes_needed += IW_EV_UINT_LEN;
145 }
146
147 if ((end_buf - current_ev) > IW_EV_FREQ_LEN)
148 {
149 A_MEMZERO(&iwe, sizeof(iwe));
150 iwe.cmd = SIOCGIWFREQ;
151 iwe.u.freq.m = cie->ie_chan * 100000;
152 iwe.u.freq.e = 1;
153 current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
154 &iwe, IW_EV_FREQ_LEN);
155 }
156 param->bytes_needed += IW_EV_FREQ_LEN;
157
158 if ((end_buf - current_ev) > IW_EV_QUAL_LEN)
159 {
160 A_MEMZERO(&iwe, sizeof(iwe));
161 iwe.cmd = IWEVQUAL;
162 ar6000_set_quality(&iwe.u.qual, ni->ni_snr);
163 current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
164 &iwe, IW_EV_QUAL_LEN);
165 }
166 param->bytes_needed += IW_EV_QUAL_LEN;
167
168 if ((end_buf - current_ev) > IW_EV_POINT_LEN)
169 {
170 A_MEMZERO(&iwe, sizeof(iwe));
171 iwe.cmd = SIOCGIWENCODE;
172 if (cie->ie_capInfo & IEEE80211_CAPINFO_PRIVACY) {
173 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
174 } else {
175 iwe.u.data.flags = IW_ENCODE_DISABLED;
176 }
177 iwe.u.data.length = 0;
178 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
179 &iwe, "");
180 }
181 param->bytes_needed += IW_EV_POINT_LEN;
182
183 /* supported bit rate */
184 A_MEMZERO(&iwe, sizeof(iwe));
185 iwe.cmd = SIOCGIWRATE;
186 iwe.u.bitrate.fixed = 0;
187 iwe.u.bitrate.disabled = 0;
188 iwe.u.bitrate.value = 0;
189 current_val = current_ev + IW_EV_LCP_LEN;
190 param->bytes_needed += IW_EV_LCP_LEN;
191
192 if (cie->ie_rates != NULL) {
193 rate_len = cie->ie_rates[1];
194 data_len = (rate_len * (IW_EV_PARAM_LEN - IW_EV_LCP_LEN));
195 if ((end_buf - current_ev) > data_len)
196 {
197 for (j = 0; j < rate_len; j++) {
198 unsigned char val;
199 val = cie->ie_rates[2 + j];
200 iwe.u.bitrate.value =
201 (val >= 0x80)? ((val - 0x80) * 500000): (val * 500000);
202 current_val = IWE_STREAM_ADD_VALUE(param->info, current_ev,
203 current_val, end_buf,
204 &iwe, IW_EV_PARAM_LEN);
205 }
206 }
207 param->bytes_needed += data_len;
208 }
209
210 if (cie->ie_xrates != NULL) {
211 rate_len = cie->ie_xrates[1];
212 data_len = (rate_len * (IW_EV_PARAM_LEN - IW_EV_LCP_LEN));
213 if ((end_buf - current_ev) > data_len)
214 {
215 for (j = 0; j < rate_len; j++) {
216 unsigned char val;
217 val = cie->ie_xrates[2 + j];
218 iwe.u.bitrate.value =
219 (val >= 0x80)? ((val - 0x80) * 500000): (val * 500000);
220 current_val = IWE_STREAM_ADD_VALUE(param->info, current_ev,
221 current_val, end_buf,
222 &iwe, IW_EV_PARAM_LEN);
223 }
224 }
225 param->bytes_needed += data_len;
226 }
227 /* remove fixed header if no rates were added */
228 if ((current_val - current_ev) > IW_EV_LCP_LEN)
229 current_ev = current_val;
230
231 #if WIRELESS_EXT >= 18
232 /* IE */
233 if (cie->ie_wpa != NULL) {
234 data_len = cie->ie_wpa[1] + 2 + IW_EV_POINT_LEN;
235 if ((end_buf - current_ev) > data_len)
236 {
237 A_MEMZERO(&iwe, sizeof(iwe));
238 iwe.cmd = IWEVGENIE;
239 iwe.u.data.length = cie->ie_wpa[1] + 2;
240 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
241 &iwe, (char*)cie->ie_wpa);
242 }
243 param->bytes_needed += data_len;
244 }
245
246 if (cie->ie_rsn != NULL && cie->ie_rsn[0] == IEEE80211_ELEMID_RSN) {
247 data_len = cie->ie_rsn[1] + 2 + IW_EV_POINT_LEN;
248 if ((end_buf - current_ev) > data_len)
249 {
250 A_MEMZERO(&iwe, sizeof(iwe));
251 iwe.cmd = IWEVGENIE;
252 iwe.u.data.length = cie->ie_rsn[1] + 2;
253 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
254 &iwe, (char*)cie->ie_rsn);
255 }
256 param->bytes_needed += data_len;
257 }
258
259 #endif /* WIRELESS_EXT >= 18 */
260
261 if ((end_buf - current_ev) > IW_EV_CHAR_LEN)
262 {
263 /* protocol */
264 A_MEMZERO(&iwe, sizeof(iwe));
265 iwe.cmd = SIOCGIWNAME;
266 switch (get_bss_phy_capability(ni)) {
267 case WMI_11A_CAPABILITY:
268 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11a");
269 break;
270 case WMI_11G_CAPABILITY:
271 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g");
272 break;
273 case WMI_11NA_CAPABILITY:
274 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11na");
275 break;
276 case WMI_11NG_CAPABILITY:
277 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11ng");
278 break;
279 default:
280 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b");
281 break;
282 }
283 current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
284 &iwe, IW_EV_CHAR_LEN);
285 }
286 param->bytes_needed += IW_EV_CHAR_LEN;
287
288 #if WIRELESS_EXT > 14
289 A_MEMZERO(&iwe, sizeof(iwe));
290 iwe.cmd = IWEVCUSTOM;
291 iwe.u.data.length = snprintf(buf, sizeof(buf), "bcn_int=%d", cie->ie_beaconInt);
292 data_len = iwe.u.data.length + IW_EV_POINT_LEN;
293 if ((end_buf - current_ev) > data_len)
294 {
295 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
296 &iwe, buf);
297 }
298 param->bytes_needed += data_len;
299
300 #if WIRELESS_EXT < 18
301 if (cie->ie_wpa != NULL) {
302 static const char wpa_leader[] = "wpa_ie=";
303 data_len = (sizeof(wpa_leader) - 1) + ((cie->ie_wpa[1]+2) * 2) + IW_EV_POINT_LEN;
304 if ((end_buf - current_ev) > data_len)
305 {
306 A_MEMZERO(&iwe, sizeof(iwe));
307 iwe.cmd = IWEVCUSTOM;
308 iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_wpa,
309 cie->ie_wpa[1]+2,
310 wpa_leader, sizeof(wpa_leader)-1);
311
312 if (iwe.u.data.length != 0) {
313 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev,
314 end_buf, &iwe, buf);
315 }
316 }
317 param->bytes_needed += data_len;
318 }
319
320 if (cie->ie_rsn != NULL && cie->ie_rsn[0] == IEEE80211_ELEMID_RSN) {
321 static const char rsn_leader[] = "rsn_ie=";
322 data_len = (sizeof(rsn_leader) - 1) + ((cie->ie_rsn[1]+2) * 2) + IW_EV_POINT_LEN;
323 if ((end_buf - current_ev) > data_len)
324 {
325 A_MEMZERO(&iwe, sizeof(iwe));
326 iwe.cmd = IWEVCUSTOM;
327 iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_rsn,
328 cie->ie_rsn[1]+2,
329 rsn_leader, sizeof(rsn_leader)-1);
330
331 if (iwe.u.data.length != 0) {
332 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev,
333 end_buf, &iwe, buf);
334 }
335 }
336 param->bytes_needed += data_len;
337 }
338 #endif /* WIRELESS_EXT < 18 */
339
340 if (cie->ie_wmm != NULL) {
341 static const char wmm_leader[] = "wmm_ie=";
342 data_len = (sizeof(wmm_leader) - 1) + ((cie->ie_wmm[1]+2) * 2) + IW_EV_POINT_LEN;
343 if ((end_buf - current_ev) > data_len)
344 {
345 A_MEMZERO(&iwe, sizeof(iwe));
346 iwe.cmd = IWEVCUSTOM;
347 iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_wmm,
348 cie->ie_wmm[1]+2,
349 wmm_leader, sizeof(wmm_leader)-1);
350 if (iwe.u.data.length != 0) {
351 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev,
352 end_buf, &iwe, buf);
353 }
354 }
355 param->bytes_needed += data_len;
356 }
357
358 if (cie->ie_ath != NULL) {
359 static const char ath_leader[] = "ath_ie=";
360 data_len = (sizeof(ath_leader) - 1) + ((cie->ie_ath[1]+2) * 2) + IW_EV_POINT_LEN;
361 if ((end_buf - current_ev) > data_len)
362 {
363 A_MEMZERO(&iwe, sizeof(iwe));
364 iwe.cmd = IWEVCUSTOM;
365 iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_ath,
366 cie->ie_ath[1]+2,
367 ath_leader, sizeof(ath_leader)-1);
368 if (iwe.u.data.length != 0) {
369 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev,
370 end_buf, &iwe, buf);
371 }
372 }
373 param->bytes_needed += data_len;
374 }
375
376 #ifdef WAPI_ENABLE
377 if (cie->ie_wapi != NULL) {
378 static const char wapi_leader[] = "wapi_ie=";
379 data_len = (sizeof(wapi_leader) - 1) + ((cie->ie_wapi[1] + 2) * 2) + IW_EV_POINT_LEN;
380 if ((end_buf - current_ev) > data_len) {
381 A_MEMZERO(&iwe, sizeof(iwe));
382 iwe.cmd = IWEVCUSTOM;
383 iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_wapi,
384 cie->ie_wapi[1] + 2,
385 wapi_leader, sizeof(wapi_leader) - 1);
386 if (iwe.u.data.length != 0) {
387 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev,
388 end_buf, &iwe, buf);
389 }
390 }
391 param->bytes_needed += data_len;
392 }
393 #endif /* WAPI_ENABLE */
394
395 #endif /* WIRELESS_EXT > 14 */
396
397 #if WIRELESS_EXT >= 18
398 if (cie->ie_wsc != NULL) {
399 data_len = (cie->ie_wsc[1] + 2) + IW_EV_POINT_LEN;
400 if ((end_buf - current_ev) > data_len)
401 {
402 A_MEMZERO(&iwe, sizeof(iwe));
403 iwe.cmd = IWEVGENIE;
404 iwe.u.data.length = cie->ie_wsc[1] + 2;
405 current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
406 &iwe, (char*)cie->ie_wsc);
407 }
408 param->bytes_needed += data_len;
409 }
410 #endif /* WIRELESS_EXT >= 18 */
411
412 param->current_ev = current_ev;
413 }
414
415 int
416 ar6000_ioctl_giwscan(struct net_device *dev,
417 struct iw_request_info *info,
418 struct iw_point *data, char *extra)
419 {
420 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
421 struct ar_giwscan_param param;
422
423 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
424 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
425 return -EOPNOTSUPP;
426 }
427
428 if (ar->arWlanState == WLAN_DISABLED) {
429 return -EIO;
430 }
431
432 if (ar->arWmiReady == FALSE) {
433 return -EIO;
434 }
435
436 param.current_ev = extra;
437 param.end_buf = extra + data->length;
438 param.bytes_needed = 0;
439 param.info = info;
440
441 /* Translate data to WE format */
442 wmi_iterate_nodes(ar->arWmi, ar6000_scan_node, &param);
443
444 /* check if bytes needed is greater than bytes consumed */
445 if (param.bytes_needed > (param.current_ev - extra))
446 {
447 /* Request one byte more than needed, because when "data->length" equals bytes_needed,
448 it is not possible to add the last event data as all iwe_stream_add_xxxxx() functions
449 checks whether (cur_ptr + ev_len) < end_ptr, due to this one more retry would happen*/
450 data->length = param.bytes_needed + 1;
451
452 return -E2BIG;
453 }
454
455 return 0;
456 }
457
458 extern int reconnect_flag;
459 /* SIOCSIWESSID */
460 static int
461 ar6000_ioctl_siwessid(struct net_device *dev,
462 struct iw_request_info *info,
463 struct iw_point *data, char *ssid)
464 {
465 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
466 A_STATUS status;
467 A_UINT8 arNetworkType;
468 A_UINT8 prevMode = ar->arNetworkType;
469
470 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
471 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
472 return -EOPNOTSUPP;
473 }
474
475 if (ar->bIsDestroyProgress) {
476 return -EBUSY;
477 }
478
479 if (ar->arWlanState == WLAN_DISABLED) {
480 return -EIO;
481 }
482
483 if (ar->arWmiReady == FALSE) {
484 return -EIO;
485 }
486
487 #if defined(WIRELESS_EXT)
488 if (WIRELESS_EXT >= 20) {
489 data->length += 1;
490 }
491 #endif
492
493 /*
494 * iwconfig passes a null terminated string with length including this
495 * so we need to account for this
496 */
497 if (data->flags && (!data->length || (data->length == 1) ||
498 ((data->length - 1) > sizeof(ar->arSsid))))
499 {
500 /*
501 * ssid is invalid
502 */
503 return -EINVAL;
504 }
505
506 if (ar->arNextMode == AP_NETWORK) {
507 /* SSID change for AP network - Will take effect on commit */
508 if(A_MEMCMP(ar->arSsid,ssid,32) != 0) {
509 ar->arSsidLen = data->length - 1;
510 A_MEMCPY(ar->arSsid, ssid, ar->arSsidLen);
511 ar->ap_profile_flag = 1; /* There is a change in profile */
512 }
513 return 0;
514 } else if(ar->arNetworkType == AP_NETWORK) {
515 A_UINT8 ctr;
516 struct sk_buff *skb;
517
518 /* We are switching from AP to STA | IBSS mode, cleanup the AP state */
519 for (ctr=0; ctr < AP_MAX_NUM_STA; ctr++) {
520 remove_sta(ar, ar->sta_list[ctr].mac, 0);
521 }
522 A_MUTEX_LOCK(&ar->mcastpsqLock);
523 while (!A_NETBUF_QUEUE_EMPTY(&ar->mcastpsq)) {
524 skb = A_NETBUF_DEQUEUE(&ar->mcastpsq);
525 A_NETBUF_FREE(skb);
526 }
527 A_MUTEX_UNLOCK(&ar->mcastpsqLock);
528 }
529
530 /* Added for bug 25178, return an IOCTL error instead of target returning
531 Illegal parameter error when either the BSSID or channel is missing
532 and we cannot scan during connect.
533 */
534 if (data->flags) {
535 if (ar->arSkipScan == TRUE &&
536 (ar->arChannelHint == 0 ||
537 (!ar->arReqBssid[0] && !ar->arReqBssid[1] && !ar->arReqBssid[2] &&
538 !ar->arReqBssid[3] && !ar->arReqBssid[4] && !ar->arReqBssid[5])))
539 {
540 return -EINVAL;
541 }
542 }
543
544 if (down_interruptible(&ar->arSem)) {
545 return -ERESTARTSYS;
546 }
547
548 if (ar->bIsDestroyProgress || ar->arWlanState == WLAN_DISABLED) {
549 up(&ar->arSem);
550 return -EBUSY;
551 }
552
553 if (ar->arTxPending[wmi_get_control_ep(ar->arWmi)]) {
554 /*
555 * sleep until the command queue drains
556 */
557 wait_event_interruptible_timeout(arEvent,
558 ar->arTxPending[wmi_get_control_ep(ar->arWmi)] == 0, wmitimeout * HZ);
559 if (signal_pending(current)) {
560 return -EINTR;
561 }
562 }
563
564 if (!data->flags) {
565 arNetworkType = ar->arNetworkType;
566 #ifdef ATH6K_CONFIG_CFG80211
567 if (ar->arConnected) {
568 #endif /* ATH6K_CONFIG_CFG80211 */
569 ar6000_init_profile_info(ar);
570 #ifdef ATH6K_CONFIG_CFG80211
571 }
572 #endif /* ATH6K_CONFIG_CFG80211 */
573 ar->arNetworkType = arNetworkType;
574 }
575
576 /* Update the arNetworkType */
577 ar->arNetworkType = ar->arNextMode;
578
579
580 if ((prevMode != AP_NETWORK) &&
581 ((ar->arSsidLen) || ((ar->arSsidLen == 0) && ar->arConnected) || (!data->flags)))
582 {
583 if ((!data->flags) ||
584 (A_MEMCMP(ar->arSsid, ssid, ar->arSsidLen) != 0) ||
585 (ar->arSsidLen != (data->length - 1)))
586 {
587 /*
588 * SSID set previously or essid off has been issued.
589 *
590 * Disconnect Command is issued in two cases after wmi is ready
591 * (1) ssid is different from the previous setting
592 * (2) essid off has been issued
593 *
594 */
595 if (ar->arWmiReady == TRUE) {
596 reconnect_flag = 0;
597 status = wmi_setPmkid_cmd(ar->arWmi, ar->arBssid, NULL, 0);
598 status = wmi_disconnect_cmd(ar->arWmi);
599 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
600 ar->arSsidLen = 0;
601 if (ar->arSkipScan == FALSE) {
602 A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid));
603 }
604 if (!data->flags) {
605 up(&ar->arSem);
606 return 0;
607 }
608 } else {
609 up(&ar->arSem);
610 }
611 }
612 else
613 {
614 /*
615 * SSID is same, so we assume profile hasn't changed.
616 * If the interface is up and wmi is ready, we issue
617 * a reconnect cmd. Issue a reconnect only we are already
618 * connected.
619 */
620 if((ar->arConnected == TRUE) && (ar->arWmiReady == TRUE))
621 {
622 reconnect_flag = TRUE;
623 status = wmi_reconnect_cmd(ar->arWmi,ar->arReqBssid,
624 ar->arChannelHint);
625 up(&ar->arSem);
626 if (status != A_OK) {
627 return -EIO;
628 }
629 return 0;
630 }
631 else{
632 /*
633 * Dont return if connect is pending.
634 */
635 if(!(ar->arConnectPending)) {
636 up(&ar->arSem);
637 return 0;
638 }
639 }
640 }
641 }
642
643 ar->arSsidLen = data->length - 1;
644 A_MEMCPY(ar->arSsid, ssid, ar->arSsidLen);
645
646 if (ar6000_connect_to_ap(ar)!= A_OK) {
647 up(&ar->arSem);
648 return -EIO;
649 }else{
650 up(&ar->arSem);
651 }
652 return 0;
653 }
654
655 /* SIOCGIWESSID */
656 static int
657 ar6000_ioctl_giwessid(struct net_device *dev,
658 struct iw_request_info *info,
659 struct iw_point *data, char *essid)
660 {
661 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
662
663 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
664 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
665 return -EOPNOTSUPP;
666 }
667
668 if (ar->arWlanState == WLAN_DISABLED) {
669 return -EIO;
670 }
671
672 if (!ar->arSsidLen) {
673 return -EINVAL;
674 }
675
676 data->flags = 1;
677 data->length = ar->arSsidLen;
678 A_MEMCPY(essid, ar->arSsid, ar->arSsidLen);
679
680 return 0;
681 }
682
683
684 void ar6000_install_static_wep_keys(AR_SOFTC_T *ar)
685 {
686 A_UINT8 index;
687 A_UINT8 keyUsage;
688
689 for (index = WMI_MIN_KEY_INDEX; index <= WMI_MAX_KEY_INDEX; index++) {
690 if (ar->arWepKeyList[index].arKeyLen) {
691 keyUsage = GROUP_USAGE;
692 if (index == ar->arDefTxKeyIndex) {
693 keyUsage |= TX_USAGE;
694 }
695 wmi_addKey_cmd(ar->arWmi,
696 index,
697 WEP_CRYPT,
698 keyUsage,
699 ar->arWepKeyList[index].arKeyLen,
700 NULL,
701 ar->arWepKeyList[index].arKey, KEY_OP_INIT_VAL, NULL,
702 NO_SYNC_WMIFLAG);
703 }
704 }
705 }
706
707 /*
708 * SIOCSIWRATE
709 */
710 int
711 ar6000_ioctl_siwrate(struct net_device *dev,
712 struct iw_request_info *info,
713 struct iw_param *rrq, char *extra)
714 {
715 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
716 A_UINT32 kbps;
717 A_INT8 rate_idx;
718
719 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
720 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
721 return -EOPNOTSUPP;
722 }
723
724 if (rrq->fixed) {
725 kbps = rrq->value / 1000; /* rrq->value is in bps */
726 } else {
727 kbps = -1; /* -1 indicates auto rate */
728 }
729 if(kbps != -1 && wmi_validate_bitrate(ar->arWmi, kbps, &rate_idx) != A_OK)
730 {
731 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BitRate is not Valid %d\n", kbps));
732 return -EINVAL;
733 }
734 ar->arBitRate = kbps;
735 if(ar->arWmiReady == TRUE)
736 {
737 if (wmi_set_bitrate_cmd(ar->arWmi, kbps, -1, -1) != A_OK) {
738 return -EINVAL;
739 }
740 }
741 return 0;
742 }
743
744 /*
745 * SIOCGIWRATE
746 */
747 int
748 ar6000_ioctl_giwrate(struct net_device *dev,
749 struct iw_request_info *info,
750 struct iw_param *rrq, char *extra)
751 {
752 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
753 int ret = 0;
754
755 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
756 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
757 return -EOPNOTSUPP;
758 }
759
760 if (ar->bIsDestroyProgress) {
761 return -EBUSY;
762 }
763
764 if (ar->arWlanState == WLAN_DISABLED) {
765 return -EIO;
766 }
767
768 if ((ar->arNextMode != AP_NETWORK && !ar->arConnected) || ar->arWmiReady == FALSE) {
769 rrq->value = 1000 * 1000;
770 return 0;
771 }
772
773 if (down_interruptible(&ar->arSem)) {
774 return -ERESTARTSYS;
775 }
776
777 if (ar->bIsDestroyProgress || ar->arWlanState == WLAN_DISABLED) {
778 up(&ar->arSem);
779 return -EBUSY;
780 }
781
782 ar->arBitRate = 0xFFFF;
783 if (wmi_get_bitrate_cmd(ar->arWmi) != A_OK) {
784 up(&ar->arSem);
785 return -EIO;
786 }
787 wait_event_interruptible_timeout(arEvent, ar->arBitRate != 0xFFFF, wmitimeout * HZ);
788 if (signal_pending(current)) {
789 ret = -EINTR;
790 }
791 /* If the interface is down or wmi is not ready or the target is not
792 connected - return the value stored in the device structure */
793 if (!ret) {
794 if (ar->arBitRate == -1) {
795 rrq->fixed = TRUE;
796 rrq->value = 0;
797 } else {
798 rrq->value = ar->arBitRate * 1000;
799 }
800 }
801
802 up(&ar->arSem);
803
804 return ret;
805 }
806
807 /*
808 * SIOCSIWTXPOW
809 */
810 static int
811 ar6000_ioctl_siwtxpow(struct net_device *dev,
812 struct iw_request_info *info,
813 struct iw_param *rrq, char *extra)
814 {
815 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
816 A_UINT8 dbM;
817
818 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
819 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
820 return -EOPNOTSUPP;
821 }
822
823 if (ar->arWlanState == WLAN_DISABLED) {
824 return -EIO;
825 }
826
827 if (rrq->disabled) {
828 return -EOPNOTSUPP;
829 }
830
831 if (rrq->fixed) {
832 if (rrq->flags != IW_TXPOW_DBM) {
833 return -EOPNOTSUPP;
834 }
835 ar->arTxPwr= dbM = rrq->value;
836 ar->arTxPwrSet = TRUE;
837 } else {
838 ar->arTxPwr = dbM = 0;
839 ar->arTxPwrSet = FALSE;
840 }
841 if(ar->arWmiReady == TRUE)
842 {
843 AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("Set tx pwr cmd %d dbM\n", dbM));
844 wmi_set_txPwr_cmd(ar->arWmi, dbM);
845 }
846 return 0;
847 }
848
849 /*
850 * SIOCGIWTXPOW
851 */
852 int
853 ar6000_ioctl_giwtxpow(struct net_device *dev,
854 struct iw_request_info *info,
855 struct iw_param *rrq, char *extra)
856 {
857 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
858 int ret = 0;
859
860 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
861 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
862 return -EOPNOTSUPP;
863 }
864
865 if (ar->bIsDestroyProgress) {
866 return -EBUSY;
867 }
868
869 if (ar->arWlanState == WLAN_DISABLED) {
870 return -EIO;
871 }
872
873 if (down_interruptible(&ar->arSem)) {
874 return -ERESTARTSYS;
875 }
876
877 if (ar->bIsDestroyProgress) {
878 up(&ar->arSem);
879 return -EBUSY;
880 }
881
882 if((ar->arWmiReady == TRUE) && (ar->arConnected == TRUE))
883 {
884 ar->arTxPwr = 0;
885
886 if (wmi_get_txPwr_cmd(ar->arWmi) != A_OK) {
887 up(&ar->arSem);
888 return -EIO;
889 }
890
891 wait_event_interruptible_timeout(arEvent, ar->arTxPwr != 0, wmitimeout * HZ);
892
893 if (signal_pending(current)) {
894 ret = -EINTR;
895 }
896 }
897 /* If the interace is down or wmi is not ready or target is not connected
898 then return value stored in the device structure */
899
900 if (!ret) {
901 if (ar->arTxPwrSet == TRUE) {
902 rrq->fixed = TRUE;
903 }
904 rrq->value = ar->arTxPwr;
905 rrq->flags = IW_TXPOW_DBM;
906 //
907 // IWLIST need this flag to get TxPower
908 //
909 rrq->disabled = 0;
910 }
911
912 up(&ar->arSem);
913
914 return ret;
915 }
916
917 /*
918 * SIOCSIWRETRY
919 * since iwconfig only provides us with one max retry value, we use it
920 * to apply to data frames of the BE traffic class.
921 */
922 static int
923 ar6000_ioctl_siwretry(struct net_device *dev,
924 struct iw_request_info *info,
925 struct iw_param *rrq, char *extra)
926 {
927 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
928
929 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
930 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
931 return -EOPNOTSUPP;
932 }
933
934 if (ar->arWlanState == WLAN_DISABLED) {
935 return -EIO;
936 }
937
938 if (rrq->disabled) {
939 return -EOPNOTSUPP;
940 }
941
942 if ((rrq->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT) {
943 return -EOPNOTSUPP;
944 }
945
946 if ( !(rrq->value >= WMI_MIN_RETRIES) || !(rrq->value <= WMI_MAX_RETRIES)) {
947 return - EINVAL;
948 }
949 if(ar->arWmiReady == TRUE)
950 {
951 if (wmi_set_retry_limits_cmd(ar->arWmi, DATA_FRAMETYPE, WMM_AC_BE,
952 rrq->value, 0) != A_OK){
953 return -EINVAL;
954 }
955 }
956 ar->arMaxRetries = rrq->value;
957 return 0;
958 }
959
960 /*
961 * SIOCGIWRETRY
962 */
963 static int
964 ar6000_ioctl_giwretry(struct net_device *dev,
965 struct iw_request_info *info,
966 struct iw_param *rrq, char *extra)
967 {
968 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
969
970 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
971 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
972 return -EOPNOTSUPP;
973 }
974
975 if (ar->arWlanState == WLAN_DISABLED) {
976 return -EIO;
977 }
978
979 rrq->disabled = 0;
980 switch (rrq->flags & IW_RETRY_TYPE) {
981 case IW_RETRY_LIFETIME:
982 return -EOPNOTSUPP;
983 break;
984 case IW_RETRY_LIMIT:
985 rrq->flags = IW_RETRY_LIMIT;
986 switch (rrq->flags & IW_RETRY_MODIFIER) {
987 case IW_RETRY_MIN:
988 rrq->flags |= IW_RETRY_MIN;
989 rrq->value = WMI_MIN_RETRIES;
990 break;
991 case IW_RETRY_MAX:
992 rrq->flags |= IW_RETRY_MAX;
993 rrq->value = ar->arMaxRetries;
994 break;
995 }
996 break;
997 }
998 return 0;
999 }
1000
1001 /*
1002 * SIOCSIWENCODE
1003 */
1004 static int
1005 ar6000_ioctl_siwencode(struct net_device *dev,
1006 struct iw_request_info *info,
1007 struct iw_point *erq, char *keybuf)
1008 {
1009 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1010 int index;
1011 A_INT32 auth = 0;
1012
1013 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
1014 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
1015 return -EOPNOTSUPP;
1016 }
1017
1018 if(ar->arNextMode != AP_NETWORK) {
1019 /*
1020 * Static WEP Keys should be configured before setting the SSID
1021 */
1022 if (ar->arSsid[0] && erq->length) {
1023 return -EIO;
1024 }
1025 }
1026
1027 if (ar->arWlanState == WLAN_DISABLED) {
1028 return -EIO;
1029 }
1030
1031 index = erq->flags & IW_ENCODE_INDEX;
1032
1033 if (index && (((index - 1) < WMI_MIN_KEY_INDEX) ||
1034 ((index - 1) > WMI_MAX_KEY_INDEX)))
1035 {
1036 return -EIO;
1037 }
1038
1039 if (erq->flags & IW_ENCODE_DISABLED) {
1040 /*
1041 * Encryption disabled
1042 */
1043 if (index) {
1044 /*
1045 * If key index was specified then clear the specified key
1046 */
1047 index--;
1048 A_MEMZERO(ar->arWepKeyList[index].arKey,
1049 sizeof(ar->arWepKeyList[index].arKey));
1050 ar->arWepKeyList[index].arKeyLen = 0;
1051 }
1052 ar->arDot11AuthMode = OPEN_AUTH;
1053 ar->arPairwiseCrypto = NONE_CRYPT;
1054 ar->arGroupCrypto = NONE_CRYPT;
1055 ar->arAuthMode = NONE_AUTH;
1056 } else {
1057 /*
1058 * Enabling WEP encryption
1059 */
1060 if (index) {
1061 index--; /* keyindex is off base 1 in iwconfig */
1062 }
1063
1064 if (erq->flags & IW_ENCODE_OPEN) {
1065 auth |= OPEN_AUTH;
1066 ar->arDefTxKeyIndex = index;
1067 }
1068 if (erq->flags & IW_ENCODE_RESTRICTED) {
1069 auth |= SHARED_AUTH;
1070 }
1071
1072 if (!auth) {
1073 auth = OPEN_AUTH;
1074 }
1075
1076 if (erq->length) {
1077 if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(erq->length)) {
1078 return -EIO;
1079 }
1080
1081 A_MEMZERO(ar->arWepKeyList[index].arKey,
1082 sizeof(ar->arWepKeyList[index].arKey));
1083 A_MEMCPY(ar->arWepKeyList[index].arKey, keybuf, erq->length);
1084 ar->arWepKeyList[index].arKeyLen = erq->length;
1085 ar->arDot11AuthMode = auth;
1086 } else {
1087 if (ar->arWepKeyList[index].arKeyLen == 0) {
1088 return -EIO;
1089 }
1090 ar->arDefTxKeyIndex = index;
1091
1092 if(ar->arSsidLen && ar->arWepKeyList[index].arKeyLen) {
1093 wmi_addKey_cmd(ar->arWmi,
1094 index,
1095 WEP_CRYPT,
1096 GROUP_USAGE | TX_USAGE,
1097 ar->arWepKeyList[index].arKeyLen,
1098 NULL,
1099 ar->arWepKeyList[index].arKey, KEY_OP_INIT_VAL, NULL,
1100 NO_SYNC_WMIFLAG);
1101 }
1102 }
1103
1104 ar->arPairwiseCrypto = WEP_CRYPT;
1105 ar->arGroupCrypto = WEP_CRYPT;
1106 ar->arAuthMode = NONE_AUTH;
1107 }
1108
1109 if(ar->arNextMode != AP_NETWORK) {
1110 /*
1111 * profile has changed. Erase ssid to signal change
1112 */
1113 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
1114 ar->arSsidLen = 0;
1115 }
1116 ar->ap_profile_flag = 1; /* There is a change in profile */
1117 return 0;
1118 }
1119
1120 static int
1121 ar6000_ioctl_giwencode(struct net_device *dev,
1122 struct iw_request_info *info,
1123 struct iw_point *erq, char *key)
1124 {
1125 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1126 A_UINT8 keyIndex;
1127 struct ar_wep_key *wk;
1128
1129 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
1130 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
1131 return -EOPNOTSUPP;
1132 }
1133
1134 if (ar->arWlanState == WLAN_DISABLED) {
1135 return -EIO;
1136 }
1137
1138 if (ar->arPairwiseCrypto == NONE_CRYPT) {
1139 erq->length = 0;
1140 erq->flags = IW_ENCODE_DISABLED;
1141 } else {
1142 if (ar->arPairwiseCrypto == WEP_CRYPT) {
1143 /* get the keyIndex */
1144 keyIndex = erq->flags & IW_ENCODE_INDEX;
1145 if (0 == keyIndex) {
1146 keyIndex = ar->arDefTxKeyIndex;
1147 } else if ((keyIndex - 1 < WMI_MIN_KEY_INDEX) ||
1148 (keyIndex - 1 > WMI_MAX_KEY_INDEX))
1149 {
1150 keyIndex = WMI_MIN_KEY_INDEX;
1151 } else {
1152 keyIndex--;
1153 }
1154 erq->flags = keyIndex + 1;
1155 erq->flags &= ~IW_ENCODE_DISABLED;
1156 wk = &ar->arWepKeyList[keyIndex];
1157 if (erq->length > wk->arKeyLen) {
1158 erq->length = wk->arKeyLen;
1159 }
1160 if (wk->arKeyLen) {
1161 A_MEMCPY(key, wk->arKey, erq->length);
1162 }
1163 } else {
1164 erq->flags &= ~IW_ENCODE_DISABLED;
1165 if (ar->user_saved_keys.keyOk) {
1166 erq->length = ar->user_saved_keys.ucast_ik.ik_keylen;
1167 if (erq->length) {
1168 A_MEMCPY(key, ar->user_saved_keys.ucast_ik.ik_keydata, erq->length);
1169 }
1170 } else {
1171 erq->length = 1; // not really printing any key but let iwconfig know enc is on
1172 }
1173 }
1174
1175 if (ar->arDot11AuthMode & OPEN_AUTH) {
1176 erq->flags |= IW_ENCODE_OPEN;
1177 }
1178 if (ar->arDot11AuthMode & SHARED_AUTH) {
1179 erq->flags |= IW_ENCODE_RESTRICTED;
1180 }
1181 }
1182
1183 return 0;
1184 }
1185
1186 #if WIRELESS_EXT >= 18
1187 /*
1188 * SIOCSIWGENIE
1189 */
1190 static int
1191 ar6000_ioctl_siwgenie(struct net_device *dev,
1192 struct iw_request_info *info,
1193 struct iw_point *erq, char *extra)
1194 {
1195 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1196
1197 #ifdef WAPI_ENABLE
1198 A_UINT8 *ie = erq->pointer;
1199 A_UINT8 ie_type = ie[0];
1200 A_UINT16 ie_length = erq->length;
1201 A_UINT8 wapi_ie[128];
1202 #endif
1203
1204 if (ar->arWmiReady == FALSE) {
1205 return -EIO;
1206 }
1207 #ifdef WAPI_ENABLE
1208 if (ie_type == IEEE80211_ELEMID_WAPI) {
1209 if (ie_length > 0) {
1210 if (copy_from_user(wapi_ie, ie, ie_length)) {
1211 return -EIO;
1212 }
1213 }
1214 wmi_set_appie_cmd(ar->arWmi, WMI_FRAME_ASSOC_REQ, ie_length, wapi_ie);
1215 } else if (ie_length == 0) {
1216 wmi_set_appie_cmd(ar->arWmi, WMI_FRAME_ASSOC_REQ, ie_length, wapi_ie);
1217 }
1218 #endif
1219 return 0;
1220 }
1221
1222
1223 /*
1224 * SIOCGIWGENIE
1225 */
1226 static int
1227 ar6000_ioctl_giwgenie(struct net_device *dev,
1228 struct iw_request_info *info,
1229 struct iw_point *erq, char *extra)
1230 {
1231 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1232
1233 if (ar->arWmiReady == FALSE) {
1234 return -EIO;
1235 }
1236 erq->length = 0;
1237 erq->flags = 0;
1238
1239 return 0;
1240 }
1241
1242 /*
1243 * SIOCSIWAUTH
1244 */
1245 static int
1246 ar6000_ioctl_siwauth(struct net_device *dev,
1247 struct iw_request_info *info,
1248 struct iw_param *data, char *extra)
1249 {
1250 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1251
1252 A_BOOL profChanged;
1253 A_UINT16 param;
1254 A_INT32 ret;
1255 A_INT32 value;
1256
1257 if (ar->arWmiReady == FALSE) {
1258 return -EIO;
1259 }
1260
1261 if (ar->arWlanState == WLAN_DISABLED) {
1262 return -EIO;
1263 }
1264
1265 param = data->flags & IW_AUTH_INDEX;
1266 value = data->value;
1267 profChanged = TRUE;
1268 ret = 0;
1269
1270 switch (param) {
1271 case IW_AUTH_WPA_VERSION:
1272 if (value & IW_AUTH_WPA_VERSION_DISABLED) {
1273 ar->arAuthMode = NONE_AUTH;
1274 } else if (value & IW_AUTH_WPA_VERSION_WPA) {
1275 ar->arAuthMode = WPA_AUTH;
1276 } else if (value & IW_AUTH_WPA_VERSION_WPA2) {
1277 ar->arAuthMode = WPA2_AUTH;
1278 } else {
1279 ret = -1;
1280 profChanged = FALSE;
1281 }
1282 break;
1283 case IW_AUTH_CIPHER_PAIRWISE:
1284 if (value & IW_AUTH_CIPHER_NONE) {
1285 ar->arPairwiseCrypto = NONE_CRYPT;
1286 ar->arPairwiseCryptoLen = 0;
1287 } else if (value & IW_AUTH_CIPHER_WEP40) {
1288 ar->arPairwiseCrypto = WEP_CRYPT;
1289 ar->arPairwiseCryptoLen = 5;
1290 } else if (value & IW_AUTH_CIPHER_TKIP) {
1291 ar->arPairwiseCrypto = TKIP_CRYPT;
1292 ar->arPairwiseCryptoLen = 0;
1293 } else if (value & IW_AUTH_CIPHER_CCMP) {
1294 ar->arPairwiseCrypto = AES_CRYPT;
1295 ar->arPairwiseCryptoLen = 0;
1296 } else if (value & IW_AUTH_CIPHER_WEP104) {
1297 ar->arPairwiseCrypto = WEP_CRYPT;
1298 ar->arPairwiseCryptoLen = 13;
1299 } else {
1300 ret = -1;
1301 profChanged = FALSE;
1302 }
1303 break;
1304 case IW_AUTH_CIPHER_GROUP:
1305 if (value & IW_AUTH_CIPHER_NONE) {
1306 ar->arGroupCrypto = NONE_CRYPT;
1307 ar->arGroupCryptoLen = 0;
1308 } else if (value & IW_AUTH_CIPHER_WEP40) {
1309 ar->arGroupCrypto = WEP_CRYPT;
1310 ar->arGroupCryptoLen = 5;
1311 } else if (value & IW_AUTH_CIPHER_TKIP) {
1312 ar->arGroupCrypto = TKIP_CRYPT;
1313 ar->arGroupCryptoLen = 0;
1314 } else if (value & IW_AUTH_CIPHER_CCMP) {
1315 ar->arGroupCrypto = AES_CRYPT;
1316 ar->arGroupCryptoLen = 0;
1317 } else if (value & IW_AUTH_CIPHER_WEP104) {
1318 ar->arGroupCrypto = WEP_CRYPT;
1319 ar->arGroupCryptoLen = 13;
1320 } else {
1321 ret = -1;
1322 profChanged = FALSE;
1323 }
1324 break;
1325 case IW_AUTH_KEY_MGMT:
1326 if (value & IW_AUTH_KEY_MGMT_PSK) {
1327 if (WPA_AUTH == ar->arAuthMode) {
1328 ar->arAuthMode = WPA_PSK_AUTH;
1329 } else if (WPA2_AUTH == ar->arAuthMode) {
1330 ar->arAuthMode = WPA2_PSK_AUTH;
1331 } else {
1332 ret = -1;
1333 }
1334 } else if (!(value & IW_AUTH_KEY_MGMT_802_1X)) {
1335 ar->arAuthMode = NONE_AUTH;
1336 }
1337 break;
1338 case IW_AUTH_TKIP_COUNTERMEASURES:
1339 wmi_set_tkip_countermeasures_cmd(ar->arWmi, value);
1340 profChanged = FALSE;
1341 break;
1342 case IW_AUTH_DROP_UNENCRYPTED:
1343 profChanged = FALSE;
1344 break;
1345 case IW_AUTH_80211_AUTH_ALG:
1346 ar->arDot11AuthMode = 0;
1347 if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
1348 ar->arDot11AuthMode |= OPEN_AUTH;
1349 }
1350 if (value & IW_AUTH_ALG_SHARED_KEY) {
1351 ar->arDot11AuthMode |= SHARED_AUTH;
1352 }
1353 if (value & IW_AUTH_ALG_LEAP) {
1354 ar->arDot11AuthMode = LEAP_AUTH;
1355 }
1356 if(ar->arDot11AuthMode == 0) {
1357 ret = -1;
1358 profChanged = FALSE;
1359 }
1360 break;
1361 case IW_AUTH_WPA_ENABLED:
1362 if (!value) {
1363 ar->arAuthMode = NONE_AUTH;
1364 /* when the supplicant is stopped, it calls this
1365 * handler with value=0. The followings need to be
1366 * reset if the STA were to connect again
1367 * without security
1368 */
1369 ar->arDot11AuthMode = OPEN_AUTH;
1370 ar->arPairwiseCrypto = NONE_CRYPT;
1371 ar->arPairwiseCryptoLen = 0;
1372 ar->arGroupCrypto = NONE_CRYPT;
1373 ar->arGroupCryptoLen = 0;
1374 }
1375 break;
1376 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1377 profChanged = FALSE;
1378 break;
1379 case IW_AUTH_ROAMING_CONTROL:
1380 profChanged = FALSE;
1381 break;
1382 case IW_AUTH_PRIVACY_INVOKED:
1383 if (!value) {
1384 ar->arPairwiseCrypto = NONE_CRYPT;
1385 ar->arPairwiseCryptoLen = 0;
1386 ar->arGroupCrypto = NONE_CRYPT;
1387 ar->arGroupCryptoLen = 0;
1388 }
1389 break;
1390 #ifdef WAPI_ENABLE
1391 case IW_AUTH_WAPI_ENABLED:
1392 ar->arWapiEnable = value;
1393 break;
1394 #endif
1395 default:
1396 ret = -1;
1397 profChanged = FALSE;
1398 break;
1399 }
1400
1401 if (profChanged == TRUE) {
1402 /*
1403 * profile has changed. Erase ssid to signal change
1404 */
1405 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
1406 ar->arSsidLen = 0;
1407 }
1408
1409 return ret;
1410 }
1411
1412
1413 /*
1414 * SIOCGIWAUTH
1415 */
1416 static int
1417 ar6000_ioctl_giwauth(struct net_device *dev,
1418 struct iw_request_info *info,
1419 struct iw_param *data, char *extra)
1420 {
1421 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1422 A_UINT16 param;
1423 A_INT32 ret;
1424
1425 if (ar->arWmiReady == FALSE) {
1426 return -EIO;
1427 }
1428
1429 if (ar->arWlanState == WLAN_DISABLED) {
1430 return -EIO;
1431 }
1432
1433 param = data->flags & IW_AUTH_INDEX;
1434 ret = 0;
1435 data->value = 0;
1436
1437
1438 switch (param) {
1439 case IW_AUTH_WPA_VERSION:
1440 if (ar->arAuthMode == NONE_AUTH) {
1441 data->value |= IW_AUTH_WPA_VERSION_DISABLED;
1442 } else if (ar->arAuthMode == WPA_AUTH) {
1443 data->value |= IW_AUTH_WPA_VERSION_WPA;
1444 } else if (ar->arAuthMode == WPA2_AUTH) {
1445 data->value |= IW_AUTH_WPA_VERSION_WPA2;
1446 } else {
1447 ret = -1;
1448 }
1449 break;
1450 case IW_AUTH_CIPHER_PAIRWISE:
1451 if (ar->arPairwiseCrypto == NONE_CRYPT) {
1452 data->value |= IW_AUTH_CIPHER_NONE;
1453 } else if (ar->arPairwiseCrypto == WEP_CRYPT) {
1454 if (ar->arPairwiseCryptoLen == 13) {
1455 data->value |= IW_AUTH_CIPHER_WEP104;
1456 } else {
1457 data->value |= IW_AUTH_CIPHER_WEP40;
1458 }
1459 } else if (ar->arPairwiseCrypto == TKIP_CRYPT) {
1460 data->value |= IW_AUTH_CIPHER_TKIP;
1461 } else if (ar->arPairwiseCrypto == AES_CRYPT) {
1462 data->value |= IW_AUTH_CIPHER_CCMP;
1463 } else {
1464 ret = -1;
1465 }
1466 break;
1467 case IW_AUTH_CIPHER_GROUP:
1468 if (ar->arGroupCrypto == NONE_CRYPT) {
1469 data->value |= IW_AUTH_CIPHER_NONE;
1470 } else if (ar->arGroupCrypto == WEP_CRYPT) {
1471 if (ar->arGroupCryptoLen == 13) {
1472 data->value |= IW_AUTH_CIPHER_WEP104;
1473 } else {
1474 data->value |= IW_AUTH_CIPHER_WEP40;
1475 }
1476 } else if (ar->arGroupCrypto == TKIP_CRYPT) {
1477 data->value |= IW_AUTH_CIPHER_TKIP;
1478 } else if (ar->arGroupCrypto == AES_CRYPT) {
1479 data->value |= IW_AUTH_CIPHER_CCMP;
1480 } else {
1481 ret = -1;
1482 }
1483 break;
1484 case IW_AUTH_KEY_MGMT:
1485 if ((ar->arAuthMode == WPA_PSK_AUTH) ||
1486 (ar->arAuthMode == WPA2_PSK_AUTH)) {
1487 data->value |= IW_AUTH_KEY_MGMT_PSK;
1488 } else if ((ar->arAuthMode == WPA_AUTH) ||
1489 (ar->arAuthMode == WPA2_AUTH)) {
1490 data->value |= IW_AUTH_KEY_MGMT_802_1X;
1491 }
1492 break;
1493 case IW_AUTH_TKIP_COUNTERMEASURES:
1494 // TODO. Save countermeassure enable/disable
1495 data->value = 0;
1496 break;
1497 case IW_AUTH_DROP_UNENCRYPTED:
1498 break;
1499 case IW_AUTH_80211_AUTH_ALG:
1500 if (ar->arDot11AuthMode == OPEN_AUTH) {
1501 data->value |= IW_AUTH_ALG_OPEN_SYSTEM;
1502 } else if (ar->arDot11AuthMode == SHARED_AUTH) {
1503 data->value |= IW_AUTH_ALG_SHARED_KEY;
1504 } else if (ar->arDot11AuthMode == LEAP_AUTH) {
1505 data->value |= IW_AUTH_ALG_LEAP;
1506 } else {
1507 ret = -1;
1508 }
1509 break;
1510 case IW_AUTH_WPA_ENABLED:
1511 if (ar->arAuthMode == NONE_AUTH) {
1512 data->value = 0;
1513 } else {
1514 data->value = 1;
1515 }
1516 break;
1517 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1518 break;
1519 case IW_AUTH_ROAMING_CONTROL:
1520 break;
1521 case IW_AUTH_PRIVACY_INVOKED:
1522 if (ar->arPairwiseCrypto == NONE_CRYPT) {
1523 data->value = 0;
1524 } else {
1525 data->value = 1;
1526 }
1527 break;
1528 #ifdef WAPI_ENABLE
1529 case IW_AUTH_WAPI_ENABLED:
1530 data->value = ar->arWapiEnable;
1531 break;
1532 #endif
1533 default:
1534 ret = -1;
1535 break;
1536 }
1537
1538 return 0;
1539 }
1540
1541 /*
1542 * SIOCSIWPMKSA
1543 */
1544 static int
1545 ar6000_ioctl_siwpmksa(struct net_device *dev,
1546 struct iw_request_info *info,
1547 struct iw_point *data, char *extra)
1548 {
1549 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1550 A_INT32 ret;
1551 A_STATUS status;
1552 struct iw_pmksa *pmksa;
1553
1554 pmksa = (struct iw_pmksa *)extra;
1555
1556 if (ar->arWmiReady == FALSE) {
1557 return -EIO;
1558 }
1559
1560 ret = 0;
1561 status = A_OK;
1562
1563 switch (pmksa->cmd) {
1564 case IW_PMKSA_ADD:
1565 status = wmi_setPmkid_cmd(ar->arWmi, (A_UINT8*)pmksa->bssid.sa_data, pmksa->pmkid, TRUE);
1566 break;
1567 case IW_PMKSA_REMOVE:
1568 status = wmi_setPmkid_cmd(ar->arWmi, (A_UINT8*)pmksa->bssid.sa_data, pmksa->pmkid, FALSE);
1569 break;
1570 case IW_PMKSA_FLUSH:
1571 if (ar->arConnected == TRUE) {
1572 status = wmi_setPmkid_cmd(ar->arWmi, ar->arBssid, NULL, 0);
1573 }
1574 break;
1575 default:
1576 ret=-1;
1577 break;
1578 }
1579 if (status != A_OK) {
1580 ret = -1;
1581 }
1582
1583 return ret;
1584 }
1585
1586 #ifdef WAPI_ENABLE
1587
1588 #define PN_INIT 0x5c365c36
1589
1590 static int ar6000_set_wapi_key(struct net_device *dev,
1591 struct iw_request_info *info,
1592 struct iw_point *erq, char *extra)
1593 {
1594 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1595 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1596 KEY_USAGE keyUsage = 0;
1597 A_INT32 keyLen;
1598 A_UINT8 *keyData;
1599 A_INT32 index;
1600 A_UINT32 *PN;
1601 A_INT32 i;
1602 A_STATUS status;
1603 A_UINT8 wapiKeyRsc[16];
1604 CRYPTO_TYPE keyType = WAPI_CRYPT;
1605 const A_UINT8 broadcastMac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1606
1607 index = erq->flags & IW_ENCODE_INDEX;
1608 if (index && (((index - 1) < WMI_MIN_KEY_INDEX) ||
1609 ((index - 1) > WMI_MAX_KEY_INDEX))) {
1610 return -EIO;
1611 }
1612
1613 index--;
1614 if (index < 0 || index > 4) {
1615 return -EIO;
1616 }
1617 keyData = (A_UINT8 *)(ext + 1);
1618 keyLen = erq->length - sizeof(struct iw_encode_ext);
1619 A_MEMCPY(wapiKeyRsc, ext->tx_seq, sizeof(wapiKeyRsc));
1620
1621 if (A_MEMCMP(ext->addr.sa_data, broadcastMac, sizeof(broadcastMac)) == 0) {
1622 keyUsage |= GROUP_USAGE;
1623 PN = (A_UINT32 *)wapiKeyRsc;
1624 for (i = 0; i < 4; i++) {
1625 PN[i] = PN_INIT;
1626 }
1627 } else {
1628 keyUsage |= PAIRWISE_USAGE;
1629 }
1630 status = wmi_addKey_cmd(ar->arWmi,
1631 index,
1632 keyType,
1633 keyUsage,
1634 keyLen,
1635 wapiKeyRsc,
1636 keyData,
1637 KEY_OP_INIT_WAPIPN,
1638 NULL,
1639 SYNC_BEFORE_WMIFLAG);
1640 if (A_OK != status) {
1641 return -EIO;
1642 }
1643 return 0;
1644 }
1645
1646 #endif
1647
1648 /*
1649 * SIOCSIWENCODEEXT
1650 */
1651 static int
1652 ar6000_ioctl_siwencodeext(struct net_device *dev,
1653 struct iw_request_info *info,
1654 struct iw_point *erq, char *extra)
1655 {
1656 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1657 A_INT32 index;
1658 struct iw_encode_ext *ext;
1659 KEY_USAGE keyUsage;
1660 A_INT32 keyLen;
1661 A_UINT8 *keyData;
1662 A_UINT8 keyRsc[8];
1663 A_STATUS status;
1664 CRYPTO_TYPE keyType;
1665 #ifdef USER_KEYS
1666 struct ieee80211req_key ik;
1667 #endif /* USER_KEYS */
1668
1669 if (ar->arWlanState == WLAN_DISABLED) {
1670 return -EIO;
1671 }
1672
1673 #ifdef USER_KEYS
1674 ar->user_saved_keys.keyOk = FALSE;
1675 #endif /* USER_KEYS */
1676
1677 index = erq->flags & IW_ENCODE_INDEX;
1678
1679 if (index && (((index - 1) < WMI_MIN_KEY_INDEX) ||
1680 ((index - 1) > WMI_MAX_KEY_INDEX)))
1681 {
1682 return -EIO;
1683 }
1684
1685 ext = (struct iw_encode_ext *)extra;
1686 if (erq->flags & IW_ENCODE_DISABLED) {
1687 /*
1688 * Encryption disabled
1689 */
1690 if (index) {
1691 /*
1692 * If key index was specified then clear the specified key
1693 */
1694 index--;
1695 A_MEMZERO(ar->arWepKeyList[index].arKey,
1696 sizeof(ar->arWepKeyList[index].arKey));
1697 ar->arWepKeyList[index].arKeyLen = 0;
1698 }
1699 } else {
1700 /*
1701 * Enabling WEP encryption
1702 */
1703 if (index) {
1704 index--; /* keyindex is off base 1 in iwconfig */
1705 }
1706
1707 keyUsage = 0;
1708 keyLen = erq->length - sizeof(struct iw_encode_ext);
1709
1710 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
1711 keyUsage = TX_USAGE;
1712 ar->arDefTxKeyIndex = index;
1713 // Just setting the key index
1714 if (keyLen == 0) {
1715 return 0;
1716 }
1717 }
1718
1719 if (keyLen <= 0) {
1720 return -EIO;
1721 }
1722
1723 /* key follows iw_encode_ext */
1724 keyData = (A_UINT8 *)(ext + 1);
1725
1726 switch (ext->alg) {
1727 case IW_ENCODE_ALG_WEP:
1728 keyType = WEP_CRYPT;
1729 #ifdef USER_KEYS
1730 ik.ik_type = IEEE80211_CIPHER_WEP;
1731 #endif /* USER_KEYS */
1732 if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(keyLen)) {
1733 return -EIO;
1734 }
1735
1736 /* Check whether it is static wep. */
1737 if (!ar->arConnected) {
1738 A_MEMZERO(ar->arWepKeyList[index].arKey,
1739 sizeof(ar->arWepKeyList[index].arKey));
1740 A_MEMCPY(ar->arWepKeyList[index].arKey, keyData, keyLen);
1741 ar->arWepKeyList[index].arKeyLen = keyLen;
1742
1743 return 0;
1744 }
1745 break;
1746 case IW_ENCODE_ALG_TKIP:
1747 keyType = TKIP_CRYPT;
1748 #ifdef USER_KEYS
1749 ik.ik_type = IEEE80211_CIPHER_TKIP;
1750 #endif /* USER_KEYS */
1751 break;
1752 case IW_ENCODE_ALG_CCMP:
1753 keyType = AES_CRYPT;
1754 #ifdef USER_KEYS
1755 ik.ik_type = IEEE80211_CIPHER_AES_CCM;
1756 #endif /* USER_KEYS */
1757 break;
1758 #ifdef WAPI_ENABLE
1759 case IW_ENCODE_ALG_SM4:
1760 if (ar->arWapiEnable) {
1761 return ar6000_set_wapi_key(dev, info, erq, extra);
1762 } else {
1763 return -EIO;
1764 }
1765 #endif
1766 case IW_ENCODE_ALG_PMK:
1767 ar->arConnectCtrlFlags |= CONNECT_DO_WPA_OFFLOAD;
1768 return wmi_set_pmk_cmd(ar->arWmi, keyData);
1769 default:
1770 return -EIO;
1771 }
1772
1773
1774 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
1775 keyUsage |= GROUP_USAGE;
1776 } else {
1777 keyUsage |= PAIRWISE_USAGE;
1778 }
1779
1780 if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
1781 A_MEMCPY(keyRsc, ext->rx_seq, sizeof(keyRsc));
1782 } else {
1783 A_MEMZERO(keyRsc, sizeof(keyRsc));
1784 }
1785
1786 if (((WPA_PSK_AUTH == ar->arAuthMode) || (WPA2_PSK_AUTH == ar->arAuthMode)) &&
1787 (GROUP_USAGE & keyUsage))
1788 {
1789 A_UNTIMEOUT(&ar->disconnect_timer);
1790 }
1791
1792 status = wmi_addKey_cmd(ar->arWmi, index, keyType, keyUsage,
1793 keyLen, keyRsc,
1794 keyData, KEY_OP_INIT_VAL,
1795 (A_UINT8*)ext->addr.sa_data,
1796 SYNC_BOTH_WMIFLAG);
1797 if (status != A_OK) {
1798 return -EIO;
1799 }
1800
1801 #ifdef USER_KEYS
1802 ik.ik_keyix = index;
1803 ik.ik_keylen = keyLen;
1804 memcpy(ik.ik_keydata, keyData, keyLen);
1805 memcpy(&ik.ik_keyrsc, keyRsc, sizeof(keyRsc));
1806 memcpy(ik.ik_macaddr, ext->addr.sa_data, ETH_ALEN);
1807 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
1808 memcpy(&ar->user_saved_keys.bcast_ik, &ik,
1809 sizeof(struct ieee80211req_key));
1810 } else {
1811 memcpy(&ar->user_saved_keys.ucast_ik, &ik,
1812 sizeof(struct ieee80211req_key));
1813 }
1814 ar->user_saved_keys.keyOk = TRUE;
1815 #endif /* USER_KEYS */
1816 }
1817
1818
1819 return 0;
1820 }
1821
1822 /*
1823 * SIOCGIWENCODEEXT
1824 */
1825 static int
1826 ar6000_ioctl_giwencodeext(struct net_device *dev,
1827 struct iw_request_info *info,
1828 struct iw_point *erq, char *extra)
1829 {
1830 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1831
1832 if (ar->arWlanState == WLAN_DISABLED) {
1833 return -EIO;
1834 }
1835
1836 if (ar->arPairwiseCrypto == NONE_CRYPT) {
1837 erq->length = 0;
1838 erq->flags = IW_ENCODE_DISABLED;
1839 } else {
1840 erq->length = 0;
1841 }
1842
1843 return 0;
1844 }
1845 #endif // WIRELESS_EXT >= 18
1846
1847 #if WIRELESS_EXT > 20
1848 static int ar6000_ioctl_siwpower(struct net_device *dev,
1849 struct iw_request_info *info,
1850 union iwreq_data *wrqu, char *extra)
1851 {
1852 #ifndef ATH6K_CONFIG_OTA_MODE
1853 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1854 WMI_POWER_MODE power_mode;
1855
1856 if (ar->arWmiReady == FALSE) {
1857 return -EIO;
1858 }
1859
1860 if (ar->arWlanState == WLAN_DISABLED) {
1861 return -EIO;
1862 }
1863
1864 if (wrqu->power.disabled)
1865 power_mode = MAX_PERF_POWER;
1866 else
1867 power_mode = REC_POWER;
1868
1869 if (wmi_powermode_cmd(ar->arWmi, power_mode) < 0)
1870 return -EIO;
1871 #endif
1872 return 0;
1873 }
1874
1875 static int ar6000_ioctl_giwpower(struct net_device *dev,
1876 struct iw_request_info *info,
1877 union iwreq_data *wrqu, char *extra)
1878 {
1879 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1880 WMI_POWER_MODE power_mode;
1881
1882 if (ar->arWmiReady == FALSE) {
1883 return -EIO;
1884 }
1885
1886 if (ar->arWlanState == WLAN_DISABLED) {
1887 return -EIO;
1888 }
1889
1890 power_mode = wmi_get_power_mode_cmd(ar->arWmi);
1891
1892 if (power_mode == MAX_PERF_POWER)
1893 wrqu->power.disabled = 1;
1894 else
1895 wrqu->power.disabled = 0;
1896
1897 return 0;
1898 }
1899 #endif // WIRELESS_EXT > 20
1900
1901 /*
1902 * SIOCGIWNAME
1903 */
1904 int
1905 ar6000_ioctl_giwname(struct net_device *dev,
1906 struct iw_request_info *info,
1907 char *name, char *extra)
1908 {
1909 A_UINT8 capability;
1910 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1911
1912 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
1913 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
1914 return -EOPNOTSUPP;
1915 }
1916
1917 if (ar->arWlanState == WLAN_DISABLED) {
1918 return -EIO;
1919 }
1920
1921 capability = ar->arPhyCapability;
1922 if(ar->arNetworkType == INFRA_NETWORK && ar->arConnected) {
1923 bss_t *bss = wmi_find_node(ar->arWmi, ar->arBssid);
1924 if (bss) {
1925 capability = get_bss_phy_capability(bss);
1926 wmi_node_return(ar->arWmi, bss);
1927 }
1928 }
1929 switch (capability) {
1930 case (WMI_11A_CAPABILITY):
1931 strncpy(name, "AR6000 802.11a", IFNAMSIZ);
1932 break;
1933 case (WMI_11G_CAPABILITY):
1934 strncpy(name, "AR6000 802.11g", IFNAMSIZ);
1935 break;
1936 case (WMI_11AG_CAPABILITY):
1937 strncpy(name, "AR6000 802.11ag", IFNAMSIZ);
1938 break;
1939 case (WMI_11NA_CAPABILITY):
1940 strncpy(name, "AR6000 802.11na", IFNAMSIZ);
1941 break;
1942 case (WMI_11NG_CAPABILITY):
1943 strncpy(name, "AR6000 802.11ng", IFNAMSIZ);
1944 break;
1945 case (WMI_11NAG_CAPABILITY):
1946 strncpy(name, "AR6000 802.11nag", IFNAMSIZ);
1947 break;
1948 default:
1949 strncpy(name, "AR6000 802.11b", IFNAMSIZ);
1950 break;
1951 }
1952
1953 return 0;
1954 }
1955
1956 /*
1957 * SIOCSIWFREQ
1958 */
1959 int
1960 ar6000_ioctl_siwfreq(struct net_device *dev,
1961 struct iw_request_info *info,
1962 struct iw_freq *freq, char *extra)
1963 {
1964 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1965
1966 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
1967 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
1968 return -EOPNOTSUPP;
1969 }
1970
1971 if (ar->arWlanState == WLAN_DISABLED) {
1972 return -EIO;
1973 }
1974
1975 /*
1976 * We support limiting the channels via wmiconfig.
1977 *
1978 * We use this command to configure the channel hint for the connect cmd
1979 * so it is possible the target will end up connecting to a different
1980 * channel.
1981 */
1982 if (freq->e > 1) {
1983 return -EINVAL;
1984 } else if (freq->e == 1) {
1985 ar->arChannelHint = freq->m / 100000;
1986 } else {
1987 if(freq->m) {
1988 ar->arChannelHint = wlan_ieee2freq(freq->m);
1989 } else {
1990 /* Auto Channel Selection */
1991 ar->arChannelHint = 0;
1992 }
1993 }
1994
1995 ar->ap_profile_flag = 1; /* There is a change in profile */
1996
1997 A_PRINTF("channel hint set to %d\n", ar->arChannelHint);
1998 return 0;
1999 }
2000
2001 /*
2002 * SIOCGIWFREQ
2003 */
2004 int
2005 ar6000_ioctl_giwfreq(struct net_device *dev,
2006 struct iw_request_info *info,
2007 struct iw_freq *freq, char *extra)
2008 {
2009 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2010
2011 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
2012 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
2013 return -EOPNOTSUPP;
2014 }
2015
2016 if (ar->arWlanState == WLAN_DISABLED) {
2017 return -EIO;
2018 }
2019
2020 if (ar->arNetworkType == AP_NETWORK) {
2021 if(ar->arChannelHint) {
2022 freq->m = ar->arChannelHint * 100000;
2023 } else if(ar->arACS) {
2024 freq->m = ar->arACS * 100000;
2025 } else {
2026 return -EINVAL;
2027 }
2028 } else {
2029 if (ar->arConnected != TRUE) {
2030 return -EINVAL;
2031 } else {
2032 freq->m = ar->arBssChannel * 100000;
2033 }
2034 }
2035
2036 freq->e = 1;
2037
2038 return 0;
2039 }
2040
2041 /*
2042 * SIOCSIWMODE
2043 */
2044 int
2045 ar6000_ioctl_siwmode(struct net_device *dev,
2046 struct iw_request_info *info,
2047 __u32 *mode, char *extra)
2048 {
2049 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2050
2051 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
2052 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
2053 return -EOPNOTSUPP;
2054 }
2055
2056 if (ar->arWlanState == WLAN_DISABLED) {
2057 return -EIO;
2058 }
2059
2060 /*
2061 * clear SSID during mode switch in connected state
2062 */
2063 if(!(ar->arNetworkType == (((*mode) == IW_MODE_INFRA) ? INFRA_NETWORK : ADHOC_NETWORK)) && (ar->arConnected == TRUE) ){
2064 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
2065 ar->arSsidLen = 0;
2066 }
2067
2068 switch (*mode) {
2069 case IW_MODE_INFRA:
2070 ar->arNextMode = INFRA_NETWORK;
2071 break;
2072 case IW_MODE_ADHOC:
2073 ar->arNextMode = ADHOC_NETWORK;
2074 break;
2075 case IW_MODE_MASTER:
2076 ar->arNextMode = AP_NETWORK;
2077 break;
2078 default:
2079 return -EINVAL;
2080 }
2081
2082 /* clear all shared parameters between AP and STA|IBSS modes when we
2083 * switch between them. Switch between STA & IBSS modes does'nt clear
2084 * the shared profile. This is as per the original design for switching
2085 * between STA & IBSS.
2086 */
2087 if (ar->arNetworkType == AP_NETWORK || ar->arNextMode == AP_NETWORK) {
2088 ar->arDot11AuthMode = OPEN_AUTH;
2089 ar->arAuthMode = NONE_AUTH;
2090 ar->arPairwiseCrypto = NONE_CRYPT;
2091 ar->arPairwiseCryptoLen = 0;
2092 ar->arGroupCrypto = NONE_CRYPT;
2093 ar->arGroupCryptoLen = 0;
2094 ar->arChannelHint = 0;
2095 ar->arBssChannel = 0;
2096 A_MEMZERO(ar->arBssid, sizeof(ar->arBssid));
2097 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
2098 ar->arSsidLen = 0;
2099 }
2100
2101 /* SSID has to be cleared to trigger a profile change while switching
2102 * between STA & IBSS modes having the same SSID
2103 */
2104 if (ar->arNetworkType != ar->arNextMode) {
2105 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
2106 ar->arSsidLen = 0;
2107 }
2108
2109 return 0;
2110 }
2111
2112 /*
2113 * SIOCGIWMODE
2114 */
2115 int
2116 ar6000_ioctl_giwmode(struct net_device *dev,
2117 struct iw_request_info *info,
2118 __u32 *mode, char *extra)
2119 {
2120 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2121
2122 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
2123 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
2124 return -EOPNOTSUPP;
2125 }
2126
2127 if (ar->arWlanState == WLAN_DISABLED) {
2128 return -EIO;
2129 }
2130
2131 switch (ar->arNetworkType) {
2132 case INFRA_NETWORK:
2133 *mode = IW_MODE_INFRA;
2134 break;
2135 case ADHOC_NETWORK:
2136 *mode = IW_MODE_ADHOC;
2137 break;
2138 case AP_NETWORK:
2139 *mode = IW_MODE_MASTER;
2140 break;
2141 default:
2142 return -EIO;
2143 }
2144 return 0;
2145 }
2146
2147 /*
2148 * SIOCSIWSENS
2149 */
2150 int
2151 ar6000_ioctl_siwsens(struct net_device *dev,
2152 struct iw_request_info *info,
2153 struct iw_param *sens, char *extra)
2154 {
2155 return 0;
2156 }
2157
2158 /*
2159 * SIOCGIWSENS
2160 */
2161 int
2162 ar6000_ioctl_giwsens(struct net_device *dev,
2163 struct iw_request_info *info,
2164 struct iw_param *sens, char *extra)
2165 {
2166 sens->value = 0;
2167 sens->fixed = 1;
2168
2169 return 0;
2170 }
2171
2172 /*
2173 * SIOCGIWRANGE
2174 */
2175 int
2176 ar6000_ioctl_giwrange(struct net_device *dev,
2177 struct iw_request_info *info,
2178 struct iw_point *data, char *extra)
2179 {
2180 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2181 struct iw_range *range = (struct iw_range *) extra;
2182 int i, ret = 0;
2183
2184 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
2185 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
2186 return -EOPNOTSUPP;
2187 }
2188
2189 if (ar->bIsDestroyProgress) {
2190 return -EBUSY;
2191 }
2192
2193 if (ar->arWmiReady == FALSE) {
2194 return -EIO;
2195 }
2196
2197 if (down_interruptible(&ar->arSem)) {
2198 return -ERESTARTSYS;
2199 }
2200
2201 if (ar->bIsDestroyProgress) {
2202 up(&ar->arSem);
2203 return -EBUSY;
2204 }
2205
2206 ar->arNumChannels = -1;
2207 A_MEMZERO(ar->arChannelList, sizeof (ar->arChannelList));
2208
2209 if (wmi_get_channelList_cmd(ar->arWmi) != A_OK) {
2210 up(&ar->arSem);
2211 return -EIO;
2212 }
2213
2214 wait_event_interruptible_timeout(arEvent, ar->arNumChannels != -1, wmitimeout * HZ);
2215
2216 if (signal_pending(current)) {
2217 up(&ar->arSem);
2218 return -EINTR;
2219 }
2220
2221 data->length = sizeof(struct iw_range);
2222 A_MEMZERO(range, sizeof(struct iw_range));
2223
2224 range->txpower_capa = 0;
2225
2226 range->min_pmp = 1 * 1024;
2227 range->max_pmp = 65535 * 1024;
2228 range->min_pmt = 1 * 1024;
2229 range->max_pmt = 1000 * 1024;
2230 range->pmp_flags = IW_POWER_PERIOD;
2231 range->pmt_flags = IW_POWER_TIMEOUT;
2232 range->pm_capa = 0;
2233
2234 range->we_version_compiled = WIRELESS_EXT;
2235 range->we_version_source = 13;
2236
2237 range->retry_capa = IW_RETRY_LIMIT;
2238 range->retry_flags = IW_RETRY_LIMIT;
2239 range->min_retry = 0;
2240 range->max_retry = 255;
2241
2242 range->num_frequency = range->num_channels = ar->arNumChannels;
2243 for (i = 0; i < ar->arNumChannels; i++) {
2244 range->freq[i].i = wlan_freq2ieee(ar->arChannelList[i]);
2245 range->freq[i].m = ar->arChannelList[i] * 100000;
2246 range->freq[i].e = 1;
2247 /*
2248 * Linux supports max of 32 channels, bail out once you
2249 * reach the max.
2250 */
2251 if (i == IW_MAX_FREQUENCIES) {
2252 break;
2253 }
2254 }
2255
2256 /* Max quality is max field value minus noise floor */
2257 range->max_qual.qual = 0xff - 161;
2258
2259 /*
2260 * In order to use dBm measurements, 'level' must be lower
2261 * than any possible measurement (see iw_print_stats() in
2262 * wireless tools). It's unclear how this is meant to be
2263 * done, but setting zero in these values forces dBm and
2264 * the actual numbers are not used.
2265 */
2266 range->max_qual.level = 0;
2267 range->max_qual.noise = 0;
2268
2269 range->sensitivity = 3;
2270
2271 range->max_encoding_tokens = 4;
2272 /* XXX query driver to find out supported key sizes */
2273 range->num_encoding_sizes = 3;
2274 range->encoding_size[0] = 5; /* 40-bit */
2275 range->encoding_size[1] = 13; /* 104-bit */
2276 range->encoding_size[2] = 16; /* 128-bit */
2277
2278 range->num_bitrates = 0;
2279
2280 /* estimated maximum TCP throughput values (bps) */
2281 range->throughput = 22000000;
2282
2283 range->min_rts = 0;
2284 range->max_rts = 2347;
2285 range->min_frag = 256;
2286 range->max_frag = 2346;
2287
2288 up(&ar->arSem);
2289
2290 return ret;
2291 }
2292
2293
2294 /*
2295 * SIOCSIWAP
2296 * This ioctl is used to set the desired bssid for the connect command.
2297 */
2298 int
2299 ar6000_ioctl_siwap(struct net_device *dev,
2300 struct iw_request_info *info,
2301 struct sockaddr *ap_addr, char *extra)
2302 {
2303 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2304
2305 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
2306 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
2307 return -EOPNOTSUPP;
2308 }
2309
2310 if (ar->arWlanState == WLAN_DISABLED) {
2311 return -EIO;
2312 }
2313
2314 if (ap_addr->sa_family != ARPHRD_ETHER) {
2315 return -EIO;
2316 }
2317
2318 if (A_MEMCMP(&ap_addr->sa_data, bcast_mac, AR6000_ETH_ADDR_LEN) == 0) {
2319 A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid));
2320 } else {
2321 A_MEMCPY(ar->arReqBssid, &ap_addr->sa_data, sizeof(ar->arReqBssid));
2322 }
2323
2324 return 0;
2325 }
2326
2327 /*
2328 * SIOCGIWAP
2329 */
2330 int
2331 ar6000_ioctl_giwap(struct net_device *dev,
2332 struct iw_request_info *info,
2333 struct sockaddr *ap_addr, char *extra)
2334 {
2335 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2336
2337 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
2338 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
2339 return -EOPNOTSUPP;
2340 }
2341
2342 if (ar->arWlanState == WLAN_DISABLED) {
2343 return -EIO;
2344 }
2345
2346 if (ar->arNetworkType == AP_NETWORK) {
2347 A_MEMCPY(&ap_addr->sa_data, dev->dev_addr, ATH_MAC_LEN);
2348 ap_addr->sa_family = ARPHRD_ETHER;
2349 return 0;
2350 }
2351
2352 if (ar->arConnected != TRUE) {
2353 return -EINVAL;
2354 }
2355
2356 A_MEMCPY(&ap_addr->sa_data, ar->arBssid, sizeof(ar->arBssid));
2357 ap_addr->sa_family = ARPHRD_ETHER;
2358
2359 return 0;
2360 }
2361
2362 #if (WIRELESS_EXT >= 18)
2363 /*
2364 * SIOCSIWMLME
2365 */
2366 int
2367 ar6000_ioctl_siwmlme(struct net_device *dev,
2368 struct iw_request_info *info,
2369 struct iw_point *data, char *extra)
2370 {
2371 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2372
2373 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
2374 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
2375 return -EOPNOTSUPP;
2376 }
2377
2378 if (ar->bIsDestroyProgress) {
2379 return -EBUSY;
2380 }
2381
2382 if (ar->arWlanState == WLAN_DISABLED) {
2383 return -EIO;
2384 }
2385
2386 if (ar->arWmiReady == FALSE) {
2387 return -EIO;
2388 }
2389
2390 if (down_interruptible(&ar->arSem)) {
2391 return -ERESTARTSYS;
2392 }
2393
2394 if (data->pointer && data->length == sizeof(struct iw_mlme)) {
2395
2396 A_UINT8 arNetworkType;
2397 struct iw_mlme mlme;
2398
2399 if (copy_from_user(&mlme, data->pointer, sizeof(struct iw_mlme)))
2400 return -EIO;
2401
2402 switch (mlme.cmd) {
2403
2404 case IW_MLME_DEAUTH:
2405 /* fall through */
2406 case IW_MLME_DISASSOC:
2407 if ((ar->arConnected != TRUE) ||
2408 (memcmp(ar->arBssid, mlme.addr.sa_data, 6) != 0)) {
2409
2410 up(&ar->arSem);
2411 return -EINVAL;
2412 }
2413 wmi_setPmkid_cmd(ar->arWmi, ar->arBssid, NULL, 0);
2414 arNetworkType = ar->arNetworkType;
2415 ar6000_init_profile_info(ar);
2416 ar->arNetworkType = arNetworkType;
2417 reconnect_flag = 0;
2418 wmi_disconnect_cmd(ar->arWmi);
2419 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
2420 ar->arSsidLen = 0;
2421 if (ar->arSkipScan == FALSE) {
2422 A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid));
2423 }
2424 break;
2425
2426 case IW_MLME_AUTH:
2427 /* fall through */
2428 case IW_MLME_ASSOC:
2429 /* fall through */
2430 default:
2431 up(&ar->arSem);
2432 return -EOPNOTSUPP;
2433 }
2434 }
2435
2436 up(&ar->arSem);
2437 return 0;
2438 }
2439 #endif /* WIRELESS_EXT >= 18 */
2440
2441 /*
2442 * SIOCGIWAPLIST
2443 */
2444 int
2445 ar6000_ioctl_iwaplist(struct net_device *dev,
2446 struct iw_request_info *info,
2447 struct iw_point *data, char *extra)
2448 {
2449 return -EIO; /* for now */
2450 }
2451
2452 /*
2453 * SIOCSIWSCAN
2454 */
2455 int
2456 ar6000_ioctl_siwscan(struct net_device *dev,
2457 struct iw_request_info *info,
2458 struct iw_point *data, char *extra)
2459 {
2460 #define ACT_DWELLTIME_DEFAULT 105
2461 #define HOME_TXDRAIN_TIME 100
2462 #define SCAN_INT HOME_TXDRAIN_TIME + ACT_DWELLTIME_DEFAULT
2463 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2464 int ret = 0;
2465
2466 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
2467 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
2468 return -EOPNOTSUPP;
2469 }
2470
2471 if (ar->arWmiReady == FALSE) {
2472 return -EIO;
2473 }
2474
2475 if (ar->arWlanState == WLAN_DISABLED) {
2476 return -EIO;
2477 }
2478
2479 /* If scan is issued in the middle of ongoing scan or connect,
2480 dont issue another one */
2481 if ( ar->scan_triggered > 0 ) {
2482 ++ar->scan_triggered;
2483 if (ar->scan_triggered < 5) {
2484 return 0;
2485 } else {
2486 AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_SCAN,("Scan request is triggered over 5 times. Not scan complete event\n"));
2487 }
2488 }
2489
2490 if (!ar->arUserBssFilter) {
2491 if (wmi_bssfilter_cmd(ar->arWmi, ALL_BSS_FILTER, 0) != A_OK) {
2492 return -EIO;
2493 }
2494 }
2495
2496 if (ar->arConnected) {
2497 if (wmi_get_stats_cmd(ar->arWmi) != A_OK) {
2498 return -EIO;
2499 }
2500 }
2501
2502 #ifdef ANDROID_ENV
2503 #if WIRELESS_EXT >= 18
2504 if (data->pointer && (data->length == sizeof(struct iw_scan_req)))
2505 {
2506 if ((data->flags & IW_SCAN_THIS_ESSID) == IW_SCAN_THIS_ESSID)
2507 {
2508 struct iw_scan_req req;
2509 if (copy_from_user(&req, data->pointer, sizeof(struct iw_scan_req)))
2510 return -EIO;
2511 if (wmi_probedSsid_cmd(ar->arWmi, 1, SPECIFIC_SSID_FLAG, req.essid_len, req.essid) != A_OK)
2512 return -EIO;
2513 ar->scanSpecificSsid = 1;
2514 }
2515 else
2516 {
2517 if (ar->scanSpecificSsid) {
2518 if (wmi_probedSsid_cmd(ar->arWmi, 1, DISABLE_SSID_FLAG, 0, NULL) != A_OK)
2519 return -EIO;
2520 ar->scanSpecificSsid = 0;
2521 }
2522 }
2523 }
2524 else
2525 {
2526 if (ar->scanSpecificSsid) {
2527 if (wmi_probedSsid_cmd(ar->arWmi, 1, DISABLE_SSID_FLAG, 0, NULL) != A_OK)
2528 return -EIO;
2529 ar->scanSpecificSsid = 0;
2530 }
2531 }
2532 #endif
2533 #endif /* ANDROID_ENV */
2534
2535 if (wmi_startscan_cmd(ar->arWmi, WMI_LONG_SCAN, FALSE, FALSE, \
2536 0, 0, 0, NULL) != A_OK) {
2537 ret = -EIO;
2538 }
2539
2540 if (ret == 0) {
2541 ar->scan_triggered = 1;
2542 }
2543
2544 return ret;
2545 #undef ACT_DWELLTIME_DEFAULT
2546 #undef HOME_TXDRAIN_TIME
2547 #undef SCAN_INT
2548 }
2549
2550
2551 /*
2552 * Units are in db above the noise floor. That means the
2553 * rssi values reported in the tx/rx descriptors in the
2554 * driver are the SNR expressed in db.
2555 *
2556 * If you assume that the noise floor is -95, which is an
2557 * excellent assumption 99.5 % of the time, then you can
2558 * derive the absolute signal level (i.e. -95 + rssi).
2559 * There are some other slight factors to take into account
2560 * depending on whether the rssi measurement is from 11b,
2561 * 11g, or 11a. These differences are at most 2db and
2562 * can be documented.
2563 *
2564 * NB: various calculations are based on the orinoco/wavelan
2565 * drivers for compatibility
2566 */
2567 static void
2568 ar6000_set_quality(struct iw_quality *iq, A_INT8 rssi)
2569 {
2570 if (rssi < 0) {
2571 iq->qual = 0;
2572 } else {
2573 iq->qual = rssi;
2574 }
2575
2576 /* NB: max is 94 because noise is hardcoded to 161 */
2577 if (iq->qual > 94)
2578 iq->qual = 94;
2579
2580 iq->noise = 161; /* -95dBm */
2581 iq->level = iq->noise + iq->qual;
2582 iq->updated = 7;
2583 }
2584
2585
2586 int
2587 ar6000_ioctl_siwcommit(struct net_device *dev,
2588 struct iw_request_info *info,
2589 struct iw_point *data, char *extra)
2590 {
2591 AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2592
2593 if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
2594 A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
2595 return -EOPNOTSUPP;
2596 }
2597
2598 if (ar->arWmiReady == FALSE) {
2599 return -EIO;
2600 }
2601
2602 if (ar->arWlanState == WLAN_DISABLED) {
2603 return -EIO;
2604 }
2605
2606 AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("AP: SSID %s freq %d authmode %d dot11 auth %d"\
2607 " PW crypto %d GRP crypto %d\n",
2608 ar->arSsid, ar->arChannelHint,
2609 ar->arAuthMode, ar->arDot11AuthMode,
2610 ar->arPairwiseCrypto, ar->arGroupCrypto));
2611
2612 ar6000_ap_mode_profile_commit(ar);
2613
2614 /* if there is a profile switch from STA|IBSS mode to AP mode,
2615 * update the host driver association state for the STA|IBSS mode.
2616 */
2617 if (ar->arNetworkType != AP_NETWORK && ar->arNextMode == AP_NETWORK) {
2618 ar->arConnectPending = FALSE;
2619 ar->arConnected = FALSE;
2620 /* Stop getting pkts from upper stack */
2621 netif_stop_queue(ar->arNetDev);
2622 A_MEMZERO(ar->arBssid, sizeof(ar->arBssid));
2623 ar->arBssChannel = 0;
2624 ar->arBeaconInterval = 0;
2625
2626 /* Flush the Tx queues */
2627 ar6000_TxDataCleanup(ar);
2628
2629 /* Start getting pkts from upper stack */
2630 netif_wake_queue(ar->arNetDev);
2631 }
2632
2633 return 0;
2634 }
2635
2636 #define W_PROTO(_x) wait_ ## _x
2637 #define WAIT_HANDLER_IMPL(_x, type) \
2638 int wait_ ## _x (struct net_device *dev, struct iw_request_info *info, type wrqu, char *extra) {\
2639 int ret; \
2640 dev_hold(dev); \
2641 rtnl_unlock(); \
2642 ret = _x(dev, info, wrqu, extra); \
2643 rtnl_lock(); \
2644 dev_put(dev); \
2645 return ret;\
2646 }
2647
2648 WAIT_HANDLER_IMPL(ar6000_ioctl_siwessid, struct iw_point *)
2649 WAIT_HANDLER_IMPL(ar6000_ioctl_giwrate, struct iw_param *)
2650 WAIT_HANDLER_IMPL(ar6000_ioctl_giwtxpow, struct iw_param *)
2651 WAIT_HANDLER_IMPL(ar6000_ioctl_giwrange, struct iw_point*)
2652
2653 /* Structures to export the Wireless Handlers */
2654 static const iw_handler ath_handlers[] = {
2655 (iw_handler) ar6000_ioctl_siwcommit, /* SIOCSIWCOMMIT */
2656 (iw_handler) ar6000_ioctl_giwname, /* SIOCGIWNAME */
2657 (iw_handler) NULL, /* SIOCSIWNWID */
2658 (iw_handler) NULL, /* SIOCGIWNWID */
2659 (iw_handler) ar6000_ioctl_siwfreq, /* SIOCSIWFREQ */
2660 (iw_handler) ar6000_ioctl_giwfreq, /* SIOCGIWFREQ */
2661 (iw_handler) ar6000_ioctl_siwmode, /* SIOCSIWMODE */
2662 (iw_handler) ar6000_ioctl_giwmode, /* SIOCGIWMODE */
2663 (iw_handler) ar6000_ioctl_siwsens, /* SIOCSIWSENS */
2664 (iw_handler) ar6000_ioctl_giwsens, /* SIOCGIWSENS */
2665 (iw_handler) NULL /* not _used */, /* SIOCSIWRANGE */
2666 (iw_handler) W_PROTO(ar6000_ioctl_giwrange),/* SIOCGIWRANGE */
2667 (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */
2668 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */
2669 (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */
2670 (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */
2671 (iw_handler) NULL, /* SIOCSIWSPY */
2672 (iw_handler) NULL, /* SIOCGIWSPY */
2673 (iw_handler) NULL, /* SIOCSIWTHRSPY */
2674 (iw_handler) NULL, /* SIOCGIWTHRSPY */
2675 (iw_handler) ar6000_ioctl_siwap, /* SIOCSIWAP */
2676 (iw_handler) ar6000_ioctl_giwap, /* SIOCGIWAP */
2677 #if (WIRELESS_EXT >= 18)
2678 (iw_handler) ar6000_ioctl_siwmlme, /* SIOCSIWMLME */
2679 #else
2680 (iw_handler) NULL, /* -- hole -- */
2681 #endif /* WIRELESS_EXT >= 18 */
2682 (iw_handler) ar6000_ioctl_iwaplist, /* SIOCGIWAPLIST */
2683 (iw_handler) ar6000_ioctl_siwscan, /* SIOCSIWSCAN */
2684 (iw_handler) ar6000_ioctl_giwscan, /* SIOCGIWSCAN */
2685 (iw_handler) W_PROTO(ar6000_ioctl_siwessid),/* SIOCSIWESSID */
2686 (iw_handler) ar6000_ioctl_giwessid, /* SIOCGIWESSID */
2687 (iw_handler) NULL, /* SIOCSIWNICKN */
2688 (iw_handler) NULL, /* SIOCGIWNICKN */
2689 (iw_handler) NULL, /* -- hole -- */
2690 (iw_handler) NULL, /* -- hole -- */
2691 (iw_handler) ar6000_ioctl_siwrate, /* SIOCSIWRATE */
2692 (iw_handler) W_PROTO(ar6000_ioctl_giwrate), /* SIOCGIWRATE */
2693 (iw_handler) NULL, /* SIOCSIWRTS */
2694 (iw_handler) NULL, /* SIOCGIWRTS */
2695 (iw_handler) NULL, /* SIOCSIWFRAG */
2696 (iw_handler) NULL, /* SIOCGIWFRAG */
2697 (iw_handler) ar6000_ioctl_siwtxpow, /* SIOCSIWTXPOW */
2698 (iw_handler) W_PROTO(ar6000_ioctl_giwtxpow),/* SIOCGIWTXPOW */
2699 (iw_handler) ar6000_ioctl_siwretry, /* SIOCSIWRETRY */
2700 (iw_handler) ar6000_ioctl_giwretry, /* SIOCGIWRETRY */
2701 (iw_handler) ar6000_ioctl_siwencode, /* SIOCSIWENCODE */
2702 (iw_handler) ar6000_ioctl_giwencode, /* SIOCGIWENCODE */
2703 #if WIRELESS_EXT > 20
2704 (iw_handler) ar6000_ioctl_siwpower, /* SIOCSIWPOWER */
2705 (iw_handler) ar6000_ioctl_giwpower, /* SIOCGIWPOWER */
2706 #endif // WIRELESS_EXT > 20
2707 #if WIRELESS_EXT >= 18
2708 (iw_handler) NULL, /* -- hole -- */
2709 (iw_handler) NULL, /* -- hole -- */
2710 (iw_handler) ar6000_ioctl_siwgenie, /* SIOCSIWGENIE */
2711 (iw_handler) ar6000_ioctl_giwgenie, /* SIOCGIWGENIE */
2712 (iw_handler) ar6000_ioctl_siwauth, /* SIOCSIWAUTH */
2713 (iw_handler) ar6000_ioctl_giwauth, /* SIOCGIWAUTH */
2714 (iw_handler) ar6000_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */
2715 (iw_handler) ar6000_ioctl_giwencodeext, /* SIOCGIWENCODEEXT */
2716 (iw_handler) ar6000_ioctl_siwpmksa, /* SIOCSIWPMKSA */
2717 #endif // WIRELESS_EXT >= 18
2718 };
2719
2720 struct iw_handler_def ath_iw_handler_def = {
2721 .standard = (iw_handler *)ath_handlers,
2722 .num_standard = ARRAY_SIZE(ath_handlers),
2723 .private = NULL,
2724 .num_private = 0,
2725 };
kernel source for telekom puls (alcatel/mediatek)