1/* 2 * 3 * Copyright (c) 2004-2007 Atheros Communications Inc. 4 * All rights reserved. 5 * 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation; 10 * 11 * Software distributed under the License is distributed on an "AS 12 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or 13 * implied. See the License for the specific language governing 14 * rights and limitations under the License. 15 * 16 * 17 * 18 */ 19 20#include "ar6000_drv.h" 21 22static A_UINT8 bcast_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 23static void ar6000_set_quality(struct iw_quality *iq, A_INT8 rssi); 24extern unsigned int wmitimeout; 25extern A_WAITQUEUE_HEAD arEvent; 26extern wait_queue_head_t ar6000_scan_queue; 27 28/* 29 * Encode a WPA or RSN information element as a custom 30 * element using the hostap format. 31 */ 32static u_int 33encode_ie(void *buf, size_t bufsize, 34 const u_int8_t *ie, size_t ielen, 35 const char *leader, size_t leader_len) 36{ 37 u_int8_t *p; 38 int i; 39 40 if (bufsize < leader_len) 41 return 0; 42 p = buf; 43 memcpy(p, leader, leader_len); 44 bufsize -= leader_len; 45 p += leader_len; 46 for (i = 0; i < ielen && bufsize > 2; i++) 47 p += sprintf(p, "%02x", ie[i]); 48 return (i == ielen ? p - (u_int8_t *)buf : 0); 49} 50 51void 52ar6000_scan_node(void *arg, bss_t *ni) 53{ 54 struct iw_event iwe; 55#if WIRELESS_EXT > 14 56 char buf[64*2 + 30]; 57#endif 58 struct ar_giwscan_param *param; 59 A_CHAR *current_ev; 60 A_CHAR *end_buf; 61 struct ieee80211_common_ie *cie; 62 struct iw_request_info info; 63 64 info.cmd = 0; 65 info.flags = 0; 66 67 param = (struct ar_giwscan_param *)arg; 68 69 if (param->current_ev >= param->end_buf) { 70 return; 71 } 72 if ((param->firstPass == TRUE) && 73 ((ni->ni_cie.ie_wpa == NULL) && (ni->ni_cie.ie_rsn == NULL))) { 74 /* 75 * Only forward wpa bss's in first pass 76 */ 77 return; 78 } 79 80 if ((param->firstPass == FALSE) && 81 ((ni->ni_cie.ie_wpa != NULL) || (ni->ni_cie.ie_rsn != NULL))) { 82 /* 83 * Only forward non-wpa bss's in 2nd pass 84 */ 85 return; 86 } 87 88 current_ev = param->current_ev; 89 end_buf = param->end_buf; 90 91 cie = &ni->ni_cie; 92 93 A_MEMZERO(&iwe, sizeof(iwe)); 94 iwe.cmd = SIOCGIWAP; 95 iwe.u.ap_addr.sa_family = ARPHRD_ETHER; 96 A_MEMCPY(iwe.u.ap_addr.sa_data, ni->ni_macaddr, 6); 97 current_ev = iwe_stream_add_event(&info, current_ev, end_buf, &iwe, 98 IW_EV_ADDR_LEN); 99 100 A_MEMZERO(&iwe, sizeof(iwe)); 101 iwe.cmd = SIOCGIWESSID; 102 iwe.u.data.flags = 1; 103 iwe.u.data.length = cie->ie_ssid[1]; 104 current_ev = iwe_stream_add_point(&info, current_ev, end_buf, &iwe, 105 &cie->ie_ssid[2]); 106 107 if (cie->ie_capInfo & (IEEE80211_CAPINFO_ESS|IEEE80211_CAPINFO_IBSS)) { 108 A_MEMZERO(&iwe, sizeof(iwe)); 109 iwe.cmd = SIOCGIWMODE; 110 iwe.u.mode = cie->ie_capInfo & IEEE80211_CAPINFO_ESS ? 111 IW_MODE_MASTER : IW_MODE_ADHOC; 112 current_ev = iwe_stream_add_event(&info, current_ev, end_buf, &iwe, 113 IW_EV_UINT_LEN); 114 } 115 116 A_MEMZERO(&iwe, sizeof(iwe)); 117 iwe.cmd = SIOCGIWFREQ; 118 iwe.u.freq.m = cie->ie_chan * 100000; 119 iwe.u.freq.e = 1; 120 current_ev = iwe_stream_add_event(&info, current_ev, end_buf, &iwe, 121 IW_EV_FREQ_LEN); 122 123 A_MEMZERO(&iwe, sizeof(iwe)); 124 iwe.cmd = IWEVQUAL; 125 ar6000_set_quality(&iwe.u.qual, ni->ni_snr); 126 current_ev = iwe_stream_add_event(&info, current_ev, end_buf, &iwe, 127 IW_EV_QUAL_LEN); 128 129 A_MEMZERO(&iwe, sizeof(iwe)); 130 iwe.cmd = SIOCGIWENCODE; 131 if (cie->ie_capInfo & IEEE80211_CAPINFO_PRIVACY) { 132 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; 133 } else { 134 iwe.u.data.flags = IW_ENCODE_DISABLED; 135 } 136 iwe.u.data.length = 0; 137 current_ev = iwe_stream_add_point(&info, current_ev, end_buf, &iwe, ""); 138 139 A_MEMZERO(&iwe, sizeof(iwe)); 140 iwe.cmd = IWEVCUSTOM; 141 snprintf(buf, sizeof(buf), "bcn_int=%d", cie->ie_beaconInt); 142 iwe.u.data.length = strlen(buf); 143 current_ev = iwe_stream_add_point(&info, current_ev, end_buf, &iwe, buf); 144 145 if (cie->ie_wpa != NULL) { 146 static const char wpa_leader[] = "wpa_ie="; 147 148 A_MEMZERO(&iwe, sizeof(iwe)); 149 iwe.cmd = IWEVCUSTOM; 150 iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_wpa, 151 cie->ie_wpa[1]+2, 152 wpa_leader, sizeof(wpa_leader)-1); 153 154 if (iwe.u.data.length != 0) { 155 current_ev = iwe_stream_add_point(&info, current_ev, end_buf, &iwe, 156 buf); 157 } 158 } 159 160 if (cie->ie_rsn != NULL && cie->ie_rsn[0] == IEEE80211_ELEMID_RSN) { 161 static const char rsn_leader[] = "rsn_ie="; 162 163 A_MEMZERO(&iwe, sizeof(iwe)); 164 iwe.cmd = IWEVCUSTOM; 165 iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_rsn, 166 cie->ie_rsn[1]+2, 167 rsn_leader, sizeof(rsn_leader)-1); 168 169 if (iwe.u.data.length != 0) { 170 current_ev = iwe_stream_add_point(&info, current_ev, end_buf, &iwe, 171 buf); 172 } 173 } 174 175 if (cie->ie_wmm != NULL) { 176 static const char wmm_leader[] = "wmm_ie="; 177 178 A_MEMZERO(&iwe, sizeof(iwe)); 179 iwe.cmd = IWEVCUSTOM; 180 iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_wmm, 181 cie->ie_wmm[1]+2, 182 wmm_leader, sizeof(wmm_leader)-1); 183 if (iwe.u.data.length != 0) { 184 current_ev = iwe_stream_add_point(&info, current_ev, end_buf, &iwe, 185 buf); 186 } 187 } 188 189 if (cie->ie_ath != NULL) { 190 static const char ath_leader[] = "ath_ie="; 191 192 A_MEMZERO(&iwe, sizeof(iwe)); 193 iwe.cmd = IWEVCUSTOM; 194 iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_ath, 195 cie->ie_ath[1]+2, 196 ath_leader, sizeof(ath_leader)-1); 197 if (iwe.u.data.length != 0) { 198 current_ev = iwe_stream_add_point(&info, current_ev, end_buf, &iwe, 199 buf); 200 } 201 } 202 203 param->current_ev = current_ev; 204} 205 206int 207ar6000_ioctl_giwscan(struct net_device *dev, 208 struct iw_request_info *info, 209 struct iw_point *data, char *extra) 210{ 211 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 212 struct ar_giwscan_param param; 213 int i; 214 215 if (ar->arWlanState == WLAN_DISABLED) { 216 return -EIO; 217 } 218 219 if (ar->arWmiReady == FALSE) { 220 return -EIO; 221 } 222 223 param.current_ev = extra; 224 param.end_buf = extra + IW_SCAN_MAX_DATA; 225 param.firstPass = TRUE; 226 227 /* 228 * Do two passes to insure WPA scan candidates 229 * are sorted to the front. This is a hack to deal with 230 * the wireless extensions capping scan results at 231 * IW_SCAN_MAX_DATA bytes. In densely populated environments 232 * it's easy to overflow this buffer (especially with WPA/RSN 233 * information elements). Note this sorting hack does not 234 * guarantee we won't overflow anyway. 235 */ 236 for (i = 0; i < 2; i++) { 237 /* 238 * Translate data to WE format. 239 */ 240 wmi_iterate_nodes(ar->arWmi, ar6000_scan_node, ¶m); 241 param.firstPass = FALSE; 242 if (param.current_ev >= param.end_buf) { 243 data->length = param.current_ev - extra; 244 return -E2BIG; 245 } 246 } 247 248 data->length = param.current_ev - extra; 249 return 0; 250} 251 252extern int reconnect_flag; 253/* SIOCSIWESSID */ 254static int 255ar6000_ioctl_siwessid(struct net_device *dev, 256 struct iw_request_info *info, 257 struct iw_point *data, char *ssid) 258{ 259 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 260 A_STATUS status; 261 A_UINT8 arNetworkType; 262 263 if (ar->arWlanState == WLAN_DISABLED) { 264 return -EIO; 265 } 266 267 if (ar->arWmiReady == FALSE) { 268 return -EIO; 269 } 270 271 /* 272 * iwconfig passes a string with length excluding any trailing NUL. 273 * FIXME: we should be able to set an ESSID of 32 bytes, yet things fall 274 * over badly if we do. So we limit the ESSID to 31 bytes. 275 */ 276 if (data->flags && (!data->length || data->length >= sizeof(ar->arSsid))) { 277 /* 278 * ssid is invalid 279 */ 280 return -EINVAL; 281 } 282 /* Added for bug 25178, return an IOCTL error instead of target returning 283 Illegal parameter error when either the BSSID or channel is missing 284 and we cannot scan during connect. 285 */ 286 if (data->flags) { 287 if (ar->arSkipScan == TRUE && 288 (ar->arChannelHint == 0 || 289 (!ar->arReqBssid[0] && !ar->arReqBssid[1] && !ar->arReqBssid[2] && 290 !ar->arReqBssid[3] && !ar->arReqBssid[4] && !ar->arReqBssid[5]))) 291 { 292 return -EINVAL; 293 } 294 } 295 296 if (down_interruptible(&ar->arSem)) { 297 return -ERESTARTSYS; 298 } 299 300 if (ar->arTxPending[WMI_CONTROL_PRI]) { 301 /* 302 * sleep until the command queue drains 303 */ 304 wait_event_interruptible_timeout(arEvent, 305 ar->arTxPending[WMI_CONTROL_PRI] == 0, wmitimeout * HZ); 306 if (signal_pending(current)) { 307 return -EINTR; 308 } 309 } 310 311 if (!data->flags) { 312 arNetworkType = ar->arNetworkType; 313 ar6000_init_profile_info(ar); 314 ar->arNetworkType = arNetworkType; 315 } 316 317 /* 318 * The original logic here prevented a disconnect if issuing an "essid off" 319 * if no ESSID was set, presumably to prevent sending multiple disconnects 320 * to the WMI. 321 * 322 * Unfortunately, this also meant that no disconnect was sent when we were 323 * already connected, but the profile has been changed since (which also 324 * clears the ESSID as a reminder that the WMI needs updating.) 325 * 326 * The "1 ||" makes sure we always disconnect or reconnect. The WMI doesn't 327 * seem to mind being sent multiple disconnects. 328 */ 329 if (1 || (ar->arSsidLen) || (!data->flags)) 330 { 331 if ((!data->flags) || 332 (A_MEMCMP(ar->arSsid, ssid, ar->arSsidLen) != 0) || 333 (ar->arSsidLen != (data->length))) 334 { 335 /* 336 * SSID set previously or essid off has been issued. 337 * 338 * Disconnect Command is issued in two cases after wmi is ready 339 * (1) ssid is different from the previous setting 340 * (2) essid off has been issued 341 * 342 */ 343 if (ar->arWmiReady == TRUE) { 344 reconnect_flag = 0; 345 status = wmi_disconnect_cmd(ar->arWmi); 346 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); 347 ar->arSsidLen = 0; 348 if (ar->arSkipScan == FALSE) { 349 A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid)); 350 } 351 if (!data->flags) { 352 up(&ar->arSem); 353 return 0; 354 } 355 } else { 356 up(&ar->arSem); 357 } 358 } 359 else 360 { 361 /* 362 * SSID is same, so we assume profile hasn't changed. 363 * If the interface is up and wmi is ready, we issue 364 * a reconnect cmd. Issue a reconnect only we are already 365 * connected. 366 */ 367 if((ar->arConnected == TRUE) && (ar->arWmiReady == TRUE)) 368 { 369 reconnect_flag = TRUE; 370 status = wmi_reconnect_cmd(ar->arWmi,ar->arReqBssid, 371 ar->arChannelHint); 372 up(&ar->arSem); 373 if (status != A_OK) { 374 return -EIO; 375 } 376 return 0; 377 } 378 else{ 379 /* 380 * Dont return if connect is pending. 381 */ 382 if(!(ar->arConnectPending)) { 383 up(&ar->arSem); 384 return 0; 385 } 386 } 387 } 388 } 389 390 ar->arSsidLen = data->length; 391 A_MEMCPY(ar->arSsid, ssid, ar->arSsidLen); 392 393 /* The ssid length check prevents second "essid off" from the user, 394 to be treated as a connect cmd. The second "essid off" is ignored. 395 */ 396 if((ar->arWmiReady == TRUE) && (ar->arSsidLen > 0) ) 397 { 398 AR6000_SPIN_LOCK(&ar->arLock, 0); 399 if (SHARED_AUTH == ar->arDot11AuthMode) { 400 ar6000_install_static_wep_keys(ar); 401 } 402 AR_DEBUG_PRINTF("Connect called with authmode %d dot11 auth %d"\ 403 " PW crypto %d PW crypto Len %d GRP crypto %d"\ 404 " GRP crypto Len %d\n", 405 ar->arAuthMode, ar->arDot11AuthMode, 406 ar->arPairwiseCrypto, ar->arPairwiseCryptoLen, 407 ar->arGroupCrypto, ar->arGroupCryptoLen); 408 reconnect_flag = 0; 409 AR6000_SPIN_UNLOCK(&ar->arLock, 0); 410 status = wmi_connect_cmd(ar->arWmi, ar->arNetworkType, 411 ar->arDot11AuthMode, ar->arAuthMode, 412 ar->arPairwiseCrypto, ar->arPairwiseCryptoLen, 413 ar->arGroupCrypto,ar->arGroupCryptoLen, 414 ar->arSsidLen, ar->arSsid, 415 ar->arReqBssid, ar->arChannelHint, 416 ar->arConnectCtrlFlags); 417 418 419 up(&ar->arSem); 420 421 if (status != A_OK) { 422 return -EIO; 423 } 424 ar->arConnectPending = TRUE; 425 }else{ 426 up(&ar->arSem); 427 } 428 return 0; 429} 430 431/* SIOCGIWESSID */ 432static int 433ar6000_ioctl_giwessid(struct net_device *dev, 434 struct iw_request_info *info, 435 struct iw_point *data, char *essid) 436{ 437 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 438 439 if (ar->arWlanState == WLAN_DISABLED) { 440 return -EIO; 441 } 442 443 data->flags = 1; 444 data->length = ar->arSsidLen; 445 A_MEMCPY(essid, ar->arSsid, ar->arSsidLen); 446 447 return 0; 448} 449 450 451void ar6000_install_static_wep_keys(AR_SOFTC_T *ar) 452{ 453 A_UINT8 index; 454 A_UINT8 keyUsage; 455 456 for (index = WMI_MIN_KEY_INDEX; index <= WMI_MAX_KEY_INDEX; index++) { 457 if (ar->arWepKeyList[index].arKeyLen) { 458 keyUsage = GROUP_USAGE; 459 if (index == ar->arDefTxKeyIndex) { 460 keyUsage |= TX_USAGE; 461 } 462 wmi_addKey_cmd(ar->arWmi, 463 index, 464 WEP_CRYPT, 465 keyUsage, 466 ar->arWepKeyList[index].arKeyLen, 467 NULL, 468 ar->arWepKeyList[index].arKey, KEY_OP_INIT_VAL, 469 NO_SYNC_WMIFLAG); 470 } 471 } 472} 473 474int 475ar6000_ioctl_delkey(struct net_device *dev, struct iw_request_info *info, 476 void *w, char *extra) 477{ 478 return 0; 479} 480 481int 482ar6000_ioctl_setmlme(struct net_device *dev, struct iw_request_info *info, 483 void *w, char *extra) 484{ 485 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 486 struct ieee80211req_mlme *mlme = (struct ieee80211req_mlme *)extra; 487 488 if ((ar->arWmiReady == FALSE) || (ar->arConnected != TRUE)) 489 return -EIO; 490 491 switch (mlme->im_op) { 492 case IEEE80211_MLME_DISASSOC: 493 case IEEE80211_MLME_DEAUTH: 494 /* Not Supported */ 495 break; 496 default: 497 break; 498 } 499 return 0; 500} 501 502 503int 504ar6000_ioctl_setwmmparams(struct net_device *dev, struct iw_request_info *info, 505 void *w, char *extra) 506{ 507 return -EIO; /* for now */ 508} 509 510int 511ar6000_ioctl_getwmmparams(struct net_device *dev, struct iw_request_info *info, 512 void *w, char *extra) 513{ 514 return -EIO; /* for now */ 515} 516 517int ar6000_ioctl_setoptie(struct net_device *dev, struct iw_request_info *info, 518 struct iw_point *data, char *extra) 519{ 520 /* The target generates the WPA/RSN IE */ 521 return 0; 522} 523 524int 525ar6000_ioctl_setauthalg(struct net_device *dev, struct iw_request_info *info, 526 void *w, char *extra) 527{ 528 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 529 struct ieee80211req_authalg *req = (struct ieee80211req_authalg *)extra; 530 int ret = 0; 531 532 533 AR6000_SPIN_LOCK(&ar->arLock, 0); 534 535 if (req->auth_alg == AUTH_ALG_OPEN_SYSTEM) { 536 ar->arDot11AuthMode = OPEN_AUTH; 537 } else if (req->auth_alg == AUTH_ALG_LEAP) { 538 ar->arDot11AuthMode = LEAP_AUTH; 539 ar->arPairwiseCrypto = WEP_CRYPT; 540 ar->arGroupCrypto = WEP_CRYPT; 541 } else { 542 ret = -EIO; 543 } 544 545 AR6000_SPIN_UNLOCK(&ar->arLock, 0); 546 547 return ret; 548} 549static int 550ar6000_ioctl_addpmkid(struct net_device *dev, struct iw_request_info *info, 551 void *w, char *extra) 552{ 553 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 554 struct ieee80211req_addpmkid *req = (struct ieee80211req_addpmkid *)extra; 555 A_STATUS status; 556 557 if (ar->arWlanState == WLAN_DISABLED) { 558 return -EIO; 559 } 560 561 AR_DEBUG_PRINTF("Add pmkid for %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x en=%d\n", 562 req->pi_bssid[0], req->pi_bssid[1], req->pi_bssid[2], 563 req->pi_bssid[3], req->pi_bssid[4], req->pi_bssid[5], 564 req->pi_enable); 565 566 status = wmi_setPmkid_cmd(ar->arWmi, req->pi_bssid, req->pi_pmkid, 567 req->pi_enable); 568 569 if (status != A_OK) { 570 return -EIO; 571 } 572 573 return 0; 574} 575 576/* 577 * SIOCSIWRATE 578 */ 579int 580ar6000_ioctl_siwrate(struct net_device *dev, 581 struct iw_request_info *info, 582 struct iw_param *rrq, char *extra) 583{ 584 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 585 A_UINT32 kbps; 586 587 if (rrq->fixed) { 588 kbps = rrq->value / 1000; /* rrq->value is in bps */ 589 } else { 590 kbps = -1; /* -1 indicates auto rate */ 591 } 592 if(kbps != -1 && wmi_validate_bitrate(ar->arWmi, kbps) == A_EINVAL) 593 { 594 AR_DEBUG_PRINTF("BitRate is not Valid %d\n", kbps); 595 return -EINVAL; 596 } 597 ar->arBitRate = kbps; 598 if(ar->arWmiReady == TRUE) 599 { 600 if (wmi_set_bitrate_cmd(ar->arWmi, kbps) != A_OK) { 601 return -EINVAL; 602 } 603 } 604 return 0; 605} 606 607/* 608 * SIOCGIWRATE 609 */ 610int 611ar6000_ioctl_giwrate(struct net_device *dev, 612 struct iw_request_info *info, 613 struct iw_param *rrq, char *extra) 614{ 615 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 616 int ret = 0; 617 618 if (down_interruptible(&ar->arSem)) { 619 return -ERESTARTSYS; 620 } 621 if(ar->arWmiReady == TRUE) 622 { 623 ar->arBitRate = 0xFFFF; 624 if (wmi_get_bitrate_cmd(ar->arWmi) != A_OK) { 625 up(&ar->arSem); 626 return -EIO; 627 } 628 wait_event_interruptible_timeout(arEvent, ar->arBitRate != 0xFFFF, wmitimeout * HZ); 629 if (signal_pending(current)) { 630 ret = -EINTR; 631 } 632 } 633 /* If the interface is down or wmi is not ready or the target is not 634 connected - return the value stored in the device structure */ 635 if (!ret) { 636 if (ar->arBitRate == -1) { 637 rrq->fixed = TRUE; 638 rrq->value = 0; 639 } else { 640 rrq->value = ar->arBitRate * 1000; 641 } 642 } 643 644 up(&ar->arSem); 645 646 return ret; 647} 648 649/* 650 * SIOCSIWTXPOW 651 */ 652static int 653ar6000_ioctl_siwtxpow(struct net_device *dev, 654 struct iw_request_info *info, 655 struct iw_param *rrq, char *extra) 656{ 657 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 658 A_UINT8 dbM; 659 660 if (ar->arWlanState == WLAN_DISABLED) { 661 return -EIO; 662 } 663 664 if (ar->arRadioSwitch == WLAN_ENABLED 665 && rrq->disabled) { 666 if (wmi_switch_radio(ar->arWmi, WLAN_DISABLED) < 0) 667 return -EIO; 668 ar->arRadioSwitch = WLAN_DISABLED; 669 } else if (ar->arRadioSwitch == WLAN_DISABLED 670 && !rrq->disabled) { 671 if (wmi_switch_radio(ar->arWmi, WLAN_ENABLED) < 0) 672 return -EIO; 673 ar->arRadioSwitch = WLAN_ENABLED; 674 } 675 676 if (rrq->fixed) { 677 if (rrq->flags != IW_TXPOW_DBM) { 678 return -EOPNOTSUPP; 679 } 680 ar->arTxPwr= dbM = rrq->value; 681 ar->arTxPwrSet = TRUE; 682 } else { 683 ar->arTxPwr = dbM = 0; 684 ar->arTxPwrSet = FALSE; 685 } 686 if(ar->arWmiReady == TRUE) 687 { 688 AR_DEBUG_PRINTF("Set tx pwr cmd %d dbM\n", dbM); 689 wmi_set_txPwr_cmd(ar->arWmi, dbM); 690 } 691 return 0; 692} 693 694/* 695 * SIOCGIWTXPOW 696 */ 697int 698ar6000_ioctl_giwtxpow(struct net_device *dev, 699 struct iw_request_info *info, 700 struct iw_param *rrq, char *extra) 701{ 702 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 703 int ret = 0; 704 705 if (ar->arWlanState == WLAN_DISABLED) { 706 return -EIO; 707 } 708 709 if (ar->arRadioSwitch == WLAN_DISABLED) { 710 rrq->disabled = 1; 711 return 0; 712 } 713 714 if (down_interruptible(&ar->arSem)) { 715 return -ERESTARTSYS; 716 } 717 if((ar->arWmiReady == TRUE) && (ar->arConnected == TRUE)) 718 { 719 ar->arTxPwr = 0; 720 721 if (wmi_get_txPwr_cmd(ar->arWmi) != A_OK) { 722 up(&ar->arSem); 723 return -EIO; 724 } 725 726 wait_event_interruptible_timeout(arEvent, ar->arTxPwr != 0, wmitimeout * HZ); 727 728 if (signal_pending(current)) { 729 ret = -EINTR; 730 } 731 } 732 /* If the interace is down or wmi is not ready or target is not connected 733 then return value stored in the device structure */ 734 735 if (!ret) { 736 if (ar->arTxPwrSet == TRUE) { 737 rrq->fixed = TRUE; 738 } 739 rrq->value = ar->arTxPwr; 740 rrq->flags = IW_TXPOW_DBM; 741 } 742 743 up(&ar->arSem); 744 745 return ret; 746} 747 748/* 749 * SIOCSIWRETRY 750 * since iwconfig only provides us with one max retry value, we use it 751 * to apply to data frames of the BE traffic class. 752 */ 753static int 754ar6000_ioctl_siwretry(struct net_device *dev, 755 struct iw_request_info *info, 756 struct iw_param *rrq, char *extra) 757{ 758 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 759 760 if (ar->arWlanState == WLAN_DISABLED) { 761 return -EIO; 762 } 763 764 if (rrq->disabled) { 765 return -EOPNOTSUPP; 766 } 767 768 if ((rrq->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT) { 769 return -EOPNOTSUPP; 770 } 771 772 if ( !(rrq->value >= WMI_MIN_RETRIES) || !(rrq->value <= WMI_MAX_RETRIES)) { 773 return - EINVAL; 774 } 775 if(ar->arWmiReady == TRUE) 776 { 777 if (wmi_set_retry_limits_cmd(ar->arWmi, DATA_FRAMETYPE, WMM_AC_BE, 778 rrq->value, 0) != A_OK){ 779 return -EINVAL; 780 } 781 } 782 ar->arMaxRetries = rrq->value; 783 return 0; 784} 785 786/* 787 * SIOCGIWRETRY 788 */ 789static int 790ar6000_ioctl_giwretry(struct net_device *dev, 791 struct iw_request_info *info, 792 struct iw_param *rrq, char *extra) 793{ 794 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 795 796 if (ar->arWlanState == WLAN_DISABLED) { 797 return -EIO; 798 } 799 800 rrq->disabled = 0; 801 switch (rrq->flags & IW_RETRY_TYPE) { 802 case IW_RETRY_LIFETIME: 803 return -EOPNOTSUPP; 804 break; 805 case IW_RETRY_LIMIT: 806 rrq->flags = IW_RETRY_LIMIT; 807 switch (rrq->flags & IW_RETRY_MODIFIER) { 808 case IW_RETRY_MIN: 809 rrq->flags |= IW_RETRY_MIN; 810 rrq->value = WMI_MIN_RETRIES; 811 break; 812 case IW_RETRY_MAX: 813 rrq->flags |= IW_RETRY_MAX; 814 rrq->value = ar->arMaxRetries; 815 break; 816 } 817 break; 818 } 819 return 0; 820} 821 822/* 823 * SIOCSIWENCODE 824 */ 825static int 826ar6000_ioctl_siwencode(struct net_device *dev, 827 struct iw_request_info *info, 828 struct iw_point *erq, char *keybuf) 829{ 830 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 831 int index; 832 A_INT32 auth = ar->arDot11AuthMode; 833 834 if (ar->arWlanState == WLAN_DISABLED) { 835 return -EIO; 836 } 837 838 index = erq->flags & IW_ENCODE_INDEX; 839 840 if (index && (((index - 1) < WMI_MIN_KEY_INDEX) || 841 ((index - 1) > WMI_MAX_KEY_INDEX))) 842 { 843 return -EIO; 844 } 845 846 if (erq->flags & IW_ENCODE_DISABLED) { 847 /* 848 * Encryption disabled 849 */ 850 if (index) { 851 /* 852 * If key index was specified then clear the specified key 853 */ 854 index--; 855 A_MEMZERO(ar->arWepKeyList[index].arKey, 856 sizeof(ar->arWepKeyList[index].arKey)); 857 ar->arWepKeyList[index].arKeyLen = 0; 858 } 859 ar->arDot11AuthMode = OPEN_AUTH; 860 ar->arPairwiseCrypto = NONE_CRYPT; 861 ar->arGroupCrypto = NONE_CRYPT; 862 ar->arAuthMode = NONE_AUTH; 863 } else { 864 /* 865 * Enabling WEP encryption 866 */ 867 if (index) { 868 index--; /* keyindex is off base 1 in iwconfig */ 869 } 870 871 if (erq->flags & IW_ENCODE_OPEN) { 872 auth = OPEN_AUTH; 873 } else if (erq->flags & IW_ENCODE_RESTRICTED) { 874 auth = SHARED_AUTH; 875 } 876 877 if (erq->length) { 878 if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(erq->length)) { 879 return -EIO; 880 } 881 882 A_MEMZERO(ar->arWepKeyList[index].arKey, 883 sizeof(ar->arWepKeyList[index].arKey)); 884 A_MEMCPY(ar->arWepKeyList[index].arKey, keybuf, erq->length); 885 ar->arWepKeyList[index].arKeyLen = erq->length; 886 } else { 887 if (ar->arWepKeyList[index].arKeyLen == 0) { 888 return -EIO; 889 } 890 ar->arDefTxKeyIndex = index; 891 } 892 893 ar->arPairwiseCrypto = WEP_CRYPT; 894 ar->arGroupCrypto = WEP_CRYPT; 895 ar->arDot11AuthMode = auth; 896 ar->arAuthMode = NONE_AUTH; 897 } 898 899 /* 900 * profile has changed. Erase ssid to signal change 901 */ 902 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); 903 ar->arSsidLen = 0; 904 905 return 0; 906} 907 908static int 909ar6000_ioctl_giwencode(struct net_device *dev, 910 struct iw_request_info *info, 911 struct iw_point *erq, char *key) 912{ 913 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 914 A_UINT8 keyIndex; 915 struct ar_wep_key *wk; 916 917 if (ar->arWlanState == WLAN_DISABLED) { 918 return -EIO; 919 } 920 921 if (ar->arPairwiseCrypto == NONE_CRYPT) { 922 erq->length = 0; 923 erq->flags = IW_ENCODE_DISABLED; 924 } else { 925 /* get the keyIndex */ 926 keyIndex = erq->flags & IW_ENCODE_INDEX; 927 if (0 == keyIndex) { 928 keyIndex = ar->arDefTxKeyIndex; 929 } else if ((keyIndex - 1 < WMI_MIN_KEY_INDEX) || 930 (keyIndex - 1 > WMI_MAX_KEY_INDEX)) 931 { 932 keyIndex = WMI_MIN_KEY_INDEX; 933 } else { 934 keyIndex--; 935 } 936 erq->flags = keyIndex + 1; 937 erq->flags |= IW_ENCODE_ENABLED; 938 wk = &ar->arWepKeyList[keyIndex]; 939 if (erq->length > wk->arKeyLen) { 940 erq->length = wk->arKeyLen; 941 } 942 if (wk->arKeyLen) { 943 A_MEMCPY(key, wk->arKey, erq->length); 944 } 945 if (ar->arDot11AuthMode == OPEN_AUTH) { 946 erq->flags |= IW_ENCODE_OPEN; 947 } else if (ar->arDot11AuthMode == SHARED_AUTH) { 948 erq->flags |= IW_ENCODE_RESTRICTED; 949 } 950 } 951 952 return 0; 953} 954 955static int ar6000_ioctl_siwpower(struct net_device *dev, 956 struct iw_request_info *info, 957 union iwreq_data *wrqu, char *extra) 958{ 959 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 960 WMI_POWER_MODE power_mode; 961 962 if (wrqu->power.disabled) 963 power_mode = MAX_PERF_POWER; 964 else 965 power_mode = REC_POWER; 966 967 if (wmi_powermode_cmd(ar->arWmi, power_mode) < 0) 968 return -EIO; 969 970 return 0; 971} 972 973static int ar6000_ioctl_giwpower(struct net_device *dev, 974 struct iw_request_info *info, 975 union iwreq_data *wrqu, char *extra) 976{ 977 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 978 979 /* 980 * FIXME: 981 * https://docs.openmoko.org/trac/ticket/2267 982 * When starting wpa_supplicant the kernel oopses. 983 * The following condition avoids the oops. 984 * Remove this comment to bless this solution. 985 */ 986 if (ar->arWlanState == WLAN_DISABLED || ar->arWmiReady == FALSE) 987 return -EIO; 988 989 return wmi_get_power_mode_cmd(ar->arWmi); 990} 991 992static int ar6000_ioctl_siwgenie(struct net_device *dev, 993 struct iw_request_info *info, 994 struct iw_point *dwrq, 995 char *extra) 996{ 997 /* The target does that for us */ 998 return 0; 999} 1000 1001static int ar6000_ioctl_giwgenie(struct net_device *dev, 1002 struct iw_request_info *info, 1003 struct iw_point *dwrq, 1004 char *extra) 1005{ 1006 return 0; 1007} 1008 1009static int ar6000_ioctl_siwauth(struct net_device *dev, 1010 struct iw_request_info *info, 1011 struct iw_param *param, 1012 char *extra) 1013{ 1014 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1015 int reset = 0; 1016 1017 switch (param->flags & IW_AUTH_INDEX) { 1018 case IW_AUTH_WPA_VERSION: 1019 if (param->value & IW_AUTH_WPA_VERSION_DISABLED) { 1020 ar->arAuthMode = NONE_AUTH; 1021 } 1022 if (param->value & IW_AUTH_WPA_VERSION_WPA) { 1023 ar->arAuthMode = WPA_AUTH; 1024 } 1025 if (param->value & IW_AUTH_WPA_VERSION_WPA2) { 1026 ar->arAuthMode = WPA2_AUTH; 1027 } 1028 1029 reset = 1; 1030 break; 1031 case IW_AUTH_CIPHER_PAIRWISE: 1032 if (param->value & IW_AUTH_CIPHER_NONE) { 1033 ar->arPairwiseCrypto = NONE_CRYPT; 1034 } 1035 if (param->value & IW_AUTH_CIPHER_WEP40) { 1036 ar->arPairwiseCrypto = WEP_CRYPT; 1037 } 1038 if (param->value & IW_AUTH_CIPHER_TKIP) { 1039 ar->arPairwiseCrypto = TKIP_CRYPT; 1040 } 1041 if (param->value & IW_AUTH_CIPHER_CCMP) { 1042 ar->arPairwiseCrypto = AES_CRYPT; 1043 } 1044 1045 reset = 1; 1046 break; 1047 case IW_AUTH_CIPHER_GROUP: 1048 if (param->value & IW_AUTH_CIPHER_NONE) { 1049 ar->arGroupCrypto = NONE_CRYPT; 1050 } 1051 if (param->value & IW_AUTH_CIPHER_WEP40) { 1052 ar->arGroupCrypto = WEP_CRYPT; 1053 } 1054 if (param->value & IW_AUTH_CIPHER_TKIP) { 1055 ar->arGroupCrypto = TKIP_CRYPT; 1056 } 1057 if (param->value & IW_AUTH_CIPHER_CCMP) { 1058 ar->arGroupCrypto = AES_CRYPT; 1059 } 1060 1061 reset = 1; 1062 break; 1063 case IW_AUTH_KEY_MGMT: 1064 if (param->value & IW_AUTH_KEY_MGMT_PSK) { 1065 if (ar->arAuthMode == WPA_AUTH) { 1066 ar->arAuthMode = WPA_PSK_AUTH; 1067 } else if (ar->arAuthMode == WPA2_AUTH) { 1068 ar->arAuthMode = WPA2_PSK_AUTH; 1069 } 1070 1071 reset = 1; 1072 } 1073 break; 1074 1075 case IW_AUTH_TKIP_COUNTERMEASURES: 1076 if (ar->arWmiReady == FALSE) { 1077 return -EIO; 1078 } 1079 wmi_set_tkip_countermeasures_cmd(ar->arWmi, param->value); 1080 break; 1081 1082 case IW_AUTH_DROP_UNENCRYPTED: 1083 break; 1084 1085 case IW_AUTH_80211_AUTH_ALG: 1086 if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) { 1087 ar->arDot11AuthMode = OPEN_AUTH; 1088 } 1089 if (param->value & IW_AUTH_ALG_SHARED_KEY) { 1090 ar->arDot11AuthMode = SHARED_AUTH; 1091 } 1092 if (param->value & IW_AUTH_ALG_LEAP) { 1093 ar->arDot11AuthMode = LEAP_AUTH; 1094 ar->arPairwiseCrypto = WEP_CRYPT; 1095 ar->arGroupCrypto = WEP_CRYPT; 1096 } 1097 1098 reset = 1; 1099 break; 1100 1101 case IW_AUTH_WPA_ENABLED: 1102 reset = 1; 1103 break; 1104 1105 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 1106 break; 1107 1108 case IW_AUTH_PRIVACY_INVOKED: 1109 break; 1110 1111 default: 1112 printk("%s(): Unknown flag 0x%x\n", __FUNCTION__, param->flags); 1113 return -EOPNOTSUPP; 1114 } 1115 1116 if (reset) { 1117 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); 1118 ar->arSsidLen = 0; 1119 } 1120 1121 return 0; 1122} 1123 1124static int ar6000_ioctl_giwauth(struct net_device *dev, 1125 struct iw_request_info *info, 1126 struct iw_param *dwrq, 1127 char *extra) 1128{ 1129 return 0; 1130} 1131 1132static int ar6000_ioctl_siwencodeext(struct net_device *dev, 1133 struct iw_request_info *info, 1134 union iwreq_data *wrqu, 1135 char *extra) 1136{ 1137 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1138 struct iw_point *encoding = &wrqu->encoding; 1139 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra; 1140 int alg = ext->alg, idx; 1141 1142 if (ar->arWlanState == WLAN_DISABLED) { 1143 return -EIO; 1144 } 1145 1146 /* Determine and validate the key index */ 1147 idx = (encoding->flags & IW_ENCODE_INDEX) - 1; 1148 if (idx) { 1149 if (idx < 0 || idx > 3) 1150 return -EINVAL; 1151 } 1152 1153 if ((alg == IW_ENCODE_ALG_TKIP) || (alg == IW_ENCODE_ALG_CCMP)) { 1154 struct ieee80211req_key ik; 1155 KEY_USAGE key_usage; 1156 CRYPTO_TYPE key_type = NONE_CRYPT; 1157 int status; 1158 1159 ar->user_saved_keys.keyOk = FALSE; 1160 1161 if (alg == IW_ENCODE_ALG_TKIP) { 1162 key_type = TKIP_CRYPT; 1163 ik.ik_type = IEEE80211_CIPHER_TKIP; 1164 } else { 1165 key_type = AES_CRYPT; 1166 ik.ik_type = IEEE80211_CIPHER_AES_CCM; 1167 } 1168 1169 ik.ik_keyix = idx; 1170 ik.ik_keylen = ext->key_len; 1171 ik.ik_flags = IEEE80211_KEY_RECV; 1172 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) { 1173 ik.ik_flags |= IEEE80211_KEY_XMIT 1174 | IEEE80211_KEY_DEFAULT; 1175 } 1176 1177 if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) { 1178 memcpy(&ik.ik_keyrsc, ext->rx_seq, 8); 1179 } 1180 1181 memcpy(ik.ik_keydata, ext->key, ext->key_len); 1182 1183 ar->user_saved_keys.keyType = key_type; 1184 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) { 1185 key_usage = GROUP_USAGE; 1186 memset(ik.ik_macaddr, 0, ETH_ALEN); 1187 memcpy(&ar->user_saved_keys.bcast_ik, &ik, 1188 sizeof(struct ieee80211req_key)); 1189 } else { 1190 key_usage = PAIRWISE_USAGE; 1191 memcpy(ik.ik_macaddr, ext->addr.sa_data, ETH_ALEN); 1192 memcpy(&ar->user_saved_keys.ucast_ik, &ik, 1193 sizeof(struct ieee80211req_key)); 1194 } 1195 1196 status = wmi_addKey_cmd(ar->arWmi, ik.ik_keyix, key_type, 1197 key_usage, ik.ik_keylen, 1198 (A_UINT8 *)&ik.ik_keyrsc, 1199 ik.ik_keydata, 1200 KEY_OP_INIT_VAL, SYNC_BEFORE_WMIFLAG); 1201 1202 if (status < 0) 1203 return -EIO; 1204 1205 ar->user_saved_keys.keyOk = TRUE; 1206 1207 return 0; 1208 1209 } else { 1210 /* WEP falls back to SIWENCODE */ 1211 return -EOPNOTSUPP; 1212 } 1213 1214 return 0; 1215} 1216 1217 1218static int ar6000_ioctl_giwencodeext(struct net_device *dev, 1219 struct iw_request_info *info, 1220 struct iw_point *dwrq, 1221 char *extra) 1222{ 1223 return 0; 1224} 1225 1226 1227static int 1228ar6000_ioctl_setparam(struct net_device *dev, 1229 struct iw_request_info *info, 1230 void *erq, char *extra) 1231{ 1232 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1233 int *i = (int *)extra; 1234 int param = i[0]; 1235 int value = i[1]; 1236 int ret = 0; 1237 A_BOOL profChanged = FALSE; 1238 1239 if (ar->arWlanState == WLAN_DISABLED) { 1240 return -EIO; 1241 } 1242 1243 switch (param) { 1244 case IEEE80211_PARAM_WPA: 1245 switch (value) { 1246 case WPA_MODE_WPA1: 1247 ar->arAuthMode = WPA_AUTH; 1248 profChanged = TRUE; 1249 break; 1250 case WPA_MODE_WPA2: 1251 ar->arAuthMode = WPA2_AUTH; 1252 profChanged = TRUE; 1253 break; 1254 case WPA_MODE_NONE: 1255 ar->arAuthMode = NONE_AUTH; 1256 profChanged = TRUE; 1257 break; 1258 default: 1259 printk("IEEE80211_PARAM_WPA: Unknown value %d\n", value); 1260 } 1261 break; 1262 case IEEE80211_PARAM_AUTHMODE: 1263 switch(value) { 1264 case IEEE80211_AUTH_WPA_PSK: 1265 if (WPA_AUTH == ar->arAuthMode) { 1266 ar->arAuthMode = WPA_PSK_AUTH; 1267 profChanged = TRUE; 1268 } else if (WPA2_AUTH == ar->arAuthMode) { 1269 ar->arAuthMode = WPA2_PSK_AUTH; 1270 profChanged = TRUE; 1271 } else { 1272 AR_DEBUG_PRINTF("Error - Setting PSK mode when WPA "\ 1273 "param was set to %d\n", 1274 ar->arAuthMode); 1275 ret = -1; 1276 } 1277 break; 1278 case IEEE80211_AUTH_WPA_CCKM: 1279 if (WPA2_AUTH == ar->arAuthMode) { 1280 ar->arAuthMode = WPA2_AUTH_CCKM; 1281 } else { 1282 ar->arAuthMode = WPA_AUTH_CCKM; 1283 } 1284 break; 1285 default: 1286 break; 1287 } 1288 break; 1289 case IEEE80211_PARAM_UCASTCIPHER: 1290 switch (value) { 1291 case IEEE80211_CIPHER_AES_CCM: 1292 ar->arPairwiseCrypto = AES_CRYPT; 1293 profChanged = TRUE; 1294 break; 1295 case IEEE80211_CIPHER_TKIP: 1296 ar->arPairwiseCrypto = TKIP_CRYPT; 1297 profChanged = TRUE; 1298 break; 1299 case IEEE80211_CIPHER_WEP: 1300 ar->arPairwiseCrypto = WEP_CRYPT; 1301 profChanged = TRUE; 1302 break; 1303 case IEEE80211_CIPHER_NONE: 1304 ar->arPairwiseCrypto = NONE_CRYPT; 1305 profChanged = TRUE; 1306 break; 1307 } 1308 break; 1309 case IEEE80211_PARAM_UCASTKEYLEN: 1310 if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(value)) { 1311 ret = -EIO; 1312 } else { 1313 ar->arPairwiseCryptoLen = value; 1314 } 1315 break; 1316 case IEEE80211_PARAM_MCASTCIPHER: 1317 switch (value) { 1318 case IEEE80211_CIPHER_AES_CCM: 1319 ar->arGroupCrypto = AES_CRYPT; 1320 profChanged = TRUE; 1321 break; 1322 case IEEE80211_CIPHER_TKIP: 1323 ar->arGroupCrypto = TKIP_CRYPT; 1324 profChanged = TRUE; 1325 break; 1326 case IEEE80211_CIPHER_WEP: 1327 ar->arGroupCrypto = WEP_CRYPT; 1328 profChanged = TRUE; 1329 break; 1330 case IEEE80211_CIPHER_NONE: 1331 ar->arGroupCrypto = NONE_CRYPT; 1332 profChanged = TRUE; 1333 break; 1334 } 1335 break; 1336 case IEEE80211_PARAM_MCASTKEYLEN: 1337 if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(value)) { 1338 ret = -EIO; 1339 } else { 1340 ar->arGroupCryptoLen = value; 1341 } 1342 break; 1343 case IEEE80211_PARAM_COUNTERMEASURES: 1344 if (ar->arWmiReady == FALSE) { 1345 return -EIO; 1346 } 1347 wmi_set_tkip_countermeasures_cmd(ar->arWmi, value); 1348 break; 1349 default: 1350 break; 1351 } 1352 1353 if (profChanged == TRUE) { 1354 /* 1355 * profile has changed. Erase ssid to signal change 1356 */ 1357 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); 1358 ar->arSsidLen = 0; 1359 } 1360 1361 return ret; 1362} 1363 1364int 1365ar6000_ioctl_getparam(struct net_device *dev, struct iw_request_info *info, 1366 void *w, char *extra) 1367{ 1368 return -EIO; /* for now */ 1369} 1370 1371int 1372ar6000_ioctl_setkey(struct net_device *dev, struct iw_request_info *info, 1373 void *w, char *extra) 1374{ 1375 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1376 struct ieee80211req_key *ik = (struct ieee80211req_key *)extra; 1377 KEY_USAGE keyUsage; 1378 A_STATUS status; 1379 CRYPTO_TYPE keyType = NONE_CRYPT; 1380 1381 if (ar->arWlanState == WLAN_DISABLED) { 1382 return -EIO; 1383 } 1384 1385 ar->user_saved_keys.keyOk = FALSE; 1386 1387 if ( 0 == memcmp(ik->ik_macaddr, "\x00\x00\x00\x00\x00\x00", 1388 IEEE80211_ADDR_LEN)) { 1389 keyUsage = GROUP_USAGE; 1390 A_MEMCPY(&ar->user_saved_keys.bcast_ik, ik, 1391 sizeof(struct ieee80211req_key)); 1392 } else { 1393 keyUsage = PAIRWISE_USAGE; 1394 A_MEMCPY(&ar->user_saved_keys.ucast_ik, ik, 1395 sizeof(struct ieee80211req_key)); 1396 } 1397 1398 switch (ik->ik_type) { 1399 case IEEE80211_CIPHER_WEP: 1400 keyType = WEP_CRYPT; 1401 break; 1402 case IEEE80211_CIPHER_TKIP: 1403 keyType = TKIP_CRYPT; 1404 break; 1405 case IEEE80211_CIPHER_AES_CCM: 1406 keyType = AES_CRYPT; 1407 break; 1408 default: 1409 break; 1410 } 1411 ar->user_saved_keys.keyType = keyType; 1412 1413 if (IEEE80211_CIPHER_CCKM_KRK != ik->ik_type) { 1414 if (NONE_CRYPT == keyType) { 1415 return -EIO; 1416 } 1417 1418 status = wmi_addKey_cmd(ar->arWmi, ik->ik_keyix, keyType, keyUsage, 1419 ik->ik_keylen, (A_UINT8 *)&ik->ik_keyrsc, 1420 ik->ik_keydata, KEY_OP_INIT_VAL, 1421 SYNC_BEFORE_WMIFLAG); 1422 1423 if (status != A_OK) { 1424 return -EIO; 1425 } 1426 } else { 1427 status = wmi_add_krk_cmd(ar->arWmi, ik->ik_keydata); 1428 } 1429 1430 ar->user_saved_keys.keyOk = TRUE; 1431 1432 return 0; 1433} 1434 1435 1436/* 1437 * SIOCGIWNAME 1438 */ 1439int 1440ar6000_ioctl_giwname(struct net_device *dev, 1441 struct iw_request_info *info, 1442 char *name, char *extra) 1443{ 1444 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1445 1446 if (ar->arWlanState == WLAN_DISABLED) { 1447 return -EIO; 1448 } 1449 1450 switch (ar->arPhyCapability) { 1451 case (WMI_11A_CAPABILITY): 1452 strncpy(name, "AR6000 802.11a", IFNAMSIZ); 1453 break; 1454 case (WMI_11G_CAPABILITY): 1455 strncpy(name, "AR6000 802.11g", IFNAMSIZ); 1456 break; 1457 case (WMI_11AG_CAPABILITY): 1458 strncpy(name, "AR6000 802.11ag", IFNAMSIZ); 1459 break; 1460 default: 1461 strncpy(name, "AR6000 802.11", IFNAMSIZ); 1462 break; 1463 } 1464 1465 return 0; 1466} 1467 1468/* 1469 * SIOCSIWFREQ 1470 */ 1471int 1472ar6000_ioctl_siwfreq(struct net_device *dev, 1473 struct iw_request_info *info, 1474 struct iw_freq *freq, char *extra) 1475{ 1476 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1477 1478 if (ar->arWlanState == WLAN_DISABLED) { 1479 return -EIO; 1480 } 1481 1482 /* 1483 * We support limiting the channels via wmiconfig. 1484 * 1485 * We use this command to configure the channel hint for the connect cmd 1486 * so it is possible the target will end up connecting to a different 1487 * channel. 1488 */ 1489 if (freq->e > 1) { 1490 return -EINVAL; 1491 } else if (freq->e == 1) { 1492 ar->arChannelHint = freq->m / 100000; 1493 } else { 1494 ar->arChannelHint = wlan_ieee2freq(freq->m); 1495 } 1496 1497 A_PRINTF("channel hint set to %d\n", ar->arChannelHint); 1498 return 0; 1499} 1500 1501/* 1502 * SIOCGIWFREQ 1503 */ 1504int 1505ar6000_ioctl_giwfreq(struct net_device *dev, 1506 struct iw_request_info *info, 1507 struct iw_freq *freq, char *extra) 1508{ 1509 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1510 1511 if (ar->arWlanState == WLAN_DISABLED) { 1512 return -EIO; 1513 } 1514 1515 if (ar->arConnected != TRUE) { 1516 return -EINVAL; 1517 } 1518 1519 freq->m = ar->arBssChannel * 100000; 1520 freq->e = 1; 1521 1522 return 0; 1523} 1524 1525/* 1526 * SIOCSIWMODE 1527 */ 1528int 1529ar6000_ioctl_siwmode(struct net_device *dev, 1530 struct iw_request_info *info, 1531 __u32 *mode, char *extra) 1532{ 1533 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1534 1535 if (ar->arWlanState == WLAN_DISABLED) { 1536 return -EIO; 1537 } 1538 1539 switch (*mode) { 1540 case IW_MODE_INFRA: 1541 ar->arNetworkType = INFRA_NETWORK; 1542 break; 1543 case IW_MODE_ADHOC: 1544 ar->arNetworkType = ADHOC_NETWORK; 1545 break; 1546 default: 1547 return -EINVAL; 1548 } 1549 1550 return 0; 1551} 1552 1553/* 1554 * SIOCGIWMODE 1555 */ 1556int 1557ar6000_ioctl_giwmode(struct net_device *dev, 1558 struct iw_request_info *info, 1559 __u32 *mode, char *extra) 1560{ 1561 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1562 1563 if (ar->arWlanState == WLAN_DISABLED) { 1564 return -EIO; 1565 } 1566 1567 switch (ar->arNetworkType) { 1568 case INFRA_NETWORK: 1569 *mode = IW_MODE_INFRA; 1570 break; 1571 case ADHOC_NETWORK: 1572 *mode = IW_MODE_ADHOC; 1573 break; 1574 default: 1575 return -EIO; 1576 } 1577 return 0; 1578} 1579 1580/* 1581 * SIOCSIWSENS 1582 */ 1583int 1584ar6000_ioctl_siwsens(struct net_device *dev, 1585 struct iw_request_info *info, 1586 struct iw_param *sens, char *extra) 1587{ 1588 return 0; 1589} 1590 1591/* 1592 * SIOCGIWSENS 1593 */ 1594int 1595ar6000_ioctl_giwsens(struct net_device *dev, 1596 struct iw_request_info *info, 1597 struct iw_param *sens, char *extra) 1598{ 1599 sens->value = 0; 1600 sens->fixed = 1; 1601 1602 return 0; 1603} 1604 1605/* 1606 * SIOCGIWRANGE 1607 */ 1608int 1609ar6000_ioctl_giwrange(struct net_device *dev, 1610 struct iw_request_info *info, 1611 struct iw_point *data, char *extra) 1612{ 1613 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1614 struct iw_range *range = (struct iw_range *) extra; 1615 int i, ret = 0; 1616 1617 if (ar->arWmiReady == FALSE) { 1618 return -EIO; 1619 } 1620 1621 if (ar->arWlanState == WLAN_DISABLED) { 1622 return -EIO; 1623 } 1624 1625 if (down_interruptible(&ar->arSem)) { 1626 return -ERESTARTSYS; 1627 } 1628 ar->arNumChannels = -1; 1629 A_MEMZERO(ar->arChannelList, sizeof (ar->arChannelList)); 1630 1631 if (wmi_get_channelList_cmd(ar->arWmi) != A_OK) { 1632 up(&ar->arSem); 1633 return -EIO; 1634 } 1635 1636 wait_event_interruptible_timeout(arEvent, ar->arNumChannels != -1, wmitimeout * HZ); 1637 1638 if (signal_pending(current)) { 1639 up(&ar->arSem); 1640 return -EINTR; 1641 } 1642 1643 data->length = sizeof(struct iw_range); 1644 A_MEMZERO(range, sizeof(struct iw_range)); 1645 1646 range->txpower_capa = IW_TXPOW_DBM; 1647 1648 range->min_pmp = 1 * 1024; 1649 range->max_pmp = 65535 * 1024; 1650 range->min_pmt = 1 * 1024; 1651 range->max_pmt = 1000 * 1024; 1652 range->pmp_flags = IW_POWER_PERIOD; 1653 range->pmt_flags = IW_POWER_TIMEOUT; 1654 range->pm_capa = 0; 1655 1656 range->we_version_compiled = WIRELESS_EXT; 1657 range->we_version_source = 13; 1658 1659 range->retry_capa = IW_RETRY_LIMIT; 1660 range->retry_flags = IW_RETRY_LIMIT; 1661 range->min_retry = 0; 1662 range->max_retry = 255; 1663 1664 range->num_frequency = range->num_channels = ar->arNumChannels; 1665 for (i = 0; i < ar->arNumChannels; i++) { 1666 range->freq[i].i = wlan_freq2ieee(ar->arChannelList[i]); 1667 range->freq[i].m = ar->arChannelList[i] * 100000; 1668 range->freq[i].e = 1; 1669 /* 1670 * Linux supports max of 32 channels, bail out once you 1671 * reach the max. 1672 */ 1673 if (i == IW_MAX_FREQUENCIES) { 1674 break; 1675 } 1676 } 1677 1678 /* Max quality is max field value minus noise floor */ 1679 range->max_qual.qual = 0xff - 161; 1680 1681 /* 1682 * In order to use dBm measurements, 'level' must be lower 1683 * than any possible measurement (see iw_print_stats() in 1684 * wireless tools). It's unclear how this is meant to be 1685 * done, but setting zero in these values forces dBm and 1686 * the actual numbers are not used. 1687 */ 1688 range->max_qual.level = 0; 1689 range->max_qual.noise = 0; 1690 1691 range->sensitivity = 3; 1692 1693 range->max_encoding_tokens = 4; 1694 /* XXX query driver to find out supported key sizes */ 1695 range->num_encoding_sizes = 3; 1696 range->encoding_size[0] = 5; /* 40-bit */ 1697 range->encoding_size[1] = 13; /* 104-bit */ 1698 range->encoding_size[2] = 16; /* 128-bit */ 1699 1700 range->num_bitrates = 0; 1701 1702 /* estimated maximum TCP throughput values (bps) */ 1703 range->throughput = 22000000; 1704 1705 range->min_rts = 0; 1706 range->max_rts = 2347; 1707 range->min_frag = 256; 1708 range->max_frag = 2346; 1709 1710 up(&ar->arSem); 1711 1712 return ret; 1713} 1714 1715 1716/* 1717 * SIOCSIWAP 1718 * This ioctl is used to set the desired bssid for the connect command. 1719 */ 1720int 1721ar6000_ioctl_siwap(struct net_device *dev, 1722 struct iw_request_info *info, 1723 struct sockaddr *ap_addr, char *extra) 1724{ 1725 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1726 1727 if (ar->arWlanState == WLAN_DISABLED) { 1728 return -EIO; 1729 } 1730 1731 if (ap_addr->sa_family != ARPHRD_ETHER) { 1732 return -EIO; 1733 } 1734 1735 if (A_MEMCMP(&ap_addr->sa_data, bcast_mac, AR6000_ETH_ADDR_LEN) == 0) { 1736 A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid)); 1737 } else { 1738 A_MEMCPY(ar->arReqBssid, &ap_addr->sa_data, sizeof(ar->arReqBssid)); 1739 } 1740 1741 return 0; 1742} 1743 1744/* 1745 * SIOCGIWAP 1746 */ 1747int 1748ar6000_ioctl_giwap(struct net_device *dev, 1749 struct iw_request_info *info, 1750 struct sockaddr *ap_addr, char *extra) 1751{ 1752 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1753 1754 if (ar->arWlanState == WLAN_DISABLED) { 1755 return -EIO; 1756 } 1757 1758 if (ar->arConnected != TRUE) { 1759 return -EINVAL; 1760 } 1761 1762 A_MEMCPY(&ap_addr->sa_data, ar->arBssid, sizeof(ar->arBssid)); 1763 ap_addr->sa_family = ARPHRD_ETHER; 1764 1765 return 0; 1766} 1767 1768/* 1769 * SIOCGIWAPLIST 1770 */ 1771int 1772ar6000_ioctl_iwaplist(struct net_device *dev, 1773 struct iw_request_info *info, 1774 struct iw_point *data, char *extra) 1775{ 1776 return -EIO; /* for now */ 1777} 1778 1779/* 1780 * SIOCSIWSCAN 1781 */ 1782int 1783ar6000_ioctl_siwscan(struct net_device *dev, 1784 struct iw_request_info *info, 1785 struct iw_point *data, char *extra) 1786{ 1787#define ACT_DWELLTIME_DEFAULT 105 1788#define HOME_TXDRAIN_TIME 100 1789#define SCAN_INT HOME_TXDRAIN_TIME + ACT_DWELLTIME_DEFAULT 1790 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev); 1791 int ret = 0; 1792 1793 if (ar->arWmiReady == FALSE) { 1794 return -EIO; 1795 } 1796 1797 if (ar->arWlanState == WLAN_DISABLED) { 1798 return -EIO; 1799 } 1800 1801 /* We ask for everything from the target */ 1802 if (wmi_bssfilter_cmd(ar->arWmi, ALL_BSS_FILTER, 0) != A_OK) { 1803 printk("Couldn't set filtering\n"); 1804 ret = -EIO; 1805 } 1806 1807 if (wmi_startscan_cmd(ar->arWmi, WMI_LONG_SCAN, FALSE, FALSE, \ 1808 HOME_TXDRAIN_TIME, SCAN_INT) != A_OK) { 1809 ret = -EIO; 1810 } 1811 1812 ar->scan_complete = 0; 1813 wait_event_interruptible_timeout(ar6000_scan_queue, ar->scan_complete, 1814 5 * HZ); 1815 1816 if (wmi_bssfilter_cmd(ar->arWmi, NONE_BSS_FILTER, 0) != A_OK) { 1817 printk("Couldn't set filtering\n"); 1818 ret = -EIO; 1819 } 1820 1821 return ret; 1822#undef ACT_DWELLTIME_DEFAULT 1823#undef HOME_TXDRAIN_TIME 1824#undef SCAN_INT 1825} 1826 1827 1828/* 1829 * Units are in db above the noise floor. That means the 1830 * rssi values reported in the tx/rx descriptors in the 1831 * driver are the SNR expressed in db. 1832 * 1833 * If you assume that the noise floor is -95, which is an 1834 * excellent assumption 99.5 % of the time, then you can 1835 * derive the absolute signal level (i.e. -95 + rssi). 1836 * There are some other slight factors to take into account 1837 * depending on whether the rssi measurement is from 11b, 1838 * 11g, or 11a. These differences are at most 2db and 1839 * can be documented. 1840 * 1841 * NB: various calculations are based on the orinoco/wavelan 1842 * drivers for compatibility 1843 */ 1844static void 1845ar6000_set_quality(struct iw_quality *iq, A_INT8 rssi) 1846{ 1847 if (rssi < 0) { 1848 iq->qual = 0; 1849 } else { 1850 iq->qual = rssi; 1851 } 1852 1853 /* NB: max is 94 because noise is hardcoded to 161 */ 1854 if (iq->qual > 94) 1855 iq->qual = 94; 1856 1857 iq->noise = 161; /* -95dBm */ 1858 iq->level = iq->noise + iq->qual; 1859 iq->updated = 7; 1860} 1861 1862 1863/* Structures to export the Wireless Handlers */ 1864static const iw_handler ath_handlers[] = { 1865 (iw_handler) NULL, /* SIOCSIWCOMMIT */ 1866 (iw_handler) ar6000_ioctl_giwname, /* SIOCGIWNAME */ 1867 (iw_handler) NULL, /* SIOCSIWNWID */ 1868 (iw_handler) NULL, /* SIOCGIWNWID */ 1869 (iw_handler) ar6000_ioctl_siwfreq, /* SIOCSIWFREQ */ 1870 (iw_handler) ar6000_ioctl_giwfreq, /* SIOCGIWFREQ */ 1871 (iw_handler) ar6000_ioctl_siwmode, /* SIOCSIWMODE */ 1872 (iw_handler) ar6000_ioctl_giwmode, /* SIOCGIWMODE */ 1873 (iw_handler) ar6000_ioctl_siwsens, /* SIOCSIWSENS */ 1874 (iw_handler) ar6000_ioctl_giwsens, /* SIOCGIWSENS */ 1875 (iw_handler) NULL /* not _used */, /* SIOCSIWRANGE */ 1876 (iw_handler) ar6000_ioctl_giwrange, /* SIOCGIWRANGE */ 1877 (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */ 1878 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */ 1879 (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */ 1880 (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */ 1881 (iw_handler) NULL, /* SIOCSIWSPY */ 1882 (iw_handler) NULL, /* SIOCGIWSPY */ 1883 (iw_handler) NULL, /* SIOCSIWTHRSPY */ 1884 (iw_handler) NULL, /* SIOCGIWTHRSPY */ 1885 (iw_handler) ar6000_ioctl_siwap, /* SIOCSIWAP */ 1886 (iw_handler) ar6000_ioctl_giwap, /* SIOCGIWAP */ 1887 (iw_handler) NULL, /* -- hole -- */ 1888 (iw_handler) ar6000_ioctl_iwaplist, /* SIOCGIWAPLIST */ 1889 (iw_handler) ar6000_ioctl_siwscan, /* SIOCSIWSCAN */ 1890 (iw_handler) ar6000_ioctl_giwscan, /* SIOCGIWSCAN */ 1891 (iw_handler) ar6000_ioctl_siwessid, /* SIOCSIWESSID */ 1892 (iw_handler) ar6000_ioctl_giwessid, /* SIOCGIWESSID */ 1893 (iw_handler) NULL, /* SIOCSIWNICKN */ 1894 (iw_handler) NULL, /* SIOCGIWNICKN */ 1895 (iw_handler) NULL, /* -- hole -- */ 1896 (iw_handler) NULL, /* -- hole -- */ 1897 (iw_handler) ar6000_ioctl_siwrate, /* SIOCSIWRATE */ 1898 (iw_handler) ar6000_ioctl_giwrate, /* SIOCGIWRATE */ 1899 (iw_handler) NULL, /* SIOCSIWRTS */ 1900 (iw_handler) NULL, /* SIOCGIWRTS */ 1901 (iw_handler) NULL, /* SIOCSIWFRAG */ 1902 (iw_handler) NULL, /* SIOCGIWFRAG */ 1903 (iw_handler) ar6000_ioctl_siwtxpow, /* SIOCSIWTXPOW */ 1904 (iw_handler) ar6000_ioctl_giwtxpow, /* SIOCGIWTXPOW */ 1905 (iw_handler) ar6000_ioctl_siwretry, /* SIOCSIWRETRY */ 1906 (iw_handler) ar6000_ioctl_giwretry, /* SIOCGIWRETRY */ 1907 (iw_handler) ar6000_ioctl_siwencode, /* SIOCSIWENCODE */ 1908 (iw_handler) ar6000_ioctl_giwencode, /* SIOCGIWENCODE */ 1909 (iw_handler) ar6000_ioctl_siwpower, /* SIOCSIWPOWER */ 1910 (iw_handler) ar6000_ioctl_giwpower, /* SIOCGIWPOWER */ 1911 (iw_handler) NULL, /* -- hole -- */ 1912 (iw_handler) NULL, /* -- hole -- */ 1913 (iw_handler) ar6000_ioctl_siwgenie, /* SIOCSIWGENIE */ 1914 (iw_handler) ar6000_ioctl_giwgenie, /* SIOCGIWGENIE */ 1915 (iw_handler) ar6000_ioctl_siwauth, /* SIOCSIWAUTH */ 1916 (iw_handler) ar6000_ioctl_giwauth, /* SIOCGIWAUTH */ 1917 (iw_handler) ar6000_ioctl_siwencodeext,/* SIOCSIWENCODEEXT */ 1918 (iw_handler) ar6000_ioctl_giwencodeext,/* SIOCGIWENCODEEXT */ 1919 (iw_handler) NULL, /* SIOCSIWPMKSA */ 1920}; 1921 1922static const iw_handler ath_priv_handlers[] = { 1923 (iw_handler) ar6000_ioctl_setparam, /* SIOCWFIRSTPRIV+0 */ 1924 (iw_handler) ar6000_ioctl_getparam, /* SIOCWFIRSTPRIV+1 */ 1925 (iw_handler) ar6000_ioctl_setkey, /* SIOCWFIRSTPRIV+2 */ 1926 (iw_handler) ar6000_ioctl_setwmmparams, /* SIOCWFIRSTPRIV+3 */ 1927 (iw_handler) ar6000_ioctl_delkey, /* SIOCWFIRSTPRIV+4 */ 1928 (iw_handler) ar6000_ioctl_getwmmparams, /* SIOCWFIRSTPRIV+5 */ 1929 (iw_handler) ar6000_ioctl_setoptie, /* SIOCWFIRSTPRIV+6 */ 1930 (iw_handler) ar6000_ioctl_setmlme, /* SIOCWFIRSTPRIV+7 */ 1931 (iw_handler) ar6000_ioctl_addpmkid, /* SIOCWFIRSTPRIV+8 */ 1932}; 1933 1934#define IW_PRIV_TYPE_KEY \ 1935 (IW_PRIV_TYPE_BYTE | sizeof(struct ieee80211req_key)) 1936#define IW_PRIV_TYPE_DELKEY \ 1937 (IW_PRIV_TYPE_BYTE | sizeof(struct ieee80211req_del_key)) 1938#define IW_PRIV_TYPE_MLME \ 1939 (IW_PRIV_TYPE_BYTE | sizeof(struct ieee80211req_mlme)) 1940#define IW_PRIV_TYPE_ADDPMKID \ 1941 (IW_PRIV_TYPE_BYTE | sizeof(struct ieee80211req_addpmkid)) 1942 1943static const struct iw_priv_args ar6000_priv_args[] = { 1944 { IEEE80211_IOCTL_SETKEY, 1945 IW_PRIV_TYPE_KEY | IW_PRIV_SIZE_FIXED, 0, "setkey"}, 1946 { IEEE80211_IOCTL_DELKEY, 1947 IW_PRIV_TYPE_DELKEY | IW_PRIV_SIZE_FIXED, 0, "delkey"}, 1948 { IEEE80211_IOCTL_SETPARAM, 1949 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "setparam"}, 1950 { IEEE80211_IOCTL_GETPARAM, 1951 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 1952 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getparam"}, 1953 { IEEE80211_IOCTL_SETWMMPARAMS, 1954 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 4, 0, "setwmmparams"}, 1955 { IEEE80211_IOCTL_GETWMMPARAMS, 1956 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 3, 1957 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getwmmparams"}, 1958 { IEEE80211_IOCTL_SETOPTIE, 1959 IW_PRIV_TYPE_BYTE, 0, "setie"}, 1960 { IEEE80211_IOCTL_SETMLME, 1961 IW_PRIV_TYPE_MLME, 0, "setmlme"}, 1962 { IEEE80211_IOCTL_ADDPMKID, 1963 IW_PRIV_TYPE_ADDPMKID | IW_PRIV_SIZE_FIXED, 0, "addpmkid"}, 1964}; 1965 1966void ar6000_ioctl_iwsetup(struct iw_handler_def *def) 1967{ 1968 def->private_args = (struct iw_priv_args *)ar6000_priv_args; 1969 def->num_private_args = ARRAY_SIZE(ar6000_priv_args); 1970} 1971 1972struct iw_handler_def ath_iw_handler_def = { 1973 .standard = (iw_handler *)ath_handlers, 1974 .num_standard = ARRAY_SIZE(ath_handlers), 1975 .private = (iw_handler *)ath_priv_handlers, 1976 .num_private = ARRAY_SIZE(ath_priv_handlers), 1977}; 1978 1979 1980