1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * This file contains wireless extension handlers. 5 * 6 * This is part of rtl8180 OpenSource driver. 7 * Copyright (C) Andrea Merello 2004-2005 <andrea.merello@gmail.com> 8 * 9 * Parts of this driver are based on the GPL part 10 * of the official realtek driver. 11 * 12 * Parts of this driver are based on the rtl8180 driver skeleton 13 * from Patric Schenke & Andres Salomon. 14 * 15 * Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver. 16 * 17 * We want to thank the Authors of those projects and the Ndiswrapper 18 * project Authors. 19 * 20 *****************************************************************************/ 21 22 #include <linux/string.h> 23 #include "r8192U.h" 24 #include "r8192U_hw.h" 25 26 #include "ieee80211/dot11d.h" 27 #include "r8192U_wx.h" 28 29 #define RATE_COUNT 12 30 static const u32 rtl8180_rates[] = {1000000, 2000000, 5500000, 11000000, 31 6000000, 9000000, 12000000, 18000000, 24000000, 36000000, 48000000, 54000000}; 32 33 #ifndef ENETDOWN 34 #define ENETDOWN 1 35 #endif 36 37 static int r8192_wx_get_freq(struct net_device *dev, 38 struct iw_request_info *a, 39 union iwreq_data *wrqu, char *b) 40 { 41 struct r8192_priv *priv = ieee80211_priv(dev); 42 43 return ieee80211_wx_get_freq(priv->ieee80211, a, wrqu, b); 44 } 45 46 static int r8192_wx_get_mode(struct net_device *dev, struct iw_request_info *a, 47 union iwreq_data *wrqu, char *b) 48 { 49 struct r8192_priv *priv = ieee80211_priv(dev); 50 51 return ieee80211_wx_get_mode(priv->ieee80211, a, wrqu, b); 52 } 53 54 static int r8192_wx_get_rate(struct net_device *dev, 55 struct iw_request_info *info, 56 union iwreq_data *wrqu, char *extra) 57 { 58 struct r8192_priv *priv = ieee80211_priv(dev); 59 60 return ieee80211_wx_get_rate(priv->ieee80211, info, wrqu, extra); 61 } 62 63 static int r8192_wx_set_rate(struct net_device *dev, 64 struct iw_request_info *info, 65 union iwreq_data *wrqu, char *extra) 66 { 67 int ret; 68 struct r8192_priv *priv = ieee80211_priv(dev); 69 70 mutex_lock(&priv->wx_mutex); 71 72 ret = ieee80211_wx_set_rate(priv->ieee80211, info, wrqu, extra); 73 74 mutex_unlock(&priv->wx_mutex); 75 76 return ret; 77 } 78 79 static int r8192_wx_set_rts(struct net_device *dev, 80 struct iw_request_info *info, 81 union iwreq_data *wrqu, char *extra) 82 { 83 int ret; 84 struct r8192_priv *priv = ieee80211_priv(dev); 85 86 mutex_lock(&priv->wx_mutex); 87 88 ret = ieee80211_wx_set_rts(priv->ieee80211, info, wrqu, extra); 89 90 mutex_unlock(&priv->wx_mutex); 91 92 return ret; 93 } 94 95 static int r8192_wx_get_rts(struct net_device *dev, 96 struct iw_request_info *info, 97 union iwreq_data *wrqu, char *extra) 98 { 99 struct r8192_priv *priv = ieee80211_priv(dev); 100 101 return ieee80211_wx_get_rts(priv->ieee80211, info, wrqu, extra); 102 } 103 104 static int r8192_wx_set_power(struct net_device *dev, 105 struct iw_request_info *info, 106 union iwreq_data *wrqu, char *extra) 107 { 108 int ret; 109 struct r8192_priv *priv = ieee80211_priv(dev); 110 111 mutex_lock(&priv->wx_mutex); 112 113 ret = ieee80211_wx_set_power(priv->ieee80211, info, wrqu, extra); 114 115 mutex_unlock(&priv->wx_mutex); 116 117 return ret; 118 } 119 120 static int r8192_wx_get_power(struct net_device *dev, 121 struct iw_request_info *info, 122 union iwreq_data *wrqu, char *extra) 123 { 124 struct r8192_priv *priv = ieee80211_priv(dev); 125 126 return ieee80211_wx_get_power(priv->ieee80211, info, wrqu, extra); 127 } 128 129 static int r8192_wx_force_reset(struct net_device *dev, 130 struct iw_request_info *info, 131 union iwreq_data *wrqu, char *extra) 132 { 133 struct r8192_priv *priv = ieee80211_priv(dev); 134 135 mutex_lock(&priv->wx_mutex); 136 137 netdev_dbg(dev, "%s(): force reset ! extra is %d\n", __func__, *extra); 138 priv->force_reset = *extra; 139 mutex_unlock(&priv->wx_mutex); 140 return 0; 141 } 142 143 static int r8192_wx_set_rawtx(struct net_device *dev, 144 struct iw_request_info *info, 145 union iwreq_data *wrqu, char *extra) 146 { 147 struct r8192_priv *priv = ieee80211_priv(dev); 148 int ret; 149 150 mutex_lock(&priv->wx_mutex); 151 152 ret = ieee80211_wx_set_rawtx(priv->ieee80211, info, wrqu, extra); 153 154 mutex_unlock(&priv->wx_mutex); 155 156 return ret; 157 } 158 159 static int r8192_wx_set_crcmon(struct net_device *dev, 160 struct iw_request_info *info, 161 union iwreq_data *wrqu, char *extra) 162 { 163 struct r8192_priv *priv = ieee80211_priv(dev); 164 int *parms = (int *)extra; 165 int enable = (parms[0] > 0); 166 167 mutex_lock(&priv->wx_mutex); 168 169 if (enable) 170 priv->crcmon = 1; 171 else 172 priv->crcmon = 0; 173 174 DMESG("bad CRC in monitor mode are %s", 175 priv->crcmon ? "accepted" : "rejected"); 176 177 mutex_unlock(&priv->wx_mutex); 178 179 return 0; 180 } 181 182 static int r8192_wx_set_mode(struct net_device *dev, struct iw_request_info *a, 183 union iwreq_data *wrqu, char *b) 184 { 185 struct r8192_priv *priv = ieee80211_priv(dev); 186 int ret; 187 188 mutex_lock(&priv->wx_mutex); 189 190 ret = ieee80211_wx_set_mode(priv->ieee80211, a, wrqu, b); 191 192 rtl8192_set_rxconf(dev); 193 194 mutex_unlock(&priv->wx_mutex); 195 return ret; 196 } 197 198 struct iw_range_with_scan_capa { 199 /* Informative stuff (to choose between different interface) */ 200 __u32 throughput; /* To give an idea... */ 201 /* In theory this value should be the maximum benchmarked 202 * TCP/IP throughput, because with most of these devices the 203 * bit rate is meaningless (overhead an co) to estimate how 204 * fast the connection will go and pick the fastest one. 205 * I suggest people to play with Netperf or any benchmark... 206 */ 207 208 /* NWID (or domain id) */ 209 __u32 min_nwid; /* Minimal NWID we are able to set */ 210 __u32 max_nwid; /* Maximal NWID we are able to set */ 211 212 /* Old Frequency (backward compat - moved lower ) */ 213 __u16 old_num_channels; 214 __u8 old_num_frequency; 215 216 /* Scan capabilities */ 217 __u8 scan_capa; 218 }; 219 220 static int rtl8180_wx_get_range(struct net_device *dev, 221 struct iw_request_info *info, 222 union iwreq_data *wrqu, char *extra) 223 { 224 struct iw_range *range = (struct iw_range *)extra; 225 struct iw_range_with_scan_capa *tmp = (struct iw_range_with_scan_capa *)range; 226 struct r8192_priv *priv = ieee80211_priv(dev); 227 u16 val; 228 int i; 229 230 wrqu->data.length = sizeof(*range); 231 memset(range, 0, sizeof(*range)); 232 233 /* Let's try to keep this struct in the same order as in 234 * linux/include/wireless.h 235 */ 236 237 /* TODO: See what values we can set, and remove the ones we can't 238 * set, or fill them with some default data. 239 */ 240 241 /* ~5 Mb/s real (802.11b) */ 242 range->throughput = 5 * 1000 * 1000; 243 244 /* TODO: Not used in 802.11b? */ 245 /* range->min_nwid; */ /* Minimal NWID we are able to set */ 246 /* TODO: Not used in 802.11b? */ 247 /* range->max_nwid; */ /* Maximal NWID we are able to set */ 248 249 /* Old Frequency (backward compat - moved lower ) */ 250 /* range->old_num_channels; */ 251 /* range->old_num_frequency; */ 252 /* range->old_freq[6]; */ /* Filler to keep "version" at the same offset */ 253 if (priv->rf_set_sens) 254 range->sensitivity = priv->max_sens; /* signal level threshold range */ 255 256 range->max_qual.qual = 100; 257 /* TODO: Find real max RSSI and stick here */ 258 range->max_qual.level = 0; 259 range->max_qual.noise = 0x100 - 98; 260 range->max_qual.updated = 7; /* Updated all three */ 261 262 range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */ 263 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */ 264 range->avg_qual.level = 0x100 - 78; 265 range->avg_qual.noise = 0; 266 range->avg_qual.updated = 7; /* Updated all three */ 267 268 range->num_bitrates = RATE_COUNT; 269 270 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) 271 range->bitrate[i] = rtl8180_rates[i]; 272 273 range->min_frag = MIN_FRAG_THRESHOLD; 274 range->max_frag = MAX_FRAG_THRESHOLD; 275 276 range->min_pmp = 0; 277 range->max_pmp = 5000000; 278 range->min_pmt = 0; 279 range->max_pmt = 65535 * 1000; 280 range->pmp_flags = IW_POWER_PERIOD; 281 range->pmt_flags = IW_POWER_TIMEOUT; 282 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R; 283 284 range->we_version_compiled = WIRELESS_EXT; 285 range->we_version_source = 16; 286 287 /* range->retry_capa; */ /* What retry options are supported */ 288 /* range->retry_flags; */ /* How to decode max/min retry limit */ 289 /* range->r_time_flags; */ /* How to decode max/min retry life */ 290 /* range->min_retry; */ /* Minimal number of retries */ 291 /* range->max_retry; */ /* Maximal number of retries */ 292 /* range->min_r_time; */ /* Minimal retry lifetime */ 293 /* range->max_r_time; */ /* Maximal retry lifetime */ 294 295 for (i = 0, val = 0; i < 14; i++) { 296 /* Include only legal frequencies for some countries */ 297 if ((GET_DOT11D_INFO(priv->ieee80211)->channel_map)[i + 1]) { 298 range->freq[val].i = i + 1; 299 range->freq[val].m = ieee80211_wlan_frequencies[i] * 100000; 300 range->freq[val].e = 1; 301 val++; 302 } else { 303 /* FIXME: do we need to set anything for channels */ 304 /* we don't use ? */ 305 } 306 307 if (val == IW_MAX_FREQUENCIES) 308 break; 309 } 310 range->num_frequency = val; 311 range->num_channels = val; 312 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 | 313 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP; 314 tmp->scan_capa = 0x01; 315 return 0; 316 } 317 318 static int r8192_wx_set_scan(struct net_device *dev, struct iw_request_info *a, 319 union iwreq_data *wrqu, char *b) 320 { 321 struct r8192_priv *priv = ieee80211_priv(dev); 322 struct ieee80211_device *ieee = priv->ieee80211; 323 int ret = 0; 324 325 if (!priv->up) 326 return -ENETDOWN; 327 328 if (priv->ieee80211->LinkDetectInfo.bBusyTraffic) 329 return -EAGAIN; 330 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) { 331 struct iw_scan_req *req = (struct iw_scan_req *)b; 332 333 if (req->essid_len) { 334 int len = min_t(int, req->essid_len, IW_ESSID_MAX_SIZE); 335 336 ieee->current_network.ssid_len = len; 337 memcpy(ieee->current_network.ssid, req->essid, len); 338 } 339 } 340 341 mutex_lock(&priv->wx_mutex); 342 if (priv->ieee80211->state != IEEE80211_LINKED) { 343 priv->ieee80211->scanning = 0; 344 ieee80211_softmac_scan_syncro(priv->ieee80211); 345 ret = 0; 346 } else { 347 ret = ieee80211_wx_set_scan(priv->ieee80211, a, wrqu, b); 348 } 349 mutex_unlock(&priv->wx_mutex); 350 return ret; 351 } 352 353 static int r8192_wx_get_scan(struct net_device *dev, struct iw_request_info *a, 354 union iwreq_data *wrqu, char *b) 355 { 356 int ret; 357 struct r8192_priv *priv = ieee80211_priv(dev); 358 359 if (!priv->up) 360 return -ENETDOWN; 361 362 mutex_lock(&priv->wx_mutex); 363 364 ret = ieee80211_wx_get_scan(priv->ieee80211, a, wrqu, b); 365 366 mutex_unlock(&priv->wx_mutex); 367 368 return ret; 369 } 370 371 static int r8192_wx_set_essid(struct net_device *dev, 372 struct iw_request_info *a, 373 union iwreq_data *wrqu, char *b) 374 { 375 struct r8192_priv *priv = ieee80211_priv(dev); 376 int ret; 377 378 mutex_lock(&priv->wx_mutex); 379 380 ret = ieee80211_wx_set_essid(priv->ieee80211, a, wrqu, b); 381 382 mutex_unlock(&priv->wx_mutex); 383 384 return ret; 385 } 386 387 static int r8192_wx_get_essid(struct net_device *dev, 388 struct iw_request_info *a, 389 union iwreq_data *wrqu, char *b) 390 { 391 int ret; 392 struct r8192_priv *priv = ieee80211_priv(dev); 393 394 mutex_lock(&priv->wx_mutex); 395 396 ret = ieee80211_wx_get_essid(priv->ieee80211, a, wrqu, b); 397 398 mutex_unlock(&priv->wx_mutex); 399 400 return ret; 401 } 402 403 static int r8192_wx_set_freq(struct net_device *dev, struct iw_request_info *a, 404 union iwreq_data *wrqu, char *b) 405 { 406 int ret; 407 struct r8192_priv *priv = ieee80211_priv(dev); 408 409 mutex_lock(&priv->wx_mutex); 410 411 ret = ieee80211_wx_set_freq(priv->ieee80211, a, wrqu, b); 412 413 mutex_unlock(&priv->wx_mutex); 414 return ret; 415 } 416 417 static int r8192_wx_get_name(struct net_device *dev, 418 struct iw_request_info *info, 419 union iwreq_data *wrqu, char *extra) 420 { 421 struct r8192_priv *priv = ieee80211_priv(dev); 422 423 return ieee80211_wx_get_name(priv->ieee80211, info, wrqu, extra); 424 } 425 426 static int r8192_wx_set_frag(struct net_device *dev, 427 struct iw_request_info *info, 428 union iwreq_data *wrqu, char *extra) 429 { 430 struct r8192_priv *priv = ieee80211_priv(dev); 431 432 if (wrqu->frag.disabled) { 433 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD; 434 } else { 435 if (wrqu->frag.value < MIN_FRAG_THRESHOLD || 436 wrqu->frag.value > MAX_FRAG_THRESHOLD) 437 return -EINVAL; 438 439 priv->ieee80211->fts = wrqu->frag.value & ~0x1; 440 } 441 442 return 0; 443 } 444 445 static int r8192_wx_get_frag(struct net_device *dev, 446 struct iw_request_info *info, 447 union iwreq_data *wrqu, char *extra) 448 { 449 struct r8192_priv *priv = ieee80211_priv(dev); 450 451 wrqu->frag.value = priv->ieee80211->fts; 452 wrqu->frag.fixed = 0; /* no auto select */ 453 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FRAG_THRESHOLD); 454 455 return 0; 456 } 457 458 static int r8192_wx_set_wap(struct net_device *dev, 459 struct iw_request_info *info, 460 union iwreq_data *awrq, 461 char *extra) 462 { 463 int ret; 464 struct r8192_priv *priv = ieee80211_priv(dev); 465 /* struct sockaddr *temp = (struct sockaddr *)awrq; */ 466 mutex_lock(&priv->wx_mutex); 467 468 ret = ieee80211_wx_set_wap(priv->ieee80211, info, awrq, extra); 469 470 mutex_unlock(&priv->wx_mutex); 471 472 return ret; 473 } 474 475 static int r8192_wx_get_wap(struct net_device *dev, 476 struct iw_request_info *info, 477 union iwreq_data *wrqu, char *extra) 478 { 479 struct r8192_priv *priv = ieee80211_priv(dev); 480 481 return ieee80211_wx_get_wap(priv->ieee80211, info, wrqu, extra); 482 } 483 484 static int r8192_wx_get_enc(struct net_device *dev, 485 struct iw_request_info *info, 486 union iwreq_data *wrqu, char *key) 487 { 488 struct r8192_priv *priv = ieee80211_priv(dev); 489 490 return ieee80211_wx_get_encode(priv->ieee80211, info, wrqu, key); 491 } 492 493 static int r8192_wx_set_enc(struct net_device *dev, 494 struct iw_request_info *info, 495 union iwreq_data *wrqu, char *key) 496 { 497 struct r8192_priv *priv = ieee80211_priv(dev); 498 struct ieee80211_device *ieee = priv->ieee80211; 499 int ret; 500 u32 hwkey[4] = {0, 0, 0, 0}; 501 u8 mask = 0xff; 502 u32 key_idx = 0; 503 u8 zero_addr[4][6] = { {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 504 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 505 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02}, 506 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03} }; 507 int i; 508 509 if (!priv->up) 510 return -ENETDOWN; 511 512 mutex_lock(&priv->wx_mutex); 513 514 RT_TRACE(COMP_SEC, "Setting SW wep key"); 515 ret = ieee80211_wx_set_encode(priv->ieee80211, info, wrqu, key); 516 517 mutex_unlock(&priv->wx_mutex); 518 519 /* sometimes, the length is zero while we do not type key value */ 520 if (wrqu->encoding.length != 0) { 521 for (i = 0; i < 4; i++) { 522 hwkey[i] |= key[4 * i + 0] & mask; 523 if (i == 1 && (4 * i + 1) == wrqu->encoding.length) 524 mask = 0x00; 525 if (i == 3 && (4 * i + 1) == wrqu->encoding.length) 526 mask = 0x00; 527 hwkey[i] |= (key[4 * i + 1] & mask) << 8; 528 hwkey[i] |= (key[4 * i + 2] & mask) << 16; 529 hwkey[i] |= (key[4 * i + 3] & mask) << 24; 530 } 531 532 #define CONF_WEP40 0x4 533 #define CONF_WEP104 0x14 534 535 switch (wrqu->encoding.flags & IW_ENCODE_INDEX) { 536 case 0: 537 key_idx = ieee->tx_keyidx; 538 break; 539 case 1: 540 key_idx = 0; 541 break; 542 case 2: 543 key_idx = 1; 544 break; 545 case 3: 546 key_idx = 2; 547 break; 548 case 4: 549 key_idx = 3; 550 break; 551 default: 552 break; 553 } 554 555 if (wrqu->encoding.length == 0x5) { 556 ieee->pairwise_key_type = KEY_TYPE_WEP40; 557 EnableHWSecurityConfig8192(dev); 558 559 setKey(dev, 560 key_idx, /* EntryNo */ 561 key_idx, /* KeyIndex */ 562 KEY_TYPE_WEP40, /* KeyType */ 563 zero_addr[key_idx], 564 0, /* DefaultKey */ 565 hwkey); /* KeyContent */ 566 } else if (wrqu->encoding.length == 0xd) { 567 ieee->pairwise_key_type = KEY_TYPE_WEP104; 568 EnableHWSecurityConfig8192(dev); 569 570 setKey(dev, 571 key_idx, /* EntryNo */ 572 key_idx, /* KeyIndex */ 573 KEY_TYPE_WEP104, /* KeyType */ 574 zero_addr[key_idx], 575 0, /* DefaultKey */ 576 hwkey); /* KeyContent */ 577 } else { 578 netdev_warn(dev, "wrong type in WEP, not WEP40 and WEP104\n"); 579 } 580 } 581 582 return ret; 583 } 584 585 static int r8192_wx_set_scan_type(struct net_device *dev, struct iw_request_info *aa, 586 union iwreq_data *wrqu, char *p) 587 { 588 struct r8192_priv *priv = ieee80211_priv(dev); 589 int *parms = (int *)p; 590 int mode = parms[0]; 591 592 priv->ieee80211->active_scan = mode; 593 594 return 1; 595 } 596 597 static int r8192_wx_set_retry(struct net_device *dev, 598 struct iw_request_info *info, 599 union iwreq_data *wrqu, char *extra) 600 { 601 struct r8192_priv *priv = ieee80211_priv(dev); 602 int err = 0; 603 604 mutex_lock(&priv->wx_mutex); 605 606 if (wrqu->retry.flags & IW_RETRY_LIFETIME || 607 wrqu->retry.disabled){ 608 err = -EINVAL; 609 goto exit; 610 } 611 if (!(wrqu->retry.flags & IW_RETRY_LIMIT)) { 612 err = -EINVAL; 613 goto exit; 614 } 615 616 if (wrqu->retry.value > R8180_MAX_RETRY) { 617 err = -EINVAL; 618 goto exit; 619 } 620 if (wrqu->retry.flags & IW_RETRY_MAX) { 621 priv->retry_rts = wrqu->retry.value; 622 DMESG("Setting retry for RTS/CTS data to %d", wrqu->retry.value); 623 624 } else { 625 priv->retry_data = wrqu->retry.value; 626 DMESG("Setting retry for non RTS/CTS data to %d", wrqu->retry.value); 627 } 628 629 /* FIXME ! 630 * We might try to write directly the TX config register 631 * or to restart just the (R)TX process. 632 * I'm unsure if whole reset is really needed 633 */ 634 635 rtl8192_commit(dev); 636 exit: 637 mutex_unlock(&priv->wx_mutex); 638 639 return err; 640 } 641 642 static int r8192_wx_get_retry(struct net_device *dev, 643 struct iw_request_info *info, 644 union iwreq_data *wrqu, char *extra) 645 { 646 struct r8192_priv *priv = ieee80211_priv(dev); 647 648 wrqu->retry.disabled = 0; /* can't be disabled */ 649 650 if ((wrqu->retry.flags & IW_RETRY_TYPE) == 651 IW_RETRY_LIFETIME) 652 return -EINVAL; 653 654 if (wrqu->retry.flags & IW_RETRY_MAX) { 655 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX; 656 wrqu->retry.value = priv->retry_rts; 657 } else { 658 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN; 659 wrqu->retry.value = priv->retry_data; 660 } 661 662 return 0; 663 } 664 665 static int r8192_wx_get_sens(struct net_device *dev, 666 struct iw_request_info *info, 667 union iwreq_data *wrqu, char *extra) 668 { 669 struct r8192_priv *priv = ieee80211_priv(dev); 670 671 if (!priv->rf_set_sens) 672 return -1; /* we have not this support for this radio */ 673 wrqu->sens.value = priv->sens; 674 return 0; 675 } 676 677 static int r8192_wx_set_sens(struct net_device *dev, 678 struct iw_request_info *info, 679 union iwreq_data *wrqu, char *extra) 680 { 681 struct r8192_priv *priv = ieee80211_priv(dev); 682 short err = 0; 683 684 mutex_lock(&priv->wx_mutex); 685 if (!priv->rf_set_sens) { 686 err = -1; /* we have not this support for this radio */ 687 goto exit; 688 } 689 if (priv->rf_set_sens(dev, wrqu->sens.value) == 0) 690 priv->sens = wrqu->sens.value; 691 else 692 err = -EINVAL; 693 694 exit: 695 mutex_unlock(&priv->wx_mutex); 696 697 return err; 698 } 699 700 /* hw security need to reorganized. */ 701 static int r8192_wx_set_enc_ext(struct net_device *dev, 702 struct iw_request_info *info, 703 union iwreq_data *wrqu, char *extra) 704 { 705 int ret = 0; 706 struct r8192_priv *priv = ieee80211_priv(dev); 707 struct ieee80211_device *ieee = priv->ieee80211; 708 709 mutex_lock(&priv->wx_mutex); 710 ret = ieee80211_wx_set_encode_ext(priv->ieee80211, info, wrqu, extra); 711 712 { 713 u8 broadcast_addr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 714 u8 zero[6] = {0}; 715 u32 key[4] = {0}; 716 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra; 717 struct iw_point *encoding = &wrqu->encoding; 718 u8 idx = 0, alg = 0, group = 0; 719 720 if ((encoding->flags & IW_ENCODE_DISABLED) || ext->alg == IW_ENCODE_ALG_NONE) 721 /* none is not allowed to use hwsec WB 2008.07.01 */ 722 goto end_hw_sec; 723 724 /* as IW_ENCODE_ALG_CCMP is defined to be 3 and KEY_TYPE_CCMP is defined to 4; */ 725 alg = (ext->alg == IW_ENCODE_ALG_CCMP) ? KEY_TYPE_CCMP : ext->alg; 726 idx = encoding->flags & IW_ENCODE_INDEX; 727 if (idx) 728 idx--; 729 group = ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY; 730 731 if ((!group) || (ieee->iw_mode == IW_MODE_ADHOC) || (alg == KEY_TYPE_WEP40)) { 732 if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40)) 733 alg = KEY_TYPE_WEP104; 734 ieee->pairwise_key_type = alg; 735 EnableHWSecurityConfig8192(dev); 736 } 737 memcpy((u8 *)key, ext->key, 16); /* we only get 16 bytes key.why? WB 2008.7.1 */ 738 739 if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) { 740 setKey(dev, 741 idx, /* EntryNao */ 742 idx, /* KeyIndex */ 743 alg, /* KeyType */ 744 zero, /* MacAddr */ 745 0, /* DefaultKey */ 746 key); /* KeyContent */ 747 } else if (group) { 748 ieee->group_key_type = alg; 749 setKey(dev, 750 idx, /* EntryNo */ 751 idx, /* KeyIndex */ 752 alg, /* KeyType */ 753 broadcast_addr, /* MacAddr */ 754 0, /* DefaultKey */ 755 key); /* KeyContent */ 756 } else { /* pairwise key */ 757 setKey(dev, 758 4, /* EntryNo */ 759 idx, /* KeyIndex */ 760 alg, /* KeyType */ 761 (u8 *)ieee->ap_mac_addr,/* MacAddr */ 762 0, /* DefaultKey */ 763 key); /* KeyContent */ 764 } 765 } 766 767 end_hw_sec: 768 769 mutex_unlock(&priv->wx_mutex); 770 return ret; 771 } 772 773 static int r8192_wx_set_auth(struct net_device *dev, 774 struct iw_request_info *info, 775 union iwreq_data *data, char *extra) 776 { 777 int ret = 0; 778 struct r8192_priv *priv = ieee80211_priv(dev); 779 780 mutex_lock(&priv->wx_mutex); 781 ret = ieee80211_wx_set_auth(priv->ieee80211, info, &data->param, extra); 782 mutex_unlock(&priv->wx_mutex); 783 return ret; 784 } 785 786 static int r8192_wx_set_mlme(struct net_device *dev, 787 struct iw_request_info *info, 788 union iwreq_data *wrqu, char *extra) 789 { 790 int ret = 0; 791 struct r8192_priv *priv = ieee80211_priv(dev); 792 793 mutex_lock(&priv->wx_mutex); 794 ret = ieee80211_wx_set_mlme(priv->ieee80211, info, wrqu, extra); 795 796 mutex_unlock(&priv->wx_mutex); 797 return ret; 798 } 799 800 static int r8192_wx_set_gen_ie(struct net_device *dev, 801 struct iw_request_info *info, 802 union iwreq_data *data, char *extra) 803 { 804 int ret = 0; 805 struct r8192_priv *priv = ieee80211_priv(dev); 806 807 mutex_lock(&priv->wx_mutex); 808 ret = ieee80211_wx_set_gen_ie(priv->ieee80211, extra, data->data.length); 809 mutex_unlock(&priv->wx_mutex); 810 return ret; 811 } 812 813 static int dummy(struct net_device *dev, struct iw_request_info *a, 814 union iwreq_data *wrqu, char *b) 815 { 816 return -1; 817 } 818 819 static iw_handler r8192_wx_handlers[] = { 820 NULL, /* SIOCSIWCOMMIT */ 821 r8192_wx_get_name, /* SIOCGIWNAME */ 822 dummy, /* SIOCSIWNWID */ 823 dummy, /* SIOCGIWNWID */ 824 r8192_wx_set_freq, /* SIOCSIWFREQ */ 825 r8192_wx_get_freq, /* SIOCGIWFREQ */ 826 r8192_wx_set_mode, /* SIOCSIWMODE */ 827 r8192_wx_get_mode, /* SIOCGIWMODE */ 828 r8192_wx_set_sens, /* SIOCSIWSENS */ 829 r8192_wx_get_sens, /* SIOCGIWSENS */ 830 NULL, /* SIOCSIWRANGE */ 831 rtl8180_wx_get_range, /* SIOCGIWRANGE */ 832 NULL, /* SIOCSIWPRIV */ 833 NULL, /* SIOCGIWPRIV */ 834 NULL, /* SIOCSIWSTATS */ 835 NULL, /* SIOCGIWSTATS */ 836 dummy, /* SIOCSIWSPY */ 837 dummy, /* SIOCGIWSPY */ 838 NULL, /* SIOCGIWTHRSPY */ 839 NULL, /* SIOCWIWTHRSPY */ 840 r8192_wx_set_wap, /* SIOCSIWAP */ 841 r8192_wx_get_wap, /* SIOCGIWAP */ 842 r8192_wx_set_mlme, /* MLME-- */ 843 dummy, /* SIOCGIWAPLIST -- deprecated */ 844 r8192_wx_set_scan, /* SIOCSIWSCAN */ 845 r8192_wx_get_scan, /* SIOCGIWSCAN */ 846 r8192_wx_set_essid, /* SIOCSIWESSID */ 847 r8192_wx_get_essid, /* SIOCGIWESSID */ 848 dummy, /* SIOCSIWNICKN */ 849 dummy, /* SIOCGIWNICKN */ 850 NULL, /* -- hole -- */ 851 NULL, /* -- hole -- */ 852 r8192_wx_set_rate, /* SIOCSIWRATE */ 853 r8192_wx_get_rate, /* SIOCGIWRATE */ 854 r8192_wx_set_rts, /* SIOCSIWRTS */ 855 r8192_wx_get_rts, /* SIOCGIWRTS */ 856 r8192_wx_set_frag, /* SIOCSIWFRAG */ 857 r8192_wx_get_frag, /* SIOCGIWFRAG */ 858 dummy, /* SIOCSIWTXPOW */ 859 dummy, /* SIOCGIWTXPOW */ 860 r8192_wx_set_retry, /* SIOCSIWRETRY */ 861 r8192_wx_get_retry, /* SIOCGIWRETRY */ 862 r8192_wx_set_enc, /* SIOCSIWENCODE */ 863 r8192_wx_get_enc, /* SIOCGIWENCODE */ 864 r8192_wx_set_power, /* SIOCSIWPOWER */ 865 r8192_wx_get_power, /* SIOCGIWPOWER */ 866 NULL, /*---hole---*/ 867 NULL, /*---hole---*/ 868 r8192_wx_set_gen_ie, /* NULL, */ /* SIOCSIWGENIE */ 869 NULL, /* SIOCSIWGENIE */ 870 871 r8192_wx_set_auth,/* NULL, */ /* SIOCSIWAUTH */ 872 NULL,/* r8192_wx_get_auth, */ /* NULL, */ /* SIOCSIWAUTH */ 873 r8192_wx_set_enc_ext, /* SIOCSIWENCODEEXT */ 874 NULL,/* r8192_wx_get_enc_ext, *//* NULL, */ /* SIOCSIWENCODEEXT */ 875 NULL, /* SIOCSIWPMKSA */ 876 NULL, /*---hole---*/ 877 878 }; 879 880 static const struct iw_priv_args r8192_private_args[] = { 881 { 882 SIOCIWFIRSTPRIV + 0x0, 883 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "badcrc" 884 }, 885 { 886 SIOCIWFIRSTPRIV + 0x1, 887 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "activescan" 888 889 }, 890 { 891 SIOCIWFIRSTPRIV + 0x2, 892 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "rawtx" 893 }, 894 { 895 SIOCIWFIRSTPRIV + 0x3, 896 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "forcereset" 897 } 898 }; 899 900 static iw_handler r8192_private_handler[] = { 901 r8192_wx_set_crcmon, 902 r8192_wx_set_scan_type, 903 r8192_wx_set_rawtx, 904 r8192_wx_force_reset, 905 }; 906 907 struct iw_statistics *r8192_get_wireless_stats(struct net_device *dev) 908 { 909 struct r8192_priv *priv = ieee80211_priv(dev); 910 struct ieee80211_device *ieee = priv->ieee80211; 911 struct iw_statistics *wstats = &priv->wstats; 912 int tmp_level = 0; 913 int tmp_qual = 0; 914 int tmp_noise = 0; 915 916 if (ieee->state < IEEE80211_LINKED) { 917 wstats->qual.qual = 0; 918 wstats->qual.level = 0; 919 wstats->qual.noise = 0; 920 wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM; 921 return wstats; 922 } 923 924 tmp_level = (&ieee->current_network)->stats.rssi; 925 tmp_qual = (&ieee->current_network)->stats.signal; 926 tmp_noise = (&ieee->current_network)->stats.noise; 927 928 wstats->qual.level = tmp_level; 929 wstats->qual.qual = tmp_qual; 930 wstats->qual.noise = tmp_noise; 931 wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM; 932 return wstats; 933 } 934 935 const struct iw_handler_def r8192_wx_handlers_def = { 936 .standard = r8192_wx_handlers, 937 .num_standard = ARRAY_SIZE(r8192_wx_handlers), 938 .private = r8192_private_handler, 939 .num_private = ARRAY_SIZE(r8192_private_handler), 940 .num_private_args = sizeof(r8192_private_args) / sizeof(struct iw_priv_args), 941 .get_wireless_stats = r8192_get_wireless_stats, 942 .private_args = (struct iw_priv_args *)r8192_private_args, 943 }; 944