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