1 // SPDX-License-Identifier: GPL-2.0 2 /* IEEE 802.11 SoftMAC layer 3 * Copyright (c) 2005 Andrea Merello <andrea.merello@gmail.com> 4 * 5 * Mostly extracted from the rtl8180-sa2400 driver for the 6 * in-kernel generic ieee802.11 stack. 7 * 8 * Few lines might be stolen from other part of the rtllib 9 * stack. Copyright who own it's copyright 10 * 11 * WPA code stolen from the ipw2200 driver. 12 * Copyright who own it's copyright. 13 */ 14 #include "rtllib.h" 15 16 #include <linux/random.h> 17 #include <linux/delay.h> 18 #include <linux/uaccess.h> 19 #include <linux/etherdevice.h> 20 #include <linux/ieee80211.h> 21 #include "dot11d.h" 22 23 static void rtllib_sta_wakeup(struct rtllib_device *ieee, short nl); 24 25 26 static short rtllib_is_54g(struct rtllib_network *net) 27 { 28 return (net->rates_ex_len > 0) || (net->rates_len > 4); 29 } 30 31 /* returns the total length needed for placing the RATE MFIE 32 * tag and the EXTENDED RATE MFIE tag if needed. 33 * It encludes two bytes per tag for the tag itself and its len 34 */ 35 static unsigned int rtllib_MFIE_rate_len(struct rtllib_device *ieee) 36 { 37 unsigned int rate_len = 0; 38 39 if (ieee->modulation & RTLLIB_CCK_MODULATION) 40 rate_len = RTLLIB_CCK_RATE_LEN + 2; 41 42 if (ieee->modulation & RTLLIB_OFDM_MODULATION) 43 44 rate_len += RTLLIB_OFDM_RATE_LEN + 2; 45 46 return rate_len; 47 } 48 49 /* place the MFIE rate, tag to the memory (double) pointed. 50 * Then it updates the pointer so that 51 * it points after the new MFIE tag added. 52 */ 53 static void rtllib_MFIE_Brate(struct rtllib_device *ieee, u8 **tag_p) 54 { 55 u8 *tag = *tag_p; 56 57 if (ieee->modulation & RTLLIB_CCK_MODULATION) { 58 *tag++ = MFIE_TYPE_RATES; 59 *tag++ = 4; 60 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_1MB; 61 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_2MB; 62 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_5MB; 63 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_11MB; 64 } 65 66 /* We may add an option for custom rates that specific HW 67 * might support 68 */ 69 *tag_p = tag; 70 } 71 72 static void rtllib_MFIE_Grate(struct rtllib_device *ieee, u8 **tag_p) 73 { 74 u8 *tag = *tag_p; 75 76 if (ieee->modulation & RTLLIB_OFDM_MODULATION) { 77 *tag++ = MFIE_TYPE_RATES_EX; 78 *tag++ = 8; 79 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_6MB; 80 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_9MB; 81 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_12MB; 82 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_18MB; 83 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_24MB; 84 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_36MB; 85 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_48MB; 86 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_54MB; 87 } 88 /* We may add an option for custom rates that specific HW might 89 * support 90 */ 91 *tag_p = tag; 92 } 93 94 static void rtllib_WMM_Info(struct rtllib_device *ieee, u8 **tag_p) 95 { 96 u8 *tag = *tag_p; 97 98 *tag++ = MFIE_TYPE_GENERIC; 99 *tag++ = 7; 100 *tag++ = 0x00; 101 *tag++ = 0x50; 102 *tag++ = 0xf2; 103 *tag++ = 0x02; 104 *tag++ = 0x00; 105 *tag++ = 0x01; 106 *tag++ = MAX_SP_Len; 107 *tag_p = tag; 108 } 109 110 static void rtllib_TURBO_Info(struct rtllib_device *ieee, u8 **tag_p) 111 { 112 u8 *tag = *tag_p; 113 114 *tag++ = MFIE_TYPE_GENERIC; 115 *tag++ = 7; 116 *tag++ = 0x00; 117 *tag++ = 0xe0; 118 *tag++ = 0x4c; 119 *tag++ = 0x01; 120 *tag++ = 0x02; 121 *tag++ = 0x11; 122 *tag++ = 0x00; 123 124 *tag_p = tag; 125 netdev_alert(ieee->dev, "This is enable turbo mode IE process\n"); 126 } 127 128 static void enqueue_mgmt(struct rtllib_device *ieee, struct sk_buff *skb) 129 { 130 int nh; 131 132 nh = (ieee->mgmt_queue_head + 1) % MGMT_QUEUE_NUM; 133 134 /* if the queue is full but we have newer frames then 135 * just overwrites the oldest. 136 * 137 * if (nh == ieee->mgmt_queue_tail) 138 * return -1; 139 */ 140 ieee->mgmt_queue_head = nh; 141 ieee->mgmt_queue_ring[nh] = skb; 142 143 } 144 145 static void init_mgmt_queue(struct rtllib_device *ieee) 146 { 147 ieee->mgmt_queue_tail = ieee->mgmt_queue_head = 0; 148 } 149 150 151 u8 152 MgntQuery_TxRateExcludeCCKRates(struct rtllib_device *ieee) 153 { 154 u16 i; 155 u8 QueryRate = 0; 156 u8 BasicRate; 157 158 159 for (i = 0; i < ieee->current_network.rates_len; i++) { 160 BasicRate = ieee->current_network.rates[i]&0x7F; 161 if (!rtllib_is_cck_rate(BasicRate)) { 162 if (QueryRate == 0) { 163 QueryRate = BasicRate; 164 } else { 165 if (BasicRate < QueryRate) 166 QueryRate = BasicRate; 167 } 168 } 169 } 170 171 if (QueryRate == 0) { 172 QueryRate = 12; 173 netdev_info(ieee->dev, "No BasicRate found!!\n"); 174 } 175 return QueryRate; 176 } 177 178 static u8 MgntQuery_MgntFrameTxRate(struct rtllib_device *ieee) 179 { 180 struct rt_hi_throughput *pHTInfo = ieee->pHTInfo; 181 u8 rate; 182 183 if (pHTInfo->IOTAction & HT_IOT_ACT_MGNT_USE_CCK_6M) 184 rate = 0x0c; 185 else 186 rate = ieee->basic_rate & 0x7f; 187 188 if (rate == 0) { 189 if (ieee->mode == IEEE_A || 190 ieee->mode == IEEE_N_5G || 191 (ieee->mode == IEEE_N_24G && !pHTInfo->bCurSuppCCK)) 192 rate = 0x0c; 193 else 194 rate = 0x02; 195 } 196 197 return rate; 198 } 199 200 inline void softmac_mgmt_xmit(struct sk_buff *skb, struct rtllib_device *ieee) 201 { 202 unsigned long flags; 203 short single = ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE; 204 struct rtllib_hdr_3addr *header = 205 (struct rtllib_hdr_3addr *) skb->data; 206 207 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb + 8); 208 209 spin_lock_irqsave(&ieee->lock, flags); 210 211 /* called with 2nd param 0, no mgmt lock required */ 212 rtllib_sta_wakeup(ieee, 0); 213 214 if (le16_to_cpu(header->frame_ctl) == RTLLIB_STYPE_BEACON) 215 tcb_desc->queue_index = BEACON_QUEUE; 216 else 217 tcb_desc->queue_index = MGNT_QUEUE; 218 219 if (ieee->disable_mgnt_queue) 220 tcb_desc->queue_index = HIGH_QUEUE; 221 222 tcb_desc->data_rate = MgntQuery_MgntFrameTxRate(ieee); 223 tcb_desc->RATRIndex = 7; 224 tcb_desc->bTxDisableRateFallBack = 1; 225 tcb_desc->bTxUseDriverAssingedRate = 1; 226 if (single) { 227 if (ieee->queue_stop) { 228 enqueue_mgmt(ieee, skb); 229 } else { 230 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0]<<4); 231 232 if (ieee->seq_ctrl[0] == 0xFFF) 233 ieee->seq_ctrl[0] = 0; 234 else 235 ieee->seq_ctrl[0]++; 236 237 /* avoid watchdog triggers */ 238 ieee->softmac_data_hard_start_xmit(skb, ieee->dev, 239 ieee->basic_rate); 240 } 241 242 spin_unlock_irqrestore(&ieee->lock, flags); 243 } else { 244 spin_unlock_irqrestore(&ieee->lock, flags); 245 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags); 246 247 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4); 248 249 if (ieee->seq_ctrl[0] == 0xFFF) 250 ieee->seq_ctrl[0] = 0; 251 else 252 ieee->seq_ctrl[0]++; 253 254 /* check whether the managed packet queued greater than 5 */ 255 if (!ieee->check_nic_enough_desc(ieee->dev, 256 tcb_desc->queue_index) || 257 skb_queue_len(&ieee->skb_waitQ[tcb_desc->queue_index]) || 258 ieee->queue_stop) { 259 /* insert the skb packet to the management queue 260 * 261 * as for the completion function, it does not need 262 * to check it any more. 263 */ 264 netdev_info(ieee->dev, 265 "%s():insert to waitqueue, queue_index:%d!\n", 266 __func__, tcb_desc->queue_index); 267 skb_queue_tail(&ieee->skb_waitQ[tcb_desc->queue_index], 268 skb); 269 } else { 270 ieee->softmac_hard_start_xmit(skb, ieee->dev); 271 } 272 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags); 273 } 274 } 275 276 static inline void 277 softmac_ps_mgmt_xmit(struct sk_buff *skb, 278 struct rtllib_device *ieee) 279 { 280 short single = ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE; 281 struct rtllib_hdr_3addr *header = 282 (struct rtllib_hdr_3addr *) skb->data; 283 u16 fc, type, stype; 284 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb + 8); 285 286 fc = le16_to_cpu(header->frame_ctl); 287 type = WLAN_FC_GET_TYPE(fc); 288 stype = WLAN_FC_GET_STYPE(fc); 289 290 291 if (stype != RTLLIB_STYPE_PSPOLL) 292 tcb_desc->queue_index = MGNT_QUEUE; 293 else 294 tcb_desc->queue_index = HIGH_QUEUE; 295 296 if (ieee->disable_mgnt_queue) 297 tcb_desc->queue_index = HIGH_QUEUE; 298 299 300 tcb_desc->data_rate = MgntQuery_MgntFrameTxRate(ieee); 301 tcb_desc->RATRIndex = 7; 302 tcb_desc->bTxDisableRateFallBack = 1; 303 tcb_desc->bTxUseDriverAssingedRate = 1; 304 if (single) { 305 if (type != RTLLIB_FTYPE_CTL) { 306 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4); 307 308 if (ieee->seq_ctrl[0] == 0xFFF) 309 ieee->seq_ctrl[0] = 0; 310 else 311 ieee->seq_ctrl[0]++; 312 313 } 314 /* avoid watchdog triggers */ 315 ieee->softmac_data_hard_start_xmit(skb, ieee->dev, 316 ieee->basic_rate); 317 318 } else { 319 if (type != RTLLIB_FTYPE_CTL) { 320 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4); 321 322 if (ieee->seq_ctrl[0] == 0xFFF) 323 ieee->seq_ctrl[0] = 0; 324 else 325 ieee->seq_ctrl[0]++; 326 } 327 ieee->softmac_hard_start_xmit(skb, ieee->dev); 328 329 } 330 } 331 332 static inline struct sk_buff *rtllib_probe_req(struct rtllib_device *ieee) 333 { 334 unsigned int len, rate_len; 335 u8 *tag; 336 struct sk_buff *skb; 337 struct rtllib_probe_request *req; 338 339 len = ieee->current_network.ssid_len; 340 341 rate_len = rtllib_MFIE_rate_len(ieee); 342 343 skb = dev_alloc_skb(sizeof(struct rtllib_probe_request) + 344 2 + len + rate_len + ieee->tx_headroom); 345 346 if (!skb) 347 return NULL; 348 349 skb_reserve(skb, ieee->tx_headroom); 350 351 req = skb_put(skb, sizeof(struct rtllib_probe_request)); 352 req->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_PROBE_REQ); 353 req->header.duration_id = 0; 354 355 eth_broadcast_addr(req->header.addr1); 356 ether_addr_copy(req->header.addr2, ieee->dev->dev_addr); 357 eth_broadcast_addr(req->header.addr3); 358 359 tag = skb_put(skb, len + 2 + rate_len); 360 361 *tag++ = MFIE_TYPE_SSID; 362 *tag++ = len; 363 memcpy(tag, ieee->current_network.ssid, len); 364 tag += len; 365 366 rtllib_MFIE_Brate(ieee, &tag); 367 rtllib_MFIE_Grate(ieee, &tag); 368 369 return skb; 370 } 371 372 static struct sk_buff *rtllib_get_beacon_(struct rtllib_device *ieee); 373 374 static void rtllib_send_beacon(struct rtllib_device *ieee) 375 { 376 struct sk_buff *skb; 377 378 if (!ieee->ieee_up) 379 return; 380 skb = rtllib_get_beacon_(ieee); 381 382 if (skb) { 383 softmac_mgmt_xmit(skb, ieee); 384 ieee->softmac_stats.tx_beacons++; 385 } 386 387 if (ieee->beacon_txing && ieee->ieee_up) 388 mod_timer(&ieee->beacon_timer, jiffies + 389 (msecs_to_jiffies(ieee->current_network.beacon_interval - 5))); 390 } 391 392 393 static void rtllib_send_beacon_cb(struct timer_list *t) 394 { 395 struct rtllib_device *ieee = 396 from_timer(ieee, t, beacon_timer); 397 unsigned long flags; 398 399 spin_lock_irqsave(&ieee->beacon_lock, flags); 400 rtllib_send_beacon(ieee); 401 spin_unlock_irqrestore(&ieee->beacon_lock, flags); 402 } 403 404 /* Enables network monitor mode, all rx packets will be received. */ 405 void rtllib_EnableNetMonitorMode(struct net_device *dev, 406 bool bInitState) 407 { 408 struct rtllib_device *ieee = netdev_priv_rsl(dev); 409 410 netdev_info(dev, "========>Enter Monitor Mode\n"); 411 412 ieee->AllowAllDestAddrHandler(dev, true, !bInitState); 413 } 414 415 416 /* Disables network monitor mode. Only packets destinated to 417 * us will be received. 418 */ 419 void rtllib_DisableNetMonitorMode(struct net_device *dev, 420 bool bInitState) 421 { 422 struct rtllib_device *ieee = netdev_priv_rsl(dev); 423 424 netdev_info(dev, "========>Exit Monitor Mode\n"); 425 426 ieee->AllowAllDestAddrHandler(dev, false, !bInitState); 427 } 428 429 430 /* Enables the specialized promiscuous mode required by Intel. 431 * In this mode, Intel intends to hear traffics from/to other STAs in the 432 * same BSS. Therefore we don't have to disable checking BSSID and we only need 433 * to allow all dest. BUT: if we enable checking BSSID then we can't recv 434 * packets from other STA. 435 */ 436 void rtllib_EnableIntelPromiscuousMode(struct net_device *dev, 437 bool bInitState) 438 { 439 bool bFilterOutNonAssociatedBSSID = false; 440 441 struct rtllib_device *ieee = netdev_priv_rsl(dev); 442 443 netdev_info(dev, "========>Enter Intel Promiscuous Mode\n"); 444 445 ieee->AllowAllDestAddrHandler(dev, true, !bInitState); 446 ieee->SetHwRegHandler(dev, HW_VAR_CECHK_BSSID, 447 (u8 *)&bFilterOutNonAssociatedBSSID); 448 449 ieee->bNetPromiscuousMode = true; 450 } 451 EXPORT_SYMBOL(rtllib_EnableIntelPromiscuousMode); 452 453 454 /* Disables the specialized promiscuous mode required by Intel. 455 * See MgntEnableIntelPromiscuousMode for detail. 456 */ 457 void rtllib_DisableIntelPromiscuousMode(struct net_device *dev, 458 bool bInitState) 459 { 460 bool bFilterOutNonAssociatedBSSID = true; 461 462 struct rtllib_device *ieee = netdev_priv_rsl(dev); 463 464 netdev_info(dev, "========>Exit Intel Promiscuous Mode\n"); 465 466 ieee->AllowAllDestAddrHandler(dev, false, !bInitState); 467 ieee->SetHwRegHandler(dev, HW_VAR_CECHK_BSSID, 468 (u8 *)&bFilterOutNonAssociatedBSSID); 469 470 ieee->bNetPromiscuousMode = false; 471 } 472 EXPORT_SYMBOL(rtllib_DisableIntelPromiscuousMode); 473 474 static void rtllib_send_probe(struct rtllib_device *ieee, u8 is_mesh) 475 { 476 struct sk_buff *skb; 477 478 skb = rtllib_probe_req(ieee); 479 if (skb) { 480 softmac_mgmt_xmit(skb, ieee); 481 ieee->softmac_stats.tx_probe_rq++; 482 } 483 } 484 485 486 static void rtllib_send_probe_requests(struct rtllib_device *ieee, u8 is_mesh) 487 { 488 if (ieee->active_scan && (ieee->softmac_features & 489 IEEE_SOFTMAC_PROBERQ)) { 490 rtllib_send_probe(ieee, 0); 491 rtllib_send_probe(ieee, 0); 492 } 493 } 494 495 static void rtllib_update_active_chan_map(struct rtllib_device *ieee) 496 { 497 memcpy(ieee->active_channel_map, GET_DOT11D_INFO(ieee)->channel_map, 498 MAX_CHANNEL_NUMBER+1); 499 } 500 501 /* this performs syncro scan blocking the caller until all channels 502 * in the allowed channel map has been checked. 503 */ 504 static void rtllib_softmac_scan_syncro(struct rtllib_device *ieee, u8 is_mesh) 505 { 506 union iwreq_data wrqu; 507 short ch = 0; 508 509 rtllib_update_active_chan_map(ieee); 510 511 ieee->be_scan_inprogress = true; 512 513 mutex_lock(&ieee->scan_mutex); 514 515 while (1) { 516 do { 517 ch++; 518 if (ch > MAX_CHANNEL_NUMBER) 519 goto out; /* scan completed */ 520 } while (!ieee->active_channel_map[ch]); 521 522 /* this function can be called in two situations 523 * 1- We have switched to ad-hoc mode and we are 524 * performing a complete syncro scan before conclude 525 * there are no interesting cell and to create a 526 * new one. In this case the link state is 527 * RTLLIB_NOLINK until we found an interesting cell. 528 * If so the ieee8021_new_net, called by the RX path 529 * will set the state to RTLLIB_LINKED, so we stop 530 * scanning 531 * 2- We are linked and the root uses run iwlist scan. 532 * So we switch to RTLLIB_LINKED_SCANNING to remember 533 * that we are still logically linked (not interested in 534 * new network events, despite for updating the net list, 535 * but we are temporarly 'unlinked' as the driver shall 536 * not filter RX frames and the channel is changing. 537 * So the only situation in which are interested is to check 538 * if the state become LINKED because of the #1 situation 539 */ 540 541 if (ieee->state == RTLLIB_LINKED) 542 goto out; 543 if (ieee->sync_scan_hurryup) { 544 netdev_info(ieee->dev, 545 "============>sync_scan_hurryup out\n"); 546 goto out; 547 } 548 549 ieee->set_chan(ieee->dev, ch); 550 if (ieee->active_channel_map[ch] == 1) 551 rtllib_send_probe_requests(ieee, 0); 552 553 /* this prevent excessive time wait when we 554 * need to wait for a syncro scan to end.. 555 */ 556 msleep_interruptible_rsl(RTLLIB_SOFTMAC_SCAN_TIME); 557 } 558 out: 559 ieee->actscanning = false; 560 ieee->sync_scan_hurryup = 0; 561 562 if (ieee->state >= RTLLIB_LINKED) { 563 if (IS_DOT11D_ENABLE(ieee)) 564 dot11d_scan_complete(ieee); 565 } 566 mutex_unlock(&ieee->scan_mutex); 567 568 ieee->be_scan_inprogress = false; 569 570 memset(&wrqu, 0, sizeof(wrqu)); 571 wireless_send_event(ieee->dev, SIOCGIWSCAN, &wrqu, NULL); 572 } 573 574 static void rtllib_softmac_scan_wq(void *data) 575 { 576 struct rtllib_device *ieee = container_of_dwork_rsl(data, 577 struct rtllib_device, softmac_scan_wq); 578 u8 last_channel = ieee->current_network.channel; 579 580 rtllib_update_active_chan_map(ieee); 581 582 if (!ieee->ieee_up) 583 return; 584 if (rtllib_act_scanning(ieee, true)) 585 return; 586 587 mutex_lock(&ieee->scan_mutex); 588 589 if (ieee->eRFPowerState == eRfOff) { 590 netdev_info(ieee->dev, 591 "======>%s():rf state is eRfOff, return\n", 592 __func__); 593 goto out1; 594 } 595 596 do { 597 ieee->current_network.channel = 598 (ieee->current_network.channel + 1) % 599 MAX_CHANNEL_NUMBER; 600 if (ieee->scan_watch_dog++ > MAX_CHANNEL_NUMBER) { 601 if (!ieee->active_channel_map[ieee->current_network.channel]) 602 ieee->current_network.channel = 6; 603 goto out; /* no good chans */ 604 } 605 } while (!ieee->active_channel_map[ieee->current_network.channel]); 606 607 if (ieee->scanning_continue == 0) 608 goto out; 609 610 ieee->set_chan(ieee->dev, ieee->current_network.channel); 611 612 if (ieee->active_channel_map[ieee->current_network.channel] == 1) 613 rtllib_send_probe_requests(ieee, 0); 614 615 schedule_delayed_work(&ieee->softmac_scan_wq, 616 msecs_to_jiffies(RTLLIB_SOFTMAC_SCAN_TIME)); 617 618 mutex_unlock(&ieee->scan_mutex); 619 return; 620 621 out: 622 if (IS_DOT11D_ENABLE(ieee)) 623 dot11d_scan_complete(ieee); 624 ieee->current_network.channel = last_channel; 625 626 out1: 627 ieee->actscanning = false; 628 ieee->scan_watch_dog = 0; 629 ieee->scanning_continue = 0; 630 mutex_unlock(&ieee->scan_mutex); 631 } 632 633 634 635 static void rtllib_beacons_start(struct rtllib_device *ieee) 636 { 637 unsigned long flags; 638 639 spin_lock_irqsave(&ieee->beacon_lock, flags); 640 641 ieee->beacon_txing = 1; 642 rtllib_send_beacon(ieee); 643 644 spin_unlock_irqrestore(&ieee->beacon_lock, flags); 645 } 646 647 static void rtllib_beacons_stop(struct rtllib_device *ieee) 648 { 649 unsigned long flags; 650 651 spin_lock_irqsave(&ieee->beacon_lock, flags); 652 653 ieee->beacon_txing = 0; 654 del_timer_sync(&ieee->beacon_timer); 655 656 spin_unlock_irqrestore(&ieee->beacon_lock, flags); 657 658 } 659 660 661 void rtllib_stop_send_beacons(struct rtllib_device *ieee) 662 { 663 if (ieee->stop_send_beacons) 664 ieee->stop_send_beacons(ieee->dev); 665 if (ieee->softmac_features & IEEE_SOFTMAC_BEACONS) 666 rtllib_beacons_stop(ieee); 667 } 668 EXPORT_SYMBOL(rtllib_stop_send_beacons); 669 670 671 void rtllib_start_send_beacons(struct rtllib_device *ieee) 672 { 673 if (ieee->start_send_beacons) 674 ieee->start_send_beacons(ieee->dev); 675 if (ieee->softmac_features & IEEE_SOFTMAC_BEACONS) 676 rtllib_beacons_start(ieee); 677 } 678 EXPORT_SYMBOL(rtllib_start_send_beacons); 679 680 681 static void rtllib_softmac_stop_scan(struct rtllib_device *ieee) 682 { 683 mutex_lock(&ieee->scan_mutex); 684 ieee->scan_watch_dog = 0; 685 if (ieee->scanning_continue == 1) { 686 ieee->scanning_continue = 0; 687 ieee->actscanning = false; 688 689 cancel_delayed_work_sync(&ieee->softmac_scan_wq); 690 } 691 692 mutex_unlock(&ieee->scan_mutex); 693 } 694 695 void rtllib_stop_scan(struct rtllib_device *ieee) 696 { 697 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN) { 698 rtllib_softmac_stop_scan(ieee); 699 } else { 700 if (ieee->rtllib_stop_hw_scan) 701 ieee->rtllib_stop_hw_scan(ieee->dev); 702 } 703 } 704 EXPORT_SYMBOL(rtllib_stop_scan); 705 706 void rtllib_stop_scan_syncro(struct rtllib_device *ieee) 707 { 708 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN) { 709 ieee->sync_scan_hurryup = 1; 710 } else { 711 if (ieee->rtllib_stop_hw_scan) 712 ieee->rtllib_stop_hw_scan(ieee->dev); 713 } 714 } 715 EXPORT_SYMBOL(rtllib_stop_scan_syncro); 716 717 bool rtllib_act_scanning(struct rtllib_device *ieee, bool sync_scan) 718 { 719 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN) { 720 if (sync_scan) 721 return ieee->be_scan_inprogress; 722 else 723 return ieee->actscanning || ieee->be_scan_inprogress; 724 } else { 725 return test_bit(STATUS_SCANNING, &ieee->status); 726 } 727 } 728 EXPORT_SYMBOL(rtllib_act_scanning); 729 730 /* called with ieee->lock held */ 731 static void rtllib_start_scan(struct rtllib_device *ieee) 732 { 733 RT_TRACE(COMP_DBG, "===>%s()\n", __func__); 734 if (ieee->rtllib_ips_leave_wq != NULL) 735 ieee->rtllib_ips_leave_wq(ieee->dev); 736 737 if (IS_DOT11D_ENABLE(ieee)) { 738 if (IS_COUNTRY_IE_VALID(ieee)) 739 RESET_CIE_WATCHDOG(ieee); 740 } 741 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN) { 742 if (ieee->scanning_continue == 0) { 743 ieee->actscanning = true; 744 ieee->scanning_continue = 1; 745 schedule_delayed_work(&ieee->softmac_scan_wq, 0); 746 } 747 } else { 748 if (ieee->rtllib_start_hw_scan) 749 ieee->rtllib_start_hw_scan(ieee->dev); 750 } 751 } 752 753 /* called with wx_mutex held */ 754 void rtllib_start_scan_syncro(struct rtllib_device *ieee, u8 is_mesh) 755 { 756 if (IS_DOT11D_ENABLE(ieee)) { 757 if (IS_COUNTRY_IE_VALID(ieee)) 758 RESET_CIE_WATCHDOG(ieee); 759 } 760 ieee->sync_scan_hurryup = 0; 761 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN) { 762 rtllib_softmac_scan_syncro(ieee, is_mesh); 763 } else { 764 if (ieee->rtllib_start_hw_scan) 765 ieee->rtllib_start_hw_scan(ieee->dev); 766 } 767 } 768 EXPORT_SYMBOL(rtllib_start_scan_syncro); 769 770 static inline struct sk_buff * 771 rtllib_authentication_req(struct rtllib_network *beacon, 772 struct rtllib_device *ieee, 773 int challengelen, u8 *daddr) 774 { 775 struct sk_buff *skb; 776 struct rtllib_authentication *auth; 777 int len; 778 779 len = sizeof(struct rtllib_authentication) + challengelen + 780 ieee->tx_headroom + 4; 781 skb = dev_alloc_skb(len); 782 783 if (!skb) 784 return NULL; 785 786 skb_reserve(skb, ieee->tx_headroom); 787 788 auth = skb_put(skb, sizeof(struct rtllib_authentication)); 789 790 auth->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_AUTH); 791 if (challengelen) 792 auth->header.frame_ctl |= cpu_to_le16(RTLLIB_FCTL_WEP); 793 794 auth->header.duration_id = cpu_to_le16(0x013a); 795 ether_addr_copy(auth->header.addr1, beacon->bssid); 796 ether_addr_copy(auth->header.addr2, ieee->dev->dev_addr); 797 ether_addr_copy(auth->header.addr3, beacon->bssid); 798 if (ieee->auth_mode == 0) 799 auth->algorithm = WLAN_AUTH_OPEN; 800 else if (ieee->auth_mode == 1) 801 auth->algorithm = cpu_to_le16(WLAN_AUTH_SHARED_KEY); 802 else if (ieee->auth_mode == 2) 803 auth->algorithm = WLAN_AUTH_OPEN; 804 auth->transaction = cpu_to_le16(ieee->associate_seq); 805 ieee->associate_seq++; 806 807 auth->status = cpu_to_le16(WLAN_STATUS_SUCCESS); 808 809 return skb; 810 } 811 812 static struct sk_buff *rtllib_probe_resp(struct rtllib_device *ieee, 813 const u8 *dest) 814 { 815 u8 *tag; 816 int beacon_size; 817 struct rtllib_probe_response *beacon_buf; 818 struct sk_buff *skb = NULL; 819 int encrypt; 820 int atim_len, erp_len; 821 struct lib80211_crypt_data *crypt; 822 823 char *ssid = ieee->current_network.ssid; 824 int ssid_len = ieee->current_network.ssid_len; 825 int rate_len = ieee->current_network.rates_len+2; 826 int rate_ex_len = ieee->current_network.rates_ex_len; 827 int wpa_ie_len = ieee->wpa_ie_len; 828 u8 erpinfo_content = 0; 829 830 u8 *tmp_ht_cap_buf = NULL; 831 u8 tmp_ht_cap_len = 0; 832 u8 *tmp_ht_info_buf = NULL; 833 u8 tmp_ht_info_len = 0; 834 struct rt_hi_throughput *pHTInfo = ieee->pHTInfo; 835 u8 *tmp_generic_ie_buf = NULL; 836 u8 tmp_generic_ie_len = 0; 837 838 if (rate_ex_len > 0) 839 rate_ex_len += 2; 840 841 if (ieee->current_network.capability & WLAN_CAPABILITY_IBSS) 842 atim_len = 4; 843 else 844 atim_len = 0; 845 846 if ((ieee->current_network.mode == IEEE_G) || 847 (ieee->current_network.mode == IEEE_N_24G && 848 ieee->pHTInfo->bCurSuppCCK)) { 849 erp_len = 3; 850 erpinfo_content = 0; 851 if (ieee->current_network.buseprotection) 852 erpinfo_content |= ERP_UseProtection; 853 } else 854 erp_len = 0; 855 856 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx]; 857 encrypt = ieee->host_encrypt && crypt && crypt->ops && 858 ((strcmp(crypt->ops->name, "R-WEP") == 0 || wpa_ie_len)); 859 if (ieee->pHTInfo->bCurrentHTSupport) { 860 tmp_ht_cap_buf = (u8 *) &(ieee->pHTInfo->SelfHTCap); 861 tmp_ht_cap_len = sizeof(ieee->pHTInfo->SelfHTCap); 862 tmp_ht_info_buf = (u8 *) &(ieee->pHTInfo->SelfHTInfo); 863 tmp_ht_info_len = sizeof(ieee->pHTInfo->SelfHTInfo); 864 HTConstructCapabilityElement(ieee, tmp_ht_cap_buf, 865 &tmp_ht_cap_len, encrypt, false); 866 HTConstructInfoElement(ieee, tmp_ht_info_buf, &tmp_ht_info_len, 867 encrypt); 868 869 if (pHTInfo->bRegRT2RTAggregation) { 870 tmp_generic_ie_buf = ieee->pHTInfo->szRT2RTAggBuffer; 871 tmp_generic_ie_len = 872 sizeof(ieee->pHTInfo->szRT2RTAggBuffer); 873 HTConstructRT2RTAggElement(ieee, tmp_generic_ie_buf, 874 &tmp_generic_ie_len); 875 } 876 } 877 878 beacon_size = sizeof(struct rtllib_probe_response)+2+ 879 ssid_len + 3 + rate_len + rate_ex_len + atim_len + erp_len 880 + wpa_ie_len + ieee->tx_headroom; 881 skb = dev_alloc_skb(beacon_size); 882 if (!skb) 883 return NULL; 884 885 skb_reserve(skb, ieee->tx_headroom); 886 887 beacon_buf = skb_put(skb, (beacon_size - ieee->tx_headroom)); 888 ether_addr_copy(beacon_buf->header.addr1, dest); 889 ether_addr_copy(beacon_buf->header.addr2, ieee->dev->dev_addr); 890 ether_addr_copy(beacon_buf->header.addr3, ieee->current_network.bssid); 891 892 beacon_buf->header.duration_id = 0; 893 beacon_buf->beacon_interval = 894 cpu_to_le16(ieee->current_network.beacon_interval); 895 beacon_buf->capability = 896 cpu_to_le16(ieee->current_network.capability & 897 WLAN_CAPABILITY_IBSS); 898 beacon_buf->capability |= 899 cpu_to_le16(ieee->current_network.capability & 900 WLAN_CAPABILITY_SHORT_PREAMBLE); 901 902 if (ieee->short_slot && (ieee->current_network.capability & 903 WLAN_CAPABILITY_SHORT_SLOT_TIME)) 904 beacon_buf->capability |= 905 cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME); 906 907 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx]; 908 if (encrypt) 909 beacon_buf->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY); 910 911 912 beacon_buf->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_PROBE_RESP); 913 beacon_buf->info_element[0].id = MFIE_TYPE_SSID; 914 beacon_buf->info_element[0].len = ssid_len; 915 916 tag = (u8 *) beacon_buf->info_element[0].data; 917 918 memcpy(tag, ssid, ssid_len); 919 920 tag += ssid_len; 921 922 *(tag++) = MFIE_TYPE_RATES; 923 *(tag++) = rate_len-2; 924 memcpy(tag, ieee->current_network.rates, rate_len-2); 925 tag += rate_len-2; 926 927 *(tag++) = MFIE_TYPE_DS_SET; 928 *(tag++) = 1; 929 *(tag++) = ieee->current_network.channel; 930 931 if (atim_len) { 932 u16 val16; 933 *(tag++) = MFIE_TYPE_IBSS_SET; 934 *(tag++) = 2; 935 val16 = ieee->current_network.atim_window; 936 memcpy((u8 *)tag, (u8 *)&val16, 2); 937 tag += 2; 938 } 939 940 if (erp_len) { 941 *(tag++) = MFIE_TYPE_ERP; 942 *(tag++) = 1; 943 *(tag++) = erpinfo_content; 944 } 945 if (rate_ex_len) { 946 *(tag++) = MFIE_TYPE_RATES_EX; 947 *(tag++) = rate_ex_len-2; 948 memcpy(tag, ieee->current_network.rates_ex, rate_ex_len-2); 949 tag += rate_ex_len-2; 950 } 951 952 if (wpa_ie_len) { 953 if (ieee->iw_mode == IW_MODE_ADHOC) 954 memcpy(&ieee->wpa_ie[14], &ieee->wpa_ie[8], 4); 955 memcpy(tag, ieee->wpa_ie, ieee->wpa_ie_len); 956 tag += ieee->wpa_ie_len; 957 } 958 return skb; 959 } 960 961 static struct sk_buff *rtllib_assoc_resp(struct rtllib_device *ieee, u8 *dest) 962 { 963 struct sk_buff *skb; 964 u8 *tag; 965 966 struct lib80211_crypt_data *crypt; 967 struct rtllib_assoc_response_frame *assoc; 968 short encrypt; 969 970 unsigned int rate_len = rtllib_MFIE_rate_len(ieee); 971 int len = sizeof(struct rtllib_assoc_response_frame) + rate_len + 972 ieee->tx_headroom; 973 974 skb = dev_alloc_skb(len); 975 976 if (!skb) 977 return NULL; 978 979 skb_reserve(skb, ieee->tx_headroom); 980 981 assoc = skb_put(skb, sizeof(struct rtllib_assoc_response_frame)); 982 983 assoc->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_ASSOC_RESP); 984 ether_addr_copy(assoc->header.addr1, dest); 985 ether_addr_copy(assoc->header.addr3, ieee->dev->dev_addr); 986 ether_addr_copy(assoc->header.addr2, ieee->dev->dev_addr); 987 assoc->capability = cpu_to_le16(ieee->iw_mode == IW_MODE_MASTER ? 988 WLAN_CAPABILITY_ESS : WLAN_CAPABILITY_IBSS); 989 990 991 if (ieee->short_slot) 992 assoc->capability |= 993 cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME); 994 995 if (ieee->host_encrypt) 996 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx]; 997 else 998 crypt = NULL; 999 1000 encrypt = (crypt && crypt->ops); 1001 1002 if (encrypt) 1003 assoc->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY); 1004 1005 assoc->status = 0; 1006 assoc->aid = cpu_to_le16(ieee->assoc_id); 1007 if (ieee->assoc_id == 0x2007) 1008 ieee->assoc_id = 0; 1009 else 1010 ieee->assoc_id++; 1011 1012 tag = skb_put(skb, rate_len); 1013 rtllib_MFIE_Brate(ieee, &tag); 1014 rtllib_MFIE_Grate(ieee, &tag); 1015 1016 return skb; 1017 } 1018 1019 static struct sk_buff *rtllib_auth_resp(struct rtllib_device *ieee, int status, 1020 u8 *dest) 1021 { 1022 struct sk_buff *skb = NULL; 1023 struct rtllib_authentication *auth; 1024 int len = ieee->tx_headroom + sizeof(struct rtllib_authentication) + 1; 1025 1026 skb = dev_alloc_skb(len); 1027 if (!skb) 1028 return NULL; 1029 1030 skb->len = sizeof(struct rtllib_authentication); 1031 1032 skb_reserve(skb, ieee->tx_headroom); 1033 1034 auth = skb_put(skb, sizeof(struct rtllib_authentication)); 1035 1036 auth->status = cpu_to_le16(status); 1037 auth->transaction = cpu_to_le16(2); 1038 auth->algorithm = cpu_to_le16(WLAN_AUTH_OPEN); 1039 1040 ether_addr_copy(auth->header.addr3, ieee->dev->dev_addr); 1041 ether_addr_copy(auth->header.addr2, ieee->dev->dev_addr); 1042 ether_addr_copy(auth->header.addr1, dest); 1043 auth->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_AUTH); 1044 return skb; 1045 1046 1047 } 1048 1049 static struct sk_buff *rtllib_null_func(struct rtllib_device *ieee, short pwr) 1050 { 1051 struct sk_buff *skb; 1052 struct rtllib_hdr_3addr *hdr; 1053 1054 skb = dev_alloc_skb(sizeof(struct rtllib_hdr_3addr)+ieee->tx_headroom); 1055 if (!skb) 1056 return NULL; 1057 1058 skb_reserve(skb, ieee->tx_headroom); 1059 1060 hdr = skb_put(skb, sizeof(struct rtllib_hdr_3addr)); 1061 1062 ether_addr_copy(hdr->addr1, ieee->current_network.bssid); 1063 ether_addr_copy(hdr->addr2, ieee->dev->dev_addr); 1064 ether_addr_copy(hdr->addr3, ieee->current_network.bssid); 1065 1066 hdr->frame_ctl = cpu_to_le16(RTLLIB_FTYPE_DATA | 1067 RTLLIB_STYPE_NULLFUNC | RTLLIB_FCTL_TODS | 1068 (pwr ? RTLLIB_FCTL_PM : 0)); 1069 1070 return skb; 1071 1072 1073 } 1074 1075 static struct sk_buff *rtllib_pspoll_func(struct rtllib_device *ieee) 1076 { 1077 struct sk_buff *skb; 1078 struct rtllib_pspoll_hdr *hdr; 1079 1080 skb = dev_alloc_skb(sizeof(struct rtllib_pspoll_hdr)+ieee->tx_headroom); 1081 if (!skb) 1082 return NULL; 1083 1084 skb_reserve(skb, ieee->tx_headroom); 1085 1086 hdr = skb_put(skb, sizeof(struct rtllib_pspoll_hdr)); 1087 1088 ether_addr_copy(hdr->bssid, ieee->current_network.bssid); 1089 ether_addr_copy(hdr->ta, ieee->dev->dev_addr); 1090 1091 hdr->aid = cpu_to_le16(ieee->assoc_id | 0xc000); 1092 hdr->frame_ctl = cpu_to_le16(RTLLIB_FTYPE_CTL | RTLLIB_STYPE_PSPOLL | 1093 RTLLIB_FCTL_PM); 1094 1095 return skb; 1096 1097 } 1098 1099 static void rtllib_resp_to_assoc_rq(struct rtllib_device *ieee, u8 *dest) 1100 { 1101 struct sk_buff *buf = rtllib_assoc_resp(ieee, dest); 1102 1103 if (buf) 1104 softmac_mgmt_xmit(buf, ieee); 1105 } 1106 1107 1108 static void rtllib_resp_to_auth(struct rtllib_device *ieee, int s, u8 *dest) 1109 { 1110 struct sk_buff *buf = rtllib_auth_resp(ieee, s, dest); 1111 1112 if (buf) 1113 softmac_mgmt_xmit(buf, ieee); 1114 } 1115 1116 1117 static void rtllib_resp_to_probe(struct rtllib_device *ieee, u8 *dest) 1118 { 1119 struct sk_buff *buf = rtllib_probe_resp(ieee, dest); 1120 1121 if (buf) 1122 softmac_mgmt_xmit(buf, ieee); 1123 } 1124 1125 1126 static inline int SecIsInPMKIDList(struct rtllib_device *ieee, u8 *bssid) 1127 { 1128 int i = 0; 1129 1130 do { 1131 if ((ieee->PMKIDList[i].bUsed) && 1132 (memcmp(ieee->PMKIDList[i].Bssid, bssid, ETH_ALEN) == 0)) 1133 break; 1134 i++; 1135 } while (i < NUM_PMKID_CACHE); 1136 1137 if (i == NUM_PMKID_CACHE) 1138 i = -1; 1139 return i; 1140 } 1141 1142 static inline struct sk_buff * 1143 rtllib_association_req(struct rtllib_network *beacon, 1144 struct rtllib_device *ieee) 1145 { 1146 struct sk_buff *skb; 1147 struct rtllib_assoc_request_frame *hdr; 1148 u8 *tag, *ies; 1149 int i; 1150 u8 *ht_cap_buf = NULL; 1151 u8 ht_cap_len = 0; 1152 u8 *realtek_ie_buf = NULL; 1153 u8 realtek_ie_len = 0; 1154 int wpa_ie_len = ieee->wpa_ie_len; 1155 int wps_ie_len = ieee->wps_ie_len; 1156 unsigned int ckip_ie_len = 0; 1157 unsigned int ccxrm_ie_len = 0; 1158 unsigned int cxvernum_ie_len = 0; 1159 struct lib80211_crypt_data *crypt; 1160 int encrypt; 1161 int PMKCacheIdx; 1162 1163 unsigned int rate_len = (beacon->rates_len ? 1164 (beacon->rates_len + 2) : 0) + 1165 (beacon->rates_ex_len ? (beacon->rates_ex_len) + 1166 2 : 0); 1167 1168 unsigned int wmm_info_len = beacon->qos_data.supported ? 9 : 0; 1169 unsigned int turbo_info_len = beacon->Turbo_Enable ? 9 : 0; 1170 1171 int len = 0; 1172 1173 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx]; 1174 if (crypt != NULL) 1175 encrypt = ieee->host_encrypt && crypt && crypt->ops && 1176 ((strcmp(crypt->ops->name, "R-WEP") == 0 || 1177 wpa_ie_len)); 1178 else 1179 encrypt = 0; 1180 1181 if ((ieee->rtllib_ap_sec_type && 1182 (ieee->rtllib_ap_sec_type(ieee) & SEC_ALG_TKIP)) || 1183 ieee->bForcedBgMode) { 1184 ieee->pHTInfo->bEnableHT = 0; 1185 ieee->mode = WIRELESS_MODE_G; 1186 } 1187 1188 if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT) { 1189 ht_cap_buf = (u8 *)&(ieee->pHTInfo->SelfHTCap); 1190 ht_cap_len = sizeof(ieee->pHTInfo->SelfHTCap); 1191 HTConstructCapabilityElement(ieee, ht_cap_buf, &ht_cap_len, 1192 encrypt, true); 1193 if (ieee->pHTInfo->bCurrentRT2RTAggregation) { 1194 realtek_ie_buf = ieee->pHTInfo->szRT2RTAggBuffer; 1195 realtek_ie_len = 1196 sizeof(ieee->pHTInfo->szRT2RTAggBuffer); 1197 HTConstructRT2RTAggElement(ieee, realtek_ie_buf, 1198 &realtek_ie_len); 1199 } 1200 } 1201 1202 if (beacon->bCkipSupported) 1203 ckip_ie_len = 30+2; 1204 if (beacon->bCcxRmEnable) 1205 ccxrm_ie_len = 6+2; 1206 if (beacon->BssCcxVerNumber >= 2) 1207 cxvernum_ie_len = 5+2; 1208 1209 PMKCacheIdx = SecIsInPMKIDList(ieee, ieee->current_network.bssid); 1210 if (PMKCacheIdx >= 0) { 1211 wpa_ie_len += 18; 1212 netdev_info(ieee->dev, "[PMK cache]: WPA2 IE length: %x\n", 1213 wpa_ie_len); 1214 } 1215 len = sizeof(struct rtllib_assoc_request_frame) + 2 1216 + beacon->ssid_len 1217 + rate_len 1218 + wpa_ie_len 1219 + wps_ie_len 1220 + wmm_info_len 1221 + turbo_info_len 1222 + ht_cap_len 1223 + realtek_ie_len 1224 + ckip_ie_len 1225 + ccxrm_ie_len 1226 + cxvernum_ie_len 1227 + ieee->tx_headroom; 1228 1229 skb = dev_alloc_skb(len); 1230 1231 if (!skb) 1232 return NULL; 1233 1234 skb_reserve(skb, ieee->tx_headroom); 1235 1236 hdr = skb_put(skb, sizeof(struct rtllib_assoc_request_frame) + 2); 1237 1238 1239 hdr->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_ASSOC_REQ); 1240 hdr->header.duration_id = cpu_to_le16(37); 1241 ether_addr_copy(hdr->header.addr1, beacon->bssid); 1242 ether_addr_copy(hdr->header.addr2, ieee->dev->dev_addr); 1243 ether_addr_copy(hdr->header.addr3, beacon->bssid); 1244 1245 ether_addr_copy(ieee->ap_mac_addr, beacon->bssid); 1246 1247 hdr->capability = cpu_to_le16(WLAN_CAPABILITY_ESS); 1248 if (beacon->capability & WLAN_CAPABILITY_PRIVACY) 1249 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY); 1250 1251 if (beacon->capability & WLAN_CAPABILITY_SHORT_PREAMBLE) 1252 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE); 1253 1254 if (ieee->short_slot && 1255 (beacon->capability&WLAN_CAPABILITY_SHORT_SLOT_TIME)) 1256 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME); 1257 1258 1259 hdr->listen_interval = cpu_to_le16(beacon->listen_interval); 1260 1261 hdr->info_element[0].id = MFIE_TYPE_SSID; 1262 1263 hdr->info_element[0].len = beacon->ssid_len; 1264 skb_put_data(skb, beacon->ssid, beacon->ssid_len); 1265 1266 tag = skb_put(skb, rate_len); 1267 1268 if (beacon->rates_len) { 1269 *tag++ = MFIE_TYPE_RATES; 1270 *tag++ = beacon->rates_len; 1271 for (i = 0; i < beacon->rates_len; i++) 1272 *tag++ = beacon->rates[i]; 1273 } 1274 1275 if (beacon->rates_ex_len) { 1276 *tag++ = MFIE_TYPE_RATES_EX; 1277 *tag++ = beacon->rates_ex_len; 1278 for (i = 0; i < beacon->rates_ex_len; i++) 1279 *tag++ = beacon->rates_ex[i]; 1280 } 1281 1282 if (beacon->bCkipSupported) { 1283 static const u8 AironetIeOui[] = {0x00, 0x01, 0x66}; 1284 u8 CcxAironetBuf[30]; 1285 struct octet_string osCcxAironetIE; 1286 1287 memset(CcxAironetBuf, 0, 30); 1288 osCcxAironetIE.Octet = CcxAironetBuf; 1289 osCcxAironetIE.Length = sizeof(CcxAironetBuf); 1290 memcpy(osCcxAironetIE.Octet, AironetIeOui, 1291 sizeof(AironetIeOui)); 1292 1293 osCcxAironetIE.Octet[IE_CISCO_FLAG_POSITION] |= 1294 (SUPPORT_CKIP_PK|SUPPORT_CKIP_MIC); 1295 tag = skb_put(skb, ckip_ie_len); 1296 *tag++ = MFIE_TYPE_AIRONET; 1297 *tag++ = osCcxAironetIE.Length; 1298 memcpy(tag, osCcxAironetIE.Octet, osCcxAironetIE.Length); 1299 tag += osCcxAironetIE.Length; 1300 } 1301 1302 if (beacon->bCcxRmEnable) { 1303 static const u8 CcxRmCapBuf[] = {0x00, 0x40, 0x96, 0x01, 0x01, 1304 0x00}; 1305 struct octet_string osCcxRmCap; 1306 1307 osCcxRmCap.Octet = (u8 *) CcxRmCapBuf; 1308 osCcxRmCap.Length = sizeof(CcxRmCapBuf); 1309 tag = skb_put(skb, ccxrm_ie_len); 1310 *tag++ = MFIE_TYPE_GENERIC; 1311 *tag++ = osCcxRmCap.Length; 1312 memcpy(tag, osCcxRmCap.Octet, osCcxRmCap.Length); 1313 tag += osCcxRmCap.Length; 1314 } 1315 1316 if (beacon->BssCcxVerNumber >= 2) { 1317 u8 CcxVerNumBuf[] = {0x00, 0x40, 0x96, 0x03, 0x00}; 1318 struct octet_string osCcxVerNum; 1319 1320 CcxVerNumBuf[4] = beacon->BssCcxVerNumber; 1321 osCcxVerNum.Octet = CcxVerNumBuf; 1322 osCcxVerNum.Length = sizeof(CcxVerNumBuf); 1323 tag = skb_put(skb, cxvernum_ie_len); 1324 *tag++ = MFIE_TYPE_GENERIC; 1325 *tag++ = osCcxVerNum.Length; 1326 memcpy(tag, osCcxVerNum.Octet, osCcxVerNum.Length); 1327 tag += osCcxVerNum.Length; 1328 } 1329 if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT) { 1330 if (ieee->pHTInfo->ePeerHTSpecVer != HT_SPEC_VER_EWC) { 1331 tag = skb_put(skb, ht_cap_len); 1332 *tag++ = MFIE_TYPE_HT_CAP; 1333 *tag++ = ht_cap_len - 2; 1334 memcpy(tag, ht_cap_buf, ht_cap_len - 2); 1335 tag += ht_cap_len - 2; 1336 } 1337 } 1338 1339 if (wpa_ie_len) { 1340 skb_put_data(skb, ieee->wpa_ie, ieee->wpa_ie_len); 1341 1342 if (PMKCacheIdx >= 0) { 1343 tag = skb_put(skb, 18); 1344 *tag = 1; 1345 *(tag + 1) = 0; 1346 memcpy((tag + 2), &ieee->PMKIDList[PMKCacheIdx].PMKID, 1347 16); 1348 } 1349 } 1350 if (wmm_info_len) { 1351 tag = skb_put(skb, wmm_info_len); 1352 rtllib_WMM_Info(ieee, &tag); 1353 } 1354 1355 if (wps_ie_len && ieee->wps_ie) 1356 skb_put_data(skb, ieee->wps_ie, wps_ie_len); 1357 1358 if (turbo_info_len) { 1359 tag = skb_put(skb, turbo_info_len); 1360 rtllib_TURBO_Info(ieee, &tag); 1361 } 1362 1363 if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT) { 1364 if (ieee->pHTInfo->ePeerHTSpecVer == HT_SPEC_VER_EWC) { 1365 tag = skb_put(skb, ht_cap_len); 1366 *tag++ = MFIE_TYPE_GENERIC; 1367 *tag++ = ht_cap_len - 2; 1368 memcpy(tag, ht_cap_buf, ht_cap_len - 2); 1369 tag += ht_cap_len - 2; 1370 } 1371 1372 if (ieee->pHTInfo->bCurrentRT2RTAggregation) { 1373 tag = skb_put(skb, realtek_ie_len); 1374 *tag++ = MFIE_TYPE_GENERIC; 1375 *tag++ = realtek_ie_len - 2; 1376 memcpy(tag, realtek_ie_buf, realtek_ie_len - 2); 1377 } 1378 } 1379 1380 kfree(ieee->assocreq_ies); 1381 ieee->assocreq_ies = NULL; 1382 ies = &(hdr->info_element[0].id); 1383 ieee->assocreq_ies_len = (skb->data + skb->len) - ies; 1384 ieee->assocreq_ies = kmemdup(ies, ieee->assocreq_ies_len, GFP_ATOMIC); 1385 if (!ieee->assocreq_ies) 1386 ieee->assocreq_ies_len = 0; 1387 1388 return skb; 1389 } 1390 1391 static void rtllib_associate_abort(struct rtllib_device *ieee) 1392 { 1393 unsigned long flags; 1394 1395 spin_lock_irqsave(&ieee->lock, flags); 1396 1397 ieee->associate_seq++; 1398 1399 /* don't scan, and avoid to have the RX path possibily 1400 * try again to associate. Even do not react to AUTH or 1401 * ASSOC response. Just wait for the retry wq to be scheduled. 1402 * Here we will check if there are good nets to associate 1403 * with, so we retry or just get back to NO_LINK and scanning 1404 */ 1405 if (ieee->state == RTLLIB_ASSOCIATING_AUTHENTICATING) { 1406 netdev_dbg(ieee->dev, "Authentication failed\n"); 1407 ieee->softmac_stats.no_auth_rs++; 1408 } else { 1409 netdev_dbg(ieee->dev, "Association failed\n"); 1410 ieee->softmac_stats.no_ass_rs++; 1411 } 1412 1413 ieee->state = RTLLIB_ASSOCIATING_RETRY; 1414 1415 schedule_delayed_work(&ieee->associate_retry_wq, 1416 RTLLIB_SOFTMAC_ASSOC_RETRY_TIME); 1417 1418 spin_unlock_irqrestore(&ieee->lock, flags); 1419 } 1420 1421 static void rtllib_associate_abort_cb(struct timer_list *t) 1422 { 1423 struct rtllib_device *dev = from_timer(dev, t, associate_timer); 1424 1425 rtllib_associate_abort(dev); 1426 } 1427 1428 static void rtllib_associate_step1(struct rtllib_device *ieee, u8 *daddr) 1429 { 1430 struct rtllib_network *beacon = &ieee->current_network; 1431 struct sk_buff *skb; 1432 1433 netdev_dbg(ieee->dev, "Stopping scan\n"); 1434 1435 ieee->softmac_stats.tx_auth_rq++; 1436 1437 skb = rtllib_authentication_req(beacon, ieee, 0, daddr); 1438 1439 if (!skb) 1440 rtllib_associate_abort(ieee); 1441 else { 1442 ieee->state = RTLLIB_ASSOCIATING_AUTHENTICATING; 1443 netdev_dbg(ieee->dev, "Sending authentication request\n"); 1444 softmac_mgmt_xmit(skb, ieee); 1445 if (!timer_pending(&ieee->associate_timer)) { 1446 ieee->associate_timer.expires = jiffies + (HZ / 2); 1447 add_timer(&ieee->associate_timer); 1448 } 1449 } 1450 } 1451 1452 static void rtllib_auth_challenge(struct rtllib_device *ieee, u8 *challenge, 1453 int chlen) 1454 { 1455 u8 *c; 1456 struct sk_buff *skb; 1457 struct rtllib_network *beacon = &ieee->current_network; 1458 1459 ieee->associate_seq++; 1460 ieee->softmac_stats.tx_auth_rq++; 1461 1462 skb = rtllib_authentication_req(beacon, ieee, chlen + 2, beacon->bssid); 1463 1464 if (!skb) 1465 rtllib_associate_abort(ieee); 1466 else { 1467 c = skb_put(skb, chlen+2); 1468 *(c++) = MFIE_TYPE_CHALLENGE; 1469 *(c++) = chlen; 1470 memcpy(c, challenge, chlen); 1471 1472 netdev_dbg(ieee->dev, 1473 "Sending authentication challenge response\n"); 1474 1475 rtllib_encrypt_fragment(ieee, skb, 1476 sizeof(struct rtllib_hdr_3addr)); 1477 1478 softmac_mgmt_xmit(skb, ieee); 1479 mod_timer(&ieee->associate_timer, jiffies + (HZ/2)); 1480 } 1481 kfree(challenge); 1482 } 1483 1484 static void rtllib_associate_step2(struct rtllib_device *ieee) 1485 { 1486 struct sk_buff *skb; 1487 struct rtllib_network *beacon = &ieee->current_network; 1488 1489 del_timer_sync(&ieee->associate_timer); 1490 1491 netdev_dbg(ieee->dev, "Sending association request\n"); 1492 1493 ieee->softmac_stats.tx_ass_rq++; 1494 skb = rtllib_association_req(beacon, ieee); 1495 if (!skb) 1496 rtllib_associate_abort(ieee); 1497 else { 1498 softmac_mgmt_xmit(skb, ieee); 1499 mod_timer(&ieee->associate_timer, jiffies + (HZ/2)); 1500 } 1501 } 1502 1503 static void rtllib_associate_complete_wq(void *data) 1504 { 1505 struct rtllib_device *ieee = (struct rtllib_device *) 1506 container_of_work_rsl(data, 1507 struct rtllib_device, 1508 associate_complete_wq); 1509 struct rt_pwr_save_ctrl *pPSC = &(ieee->PowerSaveControl); 1510 1511 netdev_info(ieee->dev, "Associated successfully with %pM\n", 1512 ieee->current_network.bssid); 1513 if (!ieee->is_silent_reset) { 1514 netdev_info(ieee->dev, "normal associate\n"); 1515 notify_wx_assoc_event(ieee); 1516 } 1517 1518 netif_carrier_on(ieee->dev); 1519 ieee->is_roaming = false; 1520 if (rtllib_is_54g(&ieee->current_network) && 1521 (ieee->modulation & RTLLIB_OFDM_MODULATION)) { 1522 ieee->rate = 108; 1523 netdev_info(ieee->dev, "Using G rates:%d\n", ieee->rate); 1524 } else { 1525 ieee->rate = 22; 1526 ieee->SetWirelessMode(ieee->dev, IEEE_B); 1527 netdev_info(ieee->dev, "Using B rates:%d\n", ieee->rate); 1528 } 1529 if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT) { 1530 netdev_info(ieee->dev, "Successfully associated, ht enabled\n"); 1531 HTOnAssocRsp(ieee); 1532 } else { 1533 netdev_info(ieee->dev, 1534 "Successfully associated, ht not enabled(%d, %d)\n", 1535 ieee->pHTInfo->bCurrentHTSupport, 1536 ieee->pHTInfo->bEnableHT); 1537 memset(ieee->dot11HTOperationalRateSet, 0, 16); 1538 } 1539 ieee->LinkDetectInfo.SlotNum = 2 * (1 + 1540 ieee->current_network.beacon_interval / 1541 500); 1542 if (ieee->LinkDetectInfo.NumRecvBcnInPeriod == 0 || 1543 ieee->LinkDetectInfo.NumRecvDataInPeriod == 0) { 1544 ieee->LinkDetectInfo.NumRecvBcnInPeriod = 1; 1545 ieee->LinkDetectInfo.NumRecvDataInPeriod = 1; 1546 } 1547 pPSC->LpsIdleCount = 0; 1548 ieee->link_change(ieee->dev); 1549 1550 if (ieee->is_silent_reset) { 1551 netdev_info(ieee->dev, "silent reset associate\n"); 1552 ieee->is_silent_reset = false; 1553 } 1554 1555 if (ieee->data_hard_resume) 1556 ieee->data_hard_resume(ieee->dev); 1557 1558 } 1559 1560 static void rtllib_sta_send_associnfo(struct rtllib_device *ieee) 1561 { 1562 } 1563 1564 static void rtllib_associate_complete(struct rtllib_device *ieee) 1565 { 1566 del_timer_sync(&ieee->associate_timer); 1567 1568 ieee->state = RTLLIB_LINKED; 1569 rtllib_sta_send_associnfo(ieee); 1570 1571 schedule_work(&ieee->associate_complete_wq); 1572 } 1573 1574 static void rtllib_associate_procedure_wq(void *data) 1575 { 1576 struct rtllib_device *ieee = container_of_dwork_rsl(data, 1577 struct rtllib_device, 1578 associate_procedure_wq); 1579 rtllib_stop_scan_syncro(ieee); 1580 if (ieee->rtllib_ips_leave != NULL) 1581 ieee->rtllib_ips_leave(ieee->dev); 1582 mutex_lock(&ieee->wx_mutex); 1583 1584 if (ieee->data_hard_stop) 1585 ieee->data_hard_stop(ieee->dev); 1586 1587 rtllib_stop_scan(ieee); 1588 RT_TRACE(COMP_DBG, "===>%s(), chan:%d\n", __func__, 1589 ieee->current_network.channel); 1590 HTSetConnectBwMode(ieee, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT); 1591 if (ieee->eRFPowerState == eRfOff) { 1592 RT_TRACE(COMP_DBG, 1593 "=============>%s():Rf state is eRfOff, schedule ipsleave wq again,return\n", 1594 __func__); 1595 if (ieee->rtllib_ips_leave_wq != NULL) 1596 ieee->rtllib_ips_leave_wq(ieee->dev); 1597 mutex_unlock(&ieee->wx_mutex); 1598 return; 1599 } 1600 ieee->associate_seq = 1; 1601 1602 rtllib_associate_step1(ieee, ieee->current_network.bssid); 1603 1604 mutex_unlock(&ieee->wx_mutex); 1605 } 1606 1607 inline void rtllib_softmac_new_net(struct rtllib_device *ieee, 1608 struct rtllib_network *net) 1609 { 1610 u8 tmp_ssid[IW_ESSID_MAX_SIZE + 1]; 1611 int tmp_ssid_len = 0; 1612 1613 short apset, ssidset, ssidbroad, apmatch, ssidmatch; 1614 1615 /* we are interested in new new only if we are not associated 1616 * and we are not associating / authenticating 1617 */ 1618 if (ieee->state != RTLLIB_NOLINK) 1619 return; 1620 1621 if ((ieee->iw_mode == IW_MODE_INFRA) && !(net->capability & 1622 WLAN_CAPABILITY_ESS)) 1623 return; 1624 1625 if ((ieee->iw_mode == IW_MODE_ADHOC) && !(net->capability & 1626 WLAN_CAPABILITY_IBSS)) 1627 return; 1628 1629 if ((ieee->iw_mode == IW_MODE_ADHOC) && 1630 (net->channel > ieee->ibss_maxjoin_chal)) 1631 return; 1632 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC) { 1633 /* if the user specified the AP MAC, we need also the essid 1634 * This could be obtained by beacons or, if the network does not 1635 * broadcast it, it can be put manually. 1636 */ 1637 apset = ieee->wap_set; 1638 ssidset = ieee->ssid_set; 1639 ssidbroad = !(net->ssid_len == 0 || net->ssid[0] == '\0'); 1640 apmatch = (memcmp(ieee->current_network.bssid, net->bssid, 1641 ETH_ALEN) == 0); 1642 if (!ssidbroad) { 1643 ssidmatch = (ieee->current_network.ssid_len == 1644 net->hidden_ssid_len) && 1645 (!strncmp(ieee->current_network.ssid, 1646 net->hidden_ssid, net->hidden_ssid_len)); 1647 if (net->hidden_ssid_len > 0) { 1648 strncpy(net->ssid, net->hidden_ssid, 1649 net->hidden_ssid_len); 1650 net->ssid_len = net->hidden_ssid_len; 1651 ssidbroad = 1; 1652 } 1653 } else 1654 ssidmatch = 1655 (ieee->current_network.ssid_len == net->ssid_len) && 1656 (!strncmp(ieee->current_network.ssid, net->ssid, 1657 net->ssid_len)); 1658 1659 /* if the user set the AP check if match. 1660 * if the network does not broadcast essid we check the 1661 * user supplied ANY essid 1662 * if the network does broadcast and the user does not set 1663 * essid it is OK 1664 * if the network does broadcast and the user did set essid 1665 * check if essid match 1666 * if the ap is not set, check that the user set the bssid 1667 * and the network does broadcast and that those two bssid match 1668 */ 1669 if ((apset && apmatch && 1670 ((ssidset && ssidbroad && ssidmatch) || 1671 (ssidbroad && !ssidset) || (!ssidbroad && ssidset))) || 1672 (!apset && ssidset && ssidbroad && ssidmatch) || 1673 (ieee->is_roaming && ssidset && ssidbroad && ssidmatch)) { 1674 /* Save the essid so that if it is hidden, it is 1675 * replaced with the essid provided by the user. 1676 */ 1677 if (!ssidbroad) { 1678 memcpy(tmp_ssid, ieee->current_network.ssid, 1679 ieee->current_network.ssid_len); 1680 tmp_ssid_len = ieee->current_network.ssid_len; 1681 } 1682 memcpy(&ieee->current_network, net, 1683 sizeof(ieee->current_network)); 1684 if (!ssidbroad) { 1685 memcpy(ieee->current_network.ssid, tmp_ssid, 1686 tmp_ssid_len); 1687 ieee->current_network.ssid_len = tmp_ssid_len; 1688 } 1689 netdev_info(ieee->dev, 1690 "Linking with %s,channel:%d, qos:%d, myHT:%d, networkHT:%d, mode:%x cur_net.flags:0x%x\n", 1691 ieee->current_network.ssid, 1692 ieee->current_network.channel, 1693 ieee->current_network.qos_data.supported, 1694 ieee->pHTInfo->bEnableHT, 1695 ieee->current_network.bssht.bdSupportHT, 1696 ieee->current_network.mode, 1697 ieee->current_network.flags); 1698 1699 if ((rtllib_act_scanning(ieee, false)) && 1700 !(ieee->softmac_features & IEEE_SOFTMAC_SCAN)) 1701 rtllib_stop_scan_syncro(ieee); 1702 1703 HTResetIOTSetting(ieee->pHTInfo); 1704 ieee->wmm_acm = 0; 1705 if (ieee->iw_mode == IW_MODE_INFRA) { 1706 /* Join the network for the first time */ 1707 ieee->AsocRetryCount = 0; 1708 if ((ieee->current_network.qos_data.supported == 1) && 1709 ieee->current_network.bssht.bdSupportHT) 1710 HTResetSelfAndSavePeerSetting(ieee, 1711 &(ieee->current_network)); 1712 else 1713 ieee->pHTInfo->bCurrentHTSupport = 1714 false; 1715 1716 ieee->state = RTLLIB_ASSOCIATING; 1717 if (ieee->LedControlHandler != NULL) 1718 ieee->LedControlHandler(ieee->dev, 1719 LED_CTL_START_TO_LINK); 1720 schedule_delayed_work( 1721 &ieee->associate_procedure_wq, 0); 1722 } else { 1723 if (rtllib_is_54g(&ieee->current_network) && 1724 (ieee->modulation & 1725 RTLLIB_OFDM_MODULATION)) { 1726 ieee->rate = 108; 1727 ieee->SetWirelessMode(ieee->dev, 1728 IEEE_G); 1729 netdev_info(ieee->dev, 1730 "Using G rates\n"); 1731 } else { 1732 ieee->rate = 22; 1733 ieee->SetWirelessMode(ieee->dev, 1734 IEEE_B); 1735 netdev_info(ieee->dev, 1736 "Using B rates\n"); 1737 } 1738 memset(ieee->dot11HTOperationalRateSet, 0, 16); 1739 ieee->state = RTLLIB_LINKED; 1740 } 1741 } 1742 } 1743 } 1744 1745 static void rtllib_softmac_check_all_nets(struct rtllib_device *ieee) 1746 { 1747 unsigned long flags; 1748 struct rtllib_network *target; 1749 1750 spin_lock_irqsave(&ieee->lock, flags); 1751 1752 list_for_each_entry(target, &ieee->network_list, list) { 1753 1754 /* if the state become different that NOLINK means 1755 * we had found what we are searching for 1756 */ 1757 1758 if (ieee->state != RTLLIB_NOLINK) 1759 break; 1760 1761 if (ieee->scan_age == 0 || time_after(target->last_scanned + 1762 ieee->scan_age, jiffies)) 1763 rtllib_softmac_new_net(ieee, target); 1764 } 1765 spin_unlock_irqrestore(&ieee->lock, flags); 1766 } 1767 1768 static inline u16 auth_parse(struct net_device *dev, struct sk_buff *skb, 1769 u8 **challenge, int *chlen) 1770 { 1771 struct rtllib_authentication *a; 1772 u8 *t; 1773 1774 if (skb->len < (sizeof(struct rtllib_authentication) - 1775 sizeof(struct rtllib_info_element))) { 1776 netdev_dbg(dev, "invalid len in auth resp: %d\n", skb->len); 1777 return 0xcafe; 1778 } 1779 *challenge = NULL; 1780 a = (struct rtllib_authentication *) skb->data; 1781 if (skb->len > (sizeof(struct rtllib_authentication) + 3)) { 1782 t = skb->data + sizeof(struct rtllib_authentication); 1783 1784 if (*(t++) == MFIE_TYPE_CHALLENGE) { 1785 *chlen = *(t++); 1786 *challenge = kmemdup(t, *chlen, GFP_ATOMIC); 1787 if (!*challenge) 1788 return -ENOMEM; 1789 } 1790 } 1791 return le16_to_cpu(a->status); 1792 } 1793 1794 static int auth_rq_parse(struct net_device *dev, struct sk_buff *skb, u8 *dest) 1795 { 1796 struct rtllib_authentication *a; 1797 1798 if (skb->len < (sizeof(struct rtllib_authentication) - 1799 sizeof(struct rtllib_info_element))) { 1800 netdev_dbg(dev, "invalid len in auth request: %d\n", skb->len); 1801 return -1; 1802 } 1803 a = (struct rtllib_authentication *) skb->data; 1804 1805 ether_addr_copy(dest, a->header.addr2); 1806 1807 if (le16_to_cpu(a->algorithm) != WLAN_AUTH_OPEN) 1808 return WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG; 1809 1810 return WLAN_STATUS_SUCCESS; 1811 } 1812 1813 static short probe_rq_parse(struct rtllib_device *ieee, struct sk_buff *skb, 1814 u8 *src) 1815 { 1816 u8 *tag; 1817 u8 *skbend; 1818 u8 *ssid = NULL; 1819 u8 ssidlen = 0; 1820 struct rtllib_hdr_3addr *header = 1821 (struct rtllib_hdr_3addr *) skb->data; 1822 bool bssid_match; 1823 1824 if (skb->len < sizeof(struct rtllib_hdr_3addr)) 1825 return -1; /* corrupted */ 1826 1827 bssid_match = 1828 (!ether_addr_equal(header->addr3, ieee->current_network.bssid)) && 1829 (!is_broadcast_ether_addr(header->addr3)); 1830 if (bssid_match) 1831 return -1; 1832 1833 ether_addr_copy(src, header->addr2); 1834 1835 skbend = (u8 *)skb->data + skb->len; 1836 1837 tag = skb->data + sizeof(struct rtllib_hdr_3addr); 1838 1839 while (tag + 1 < skbend) { 1840 if (*tag == 0) { 1841 ssid = tag + 2; 1842 ssidlen = *(tag + 1); 1843 break; 1844 } 1845 tag++; /* point to the len field */ 1846 tag = tag + *(tag); /* point to the last data byte of the tag */ 1847 tag++; /* point to the next tag */ 1848 } 1849 1850 if (ssidlen == 0) 1851 return 1; 1852 1853 if (!ssid) 1854 return 1; /* ssid not found in tagged param */ 1855 1856 return !strncmp(ssid, ieee->current_network.ssid, ssidlen); 1857 } 1858 1859 static int assoc_rq_parse(struct net_device *dev, struct sk_buff *skb, u8 *dest) 1860 { 1861 struct rtllib_assoc_request_frame *a; 1862 1863 if (skb->len < (sizeof(struct rtllib_assoc_request_frame) - 1864 sizeof(struct rtllib_info_element))) { 1865 netdev_dbg(dev, "invalid len in auth request:%d\n", skb->len); 1866 return -1; 1867 } 1868 1869 a = (struct rtllib_assoc_request_frame *) skb->data; 1870 1871 ether_addr_copy(dest, a->header.addr2); 1872 1873 return 0; 1874 } 1875 1876 static inline u16 assoc_parse(struct rtllib_device *ieee, struct sk_buff *skb, 1877 int *aid) 1878 { 1879 struct rtllib_assoc_response_frame *response_head; 1880 u16 status_code; 1881 1882 if (skb->len < sizeof(struct rtllib_assoc_response_frame)) { 1883 netdev_dbg(ieee->dev, "Invalid len in auth resp: %d\n", 1884 skb->len); 1885 return 0xcafe; 1886 } 1887 1888 response_head = (struct rtllib_assoc_response_frame *) skb->data; 1889 *aid = le16_to_cpu(response_head->aid) & 0x3fff; 1890 1891 status_code = le16_to_cpu(response_head->status); 1892 if ((status_code == WLAN_STATUS_ASSOC_DENIED_RATES || 1893 status_code == WLAN_STATUS_CAPS_UNSUPPORTED) && 1894 ((ieee->mode == IEEE_G) && 1895 (ieee->current_network.mode == IEEE_N_24G) && 1896 (ieee->AsocRetryCount++ < (RT_ASOC_RETRY_LIMIT-1)))) { 1897 ieee->pHTInfo->IOTAction |= HT_IOT_ACT_PURE_N_MODE; 1898 } else { 1899 ieee->AsocRetryCount = 0; 1900 } 1901 1902 return le16_to_cpu(response_head->status); 1903 } 1904 1905 void rtllib_rx_probe_rq(struct rtllib_device *ieee, struct sk_buff *skb) 1906 { 1907 u8 dest[ETH_ALEN]; 1908 1909 ieee->softmac_stats.rx_probe_rq++; 1910 if (probe_rq_parse(ieee, skb, dest) > 0) { 1911 ieee->softmac_stats.tx_probe_rs++; 1912 rtllib_resp_to_probe(ieee, dest); 1913 } 1914 } 1915 1916 static inline void rtllib_rx_auth_rq(struct rtllib_device *ieee, 1917 struct sk_buff *skb) 1918 { 1919 u8 dest[ETH_ALEN]; 1920 int status; 1921 1922 ieee->softmac_stats.rx_auth_rq++; 1923 1924 status = auth_rq_parse(ieee->dev, skb, dest); 1925 if (status != -1) 1926 rtllib_resp_to_auth(ieee, status, dest); 1927 } 1928 1929 static inline void rtllib_rx_assoc_rq(struct rtllib_device *ieee, 1930 struct sk_buff *skb) 1931 { 1932 u8 dest[ETH_ALEN]; 1933 1934 1935 ieee->softmac_stats.rx_ass_rq++; 1936 if (assoc_rq_parse(ieee->dev, skb, dest) != -1) 1937 rtllib_resp_to_assoc_rq(ieee, dest); 1938 1939 netdev_info(ieee->dev, "New client associated: %pM\n", dest); 1940 } 1941 1942 void rtllib_sta_ps_send_null_frame(struct rtllib_device *ieee, short pwr) 1943 { 1944 1945 struct sk_buff *buf = rtllib_null_func(ieee, pwr); 1946 1947 if (buf) 1948 softmac_ps_mgmt_xmit(buf, ieee); 1949 } 1950 EXPORT_SYMBOL(rtllib_sta_ps_send_null_frame); 1951 1952 void rtllib_sta_ps_send_pspoll_frame(struct rtllib_device *ieee) 1953 { 1954 struct sk_buff *buf = rtllib_pspoll_func(ieee); 1955 1956 if (buf) 1957 softmac_ps_mgmt_xmit(buf, ieee); 1958 } 1959 1960 static short rtllib_sta_ps_sleep(struct rtllib_device *ieee, u64 *time) 1961 { 1962 int timeout; 1963 u8 dtim; 1964 struct rt_pwr_save_ctrl *pPSC = &(ieee->PowerSaveControl); 1965 1966 if (ieee->LPSDelayCnt) { 1967 ieee->LPSDelayCnt--; 1968 return 0; 1969 } 1970 1971 dtim = ieee->current_network.dtim_data; 1972 if (!(dtim & RTLLIB_DTIM_VALID)) 1973 return 0; 1974 timeout = ieee->current_network.beacon_interval; 1975 ieee->current_network.dtim_data = RTLLIB_DTIM_INVALID; 1976 /* there's no need to nofity AP that I find you buffered 1977 * with broadcast packet 1978 */ 1979 if (dtim & (RTLLIB_DTIM_UCAST & ieee->ps)) 1980 return 2; 1981 1982 if (!time_after(jiffies, 1983 dev_trans_start(ieee->dev) + msecs_to_jiffies(timeout))) 1984 return 0; 1985 if (!time_after(jiffies, 1986 ieee->last_rx_ps_time + msecs_to_jiffies(timeout))) 1987 return 0; 1988 if ((ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE) && 1989 (ieee->mgmt_queue_tail != ieee->mgmt_queue_head)) 1990 return 0; 1991 1992 if (time) { 1993 if (ieee->bAwakePktSent) { 1994 pPSC->LPSAwakeIntvl = 1; 1995 } else { 1996 u8 MaxPeriod = 1; 1997 1998 if (pPSC->LPSAwakeIntvl == 0) 1999 pPSC->LPSAwakeIntvl = 1; 2000 if (pPSC->RegMaxLPSAwakeIntvl == 0) 2001 MaxPeriod = 1; 2002 else if (pPSC->RegMaxLPSAwakeIntvl == 0xFF) 2003 MaxPeriod = ieee->current_network.dtim_period; 2004 else 2005 MaxPeriod = pPSC->RegMaxLPSAwakeIntvl; 2006 pPSC->LPSAwakeIntvl = (pPSC->LPSAwakeIntvl >= 2007 MaxPeriod) ? MaxPeriod : 2008 (pPSC->LPSAwakeIntvl + 1); 2009 } 2010 { 2011 u8 LPSAwakeIntvl_tmp = 0; 2012 u8 period = ieee->current_network.dtim_period; 2013 u8 count = ieee->current_network.tim.tim_count; 2014 2015 if (count == 0) { 2016 if (pPSC->LPSAwakeIntvl > period) 2017 LPSAwakeIntvl_tmp = period + 2018 (pPSC->LPSAwakeIntvl - 2019 period) - 2020 ((pPSC->LPSAwakeIntvl-period) % 2021 period); 2022 else 2023 LPSAwakeIntvl_tmp = pPSC->LPSAwakeIntvl; 2024 2025 } else { 2026 if (pPSC->LPSAwakeIntvl > 2027 ieee->current_network.tim.tim_count) 2028 LPSAwakeIntvl_tmp = count + 2029 (pPSC->LPSAwakeIntvl - count) - 2030 ((pPSC->LPSAwakeIntvl-count)%period); 2031 else 2032 LPSAwakeIntvl_tmp = pPSC->LPSAwakeIntvl; 2033 } 2034 2035 *time = ieee->current_network.last_dtim_sta_time 2036 + msecs_to_jiffies(ieee->current_network.beacon_interval * 2037 LPSAwakeIntvl_tmp); 2038 } 2039 } 2040 2041 return 1; 2042 2043 2044 } 2045 2046 static inline void rtllib_sta_ps(struct tasklet_struct *t) 2047 { 2048 struct rtllib_device *ieee = from_tasklet(ieee, t, ps_task); 2049 u64 time; 2050 short sleep; 2051 unsigned long flags, flags2; 2052 2053 spin_lock_irqsave(&ieee->lock, flags); 2054 2055 if ((ieee->ps == RTLLIB_PS_DISABLED || 2056 ieee->iw_mode != IW_MODE_INFRA || 2057 ieee->state != RTLLIB_LINKED)) { 2058 RT_TRACE(COMP_DBG, 2059 "=====>%s(): no need to ps,wake up!! ieee->ps is %d, ieee->iw_mode is %d, ieee->state is %d\n", 2060 __func__, ieee->ps, ieee->iw_mode, ieee->state); 2061 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2); 2062 rtllib_sta_wakeup(ieee, 1); 2063 2064 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2); 2065 } 2066 sleep = rtllib_sta_ps_sleep(ieee, &time); 2067 /* 2 wake, 1 sleep, 0 do nothing */ 2068 if (sleep == 0) 2069 goto out; 2070 if (sleep == 1) { 2071 if (ieee->sta_sleep == LPS_IS_SLEEP) { 2072 ieee->enter_sleep_state(ieee->dev, time); 2073 } else if (ieee->sta_sleep == LPS_IS_WAKE) { 2074 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2); 2075 2076 if (ieee->ps_is_queue_empty(ieee->dev)) { 2077 ieee->sta_sleep = LPS_WAIT_NULL_DATA_SEND; 2078 ieee->ack_tx_to_ieee = 1; 2079 rtllib_sta_ps_send_null_frame(ieee, 1); 2080 ieee->ps_time = time; 2081 } 2082 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2); 2083 2084 } 2085 2086 ieee->bAwakePktSent = false; 2087 2088 } else if (sleep == 2) { 2089 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2); 2090 2091 rtllib_sta_wakeup(ieee, 1); 2092 2093 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2); 2094 } 2095 2096 out: 2097 spin_unlock_irqrestore(&ieee->lock, flags); 2098 2099 } 2100 2101 static void rtllib_sta_wakeup(struct rtllib_device *ieee, short nl) 2102 { 2103 if (ieee->sta_sleep == LPS_IS_WAKE) { 2104 if (nl) { 2105 if (ieee->pHTInfo->IOTAction & 2106 HT_IOT_ACT_NULL_DATA_POWER_SAVING) { 2107 ieee->ack_tx_to_ieee = 1; 2108 rtllib_sta_ps_send_null_frame(ieee, 0); 2109 } else { 2110 ieee->ack_tx_to_ieee = 1; 2111 rtllib_sta_ps_send_pspoll_frame(ieee); 2112 } 2113 } 2114 return; 2115 2116 } 2117 2118 if (ieee->sta_sleep == LPS_IS_SLEEP) 2119 ieee->sta_wake_up(ieee->dev); 2120 if (nl) { 2121 if (ieee->pHTInfo->IOTAction & 2122 HT_IOT_ACT_NULL_DATA_POWER_SAVING) { 2123 ieee->ack_tx_to_ieee = 1; 2124 rtllib_sta_ps_send_null_frame(ieee, 0); 2125 } else { 2126 ieee->ack_tx_to_ieee = 1; 2127 ieee->polling = true; 2128 rtllib_sta_ps_send_pspoll_frame(ieee); 2129 } 2130 2131 } else { 2132 ieee->sta_sleep = LPS_IS_WAKE; 2133 ieee->polling = false; 2134 } 2135 } 2136 2137 void rtllib_ps_tx_ack(struct rtllib_device *ieee, short success) 2138 { 2139 unsigned long flags, flags2; 2140 2141 spin_lock_irqsave(&ieee->lock, flags); 2142 2143 if (ieee->sta_sleep == LPS_WAIT_NULL_DATA_SEND) { 2144 /* Null frame with PS bit set */ 2145 if (success) { 2146 ieee->sta_sleep = LPS_IS_SLEEP; 2147 ieee->enter_sleep_state(ieee->dev, ieee->ps_time); 2148 } 2149 /* if the card report not success we can't be sure the AP 2150 * has not RXed so we can't assume the AP believe us awake 2151 */ 2152 } else {/* 21112005 - tx again null without PS bit if lost */ 2153 2154 if ((ieee->sta_sleep == LPS_IS_WAKE) && !success) { 2155 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2); 2156 if (ieee->pHTInfo->IOTAction & 2157 HT_IOT_ACT_NULL_DATA_POWER_SAVING) 2158 rtllib_sta_ps_send_null_frame(ieee, 0); 2159 else 2160 rtllib_sta_ps_send_pspoll_frame(ieee); 2161 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2); 2162 } 2163 } 2164 spin_unlock_irqrestore(&ieee->lock, flags); 2165 } 2166 EXPORT_SYMBOL(rtllib_ps_tx_ack); 2167 2168 static void rtllib_process_action(struct rtllib_device *ieee, 2169 struct sk_buff *skb) 2170 { 2171 struct rtllib_hdr_3addr *header = (struct rtllib_hdr_3addr *) skb->data; 2172 u8 *act = rtllib_get_payload((struct rtllib_hdr *)header); 2173 u8 category = 0; 2174 2175 if (act == NULL) { 2176 netdev_warn(ieee->dev, 2177 "Error getting payload of action frame\n"); 2178 return; 2179 } 2180 2181 category = *act; 2182 act++; 2183 switch (category) { 2184 case ACT_CAT_BA: 2185 switch (*act) { 2186 case ACT_ADDBAREQ: 2187 rtllib_rx_ADDBAReq(ieee, skb); 2188 break; 2189 case ACT_ADDBARSP: 2190 rtllib_rx_ADDBARsp(ieee, skb); 2191 break; 2192 case ACT_DELBA: 2193 rtllib_rx_DELBA(ieee, skb); 2194 break; 2195 } 2196 break; 2197 default: 2198 break; 2199 } 2200 } 2201 2202 static inline int 2203 rtllib_rx_assoc_resp(struct rtllib_device *ieee, struct sk_buff *skb, 2204 struct rtllib_rx_stats *rx_stats) 2205 { 2206 u16 errcode; 2207 int aid; 2208 u8 *ies; 2209 struct rtllib_assoc_response_frame *assoc_resp; 2210 struct rtllib_hdr_3addr *header = (struct rtllib_hdr_3addr *) skb->data; 2211 u16 frame_ctl = le16_to_cpu(header->frame_ctl); 2212 2213 netdev_dbg(ieee->dev, "received [RE]ASSOCIATION RESPONSE (%d)\n", 2214 WLAN_FC_GET_STYPE(frame_ctl)); 2215 2216 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) && 2217 ieee->state == RTLLIB_ASSOCIATING_AUTHENTICATED && 2218 (ieee->iw_mode == IW_MODE_INFRA)) { 2219 errcode = assoc_parse(ieee, skb, &aid); 2220 if (!errcode) { 2221 struct rtllib_network *network = 2222 kzalloc(sizeof(struct rtllib_network), 2223 GFP_ATOMIC); 2224 2225 if (!network) 2226 return 1; 2227 ieee->state = RTLLIB_LINKED; 2228 ieee->assoc_id = aid; 2229 ieee->softmac_stats.rx_ass_ok++; 2230 /* station support qos */ 2231 /* Let the register setting default with Legacy station */ 2232 assoc_resp = (struct rtllib_assoc_response_frame *)skb->data; 2233 if (ieee->current_network.qos_data.supported == 1) { 2234 if (rtllib_parse_info_param(ieee, assoc_resp->info_element, 2235 rx_stats->len - sizeof(*assoc_resp), 2236 network, rx_stats)) { 2237 kfree(network); 2238 return 1; 2239 } 2240 memcpy(ieee->pHTInfo->PeerHTCapBuf, 2241 network->bssht.bdHTCapBuf, 2242 network->bssht.bdHTCapLen); 2243 memcpy(ieee->pHTInfo->PeerHTInfoBuf, 2244 network->bssht.bdHTInfoBuf, 2245 network->bssht.bdHTInfoLen); 2246 if (ieee->handle_assoc_response != NULL) 2247 ieee->handle_assoc_response(ieee->dev, 2248 (struct rtllib_assoc_response_frame *)header, 2249 network); 2250 } 2251 kfree(network); 2252 2253 kfree(ieee->assocresp_ies); 2254 ieee->assocresp_ies = NULL; 2255 ies = &(assoc_resp->info_element[0].id); 2256 ieee->assocresp_ies_len = (skb->data + skb->len) - ies; 2257 ieee->assocresp_ies = kmemdup(ies, 2258 ieee->assocresp_ies_len, 2259 GFP_ATOMIC); 2260 if (!ieee->assocresp_ies) 2261 ieee->assocresp_ies_len = 0; 2262 2263 rtllib_associate_complete(ieee); 2264 } else { 2265 /* aid could not been allocated */ 2266 ieee->softmac_stats.rx_ass_err++; 2267 netdev_info(ieee->dev, 2268 "Association response status code 0x%x\n", 2269 errcode); 2270 if (ieee->AsocRetryCount < RT_ASOC_RETRY_LIMIT) 2271 schedule_delayed_work( 2272 &ieee->associate_procedure_wq, 0); 2273 else 2274 rtllib_associate_abort(ieee); 2275 } 2276 } 2277 return 0; 2278 } 2279 2280 static void rtllib_rx_auth_resp(struct rtllib_device *ieee, struct sk_buff *skb) 2281 { 2282 u16 errcode; 2283 u8 *challenge; 2284 int chlen = 0; 2285 bool bSupportNmode = true, bHalfSupportNmode = false; 2286 2287 errcode = auth_parse(ieee->dev, skb, &challenge, &chlen); 2288 2289 if (errcode) { 2290 ieee->softmac_stats.rx_auth_rs_err++; 2291 netdev_info(ieee->dev, 2292 "Authentication response status code 0x%x", 2293 errcode); 2294 rtllib_associate_abort(ieee); 2295 return; 2296 } 2297 2298 if (ieee->open_wep || !challenge) { 2299 ieee->state = RTLLIB_ASSOCIATING_AUTHENTICATED; 2300 ieee->softmac_stats.rx_auth_rs_ok++; 2301 if (!(ieee->pHTInfo->IOTAction & HT_IOT_ACT_PURE_N_MODE)) { 2302 if (!ieee->GetNmodeSupportBySecCfg(ieee->dev)) { 2303 if (IsHTHalfNmodeAPs(ieee)) { 2304 bSupportNmode = true; 2305 bHalfSupportNmode = true; 2306 } else { 2307 bSupportNmode = false; 2308 bHalfSupportNmode = false; 2309 } 2310 } 2311 } 2312 /* Dummy wirless mode setting to avoid encryption issue */ 2313 if (bSupportNmode) { 2314 ieee->SetWirelessMode(ieee->dev, 2315 ieee->current_network.mode); 2316 } else { 2317 /*TODO*/ 2318 ieee->SetWirelessMode(ieee->dev, IEEE_G); 2319 } 2320 2321 if ((ieee->current_network.mode == IEEE_N_24G) && 2322 bHalfSupportNmode) { 2323 netdev_info(ieee->dev, "======>enter half N mode\n"); 2324 ieee->bHalfWirelessN24GMode = true; 2325 } else { 2326 ieee->bHalfWirelessN24GMode = false; 2327 } 2328 rtllib_associate_step2(ieee); 2329 } else { 2330 rtllib_auth_challenge(ieee, challenge, chlen); 2331 } 2332 } 2333 2334 static inline int 2335 rtllib_rx_auth(struct rtllib_device *ieee, struct sk_buff *skb, 2336 struct rtllib_rx_stats *rx_stats) 2337 { 2338 2339 if (ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) { 2340 if (ieee->state == RTLLIB_ASSOCIATING_AUTHENTICATING && 2341 (ieee->iw_mode == IW_MODE_INFRA)) { 2342 netdev_dbg(ieee->dev, 2343 "Received authentication response"); 2344 rtllib_rx_auth_resp(ieee, skb); 2345 } else if (ieee->iw_mode == IW_MODE_MASTER) { 2346 rtllib_rx_auth_rq(ieee, skb); 2347 } 2348 } 2349 return 0; 2350 } 2351 2352 static inline int 2353 rtllib_rx_deauth(struct rtllib_device *ieee, struct sk_buff *skb) 2354 { 2355 struct rtllib_hdr_3addr *header = (struct rtllib_hdr_3addr *) skb->data; 2356 u16 frame_ctl; 2357 2358 if (memcmp(header->addr3, ieee->current_network.bssid, ETH_ALEN) != 0) 2359 return 0; 2360 2361 /* FIXME for now repeat all the association procedure 2362 * both for disassociation and deauthentication 2363 */ 2364 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) && 2365 ieee->state == RTLLIB_LINKED && 2366 (ieee->iw_mode == IW_MODE_INFRA)) { 2367 frame_ctl = le16_to_cpu(header->frame_ctl); 2368 netdev_info(ieee->dev, 2369 "==========>received disassoc/deauth(%x) frame, reason code:%x\n", 2370 WLAN_FC_GET_STYPE(frame_ctl), 2371 ((struct rtllib_disassoc *)skb->data)->reason); 2372 ieee->state = RTLLIB_ASSOCIATING; 2373 ieee->softmac_stats.reassoc++; 2374 ieee->is_roaming = true; 2375 ieee->LinkDetectInfo.bBusyTraffic = false; 2376 rtllib_disassociate(ieee); 2377 RemovePeerTS(ieee, header->addr2); 2378 if (ieee->LedControlHandler != NULL) 2379 ieee->LedControlHandler(ieee->dev, 2380 LED_CTL_START_TO_LINK); 2381 2382 if (!(ieee->rtllib_ap_sec_type(ieee) & 2383 (SEC_ALG_CCMP|SEC_ALG_TKIP))) 2384 schedule_delayed_work( 2385 &ieee->associate_procedure_wq, 5); 2386 } 2387 return 0; 2388 } 2389 2390 inline int rtllib_rx_frame_softmac(struct rtllib_device *ieee, 2391 struct sk_buff *skb, 2392 struct rtllib_rx_stats *rx_stats, u16 type, 2393 u16 stype) 2394 { 2395 struct rtllib_hdr_3addr *header = (struct rtllib_hdr_3addr *) skb->data; 2396 u16 frame_ctl; 2397 2398 if (!ieee->proto_started) 2399 return 0; 2400 2401 frame_ctl = le16_to_cpu(header->frame_ctl); 2402 switch (WLAN_FC_GET_STYPE(frame_ctl)) { 2403 case RTLLIB_STYPE_ASSOC_RESP: 2404 case RTLLIB_STYPE_REASSOC_RESP: 2405 if (rtllib_rx_assoc_resp(ieee, skb, rx_stats) == 1) 2406 return 1; 2407 break; 2408 case RTLLIB_STYPE_ASSOC_REQ: 2409 case RTLLIB_STYPE_REASSOC_REQ: 2410 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) && 2411 ieee->iw_mode == IW_MODE_MASTER) 2412 rtllib_rx_assoc_rq(ieee, skb); 2413 break; 2414 case RTLLIB_STYPE_AUTH: 2415 rtllib_rx_auth(ieee, skb, rx_stats); 2416 break; 2417 case RTLLIB_STYPE_DISASSOC: 2418 case RTLLIB_STYPE_DEAUTH: 2419 rtllib_rx_deauth(ieee, skb); 2420 break; 2421 case RTLLIB_STYPE_MANAGE_ACT: 2422 rtllib_process_action(ieee, skb); 2423 break; 2424 default: 2425 return -1; 2426 } 2427 return 0; 2428 } 2429 2430 /* following are for a simpler TX queue management. 2431 * Instead of using netif_[stop/wake]_queue the driver 2432 * will use these two functions (plus a reset one), that 2433 * will internally use the kernel netif_* and takes 2434 * care of the ieee802.11 fragmentation. 2435 * So the driver receives a fragment per time and might 2436 * call the stop function when it wants to not 2437 * have enough room to TX an entire packet. 2438 * This might be useful if each fragment needs it's own 2439 * descriptor, thus just keep a total free memory > than 2440 * the max fragmentation threshold is not enough.. If the 2441 * ieee802.11 stack passed a TXB struct then you need 2442 * to keep N free descriptors where 2443 * N = MAX_PACKET_SIZE / MIN_FRAG_TRESHOLD 2444 * In this way you need just one and the 802.11 stack 2445 * will take care of buffering fragments and pass them to 2446 * to the driver later, when it wakes the queue. 2447 */ 2448 void rtllib_softmac_xmit(struct rtllib_txb *txb, struct rtllib_device *ieee) 2449 { 2450 2451 unsigned int queue_index = txb->queue_index; 2452 unsigned long flags; 2453 int i; 2454 struct cb_desc *tcb_desc = NULL; 2455 unsigned long queue_len = 0; 2456 2457 spin_lock_irqsave(&ieee->lock, flags); 2458 2459 /* called with 2nd parm 0, no tx mgmt lock required */ 2460 rtllib_sta_wakeup(ieee, 0); 2461 2462 /* update the tx status */ 2463 tcb_desc = (struct cb_desc *)(txb->fragments[0]->cb + 2464 MAX_DEV_ADDR_SIZE); 2465 if (tcb_desc->bMulticast) 2466 ieee->stats.multicast++; 2467 2468 /* if xmit available, just xmit it immediately, else just insert it to 2469 * the wait queue 2470 */ 2471 for (i = 0; i < txb->nr_frags; i++) { 2472 queue_len = skb_queue_len(&ieee->skb_waitQ[queue_index]); 2473 if ((queue_len != 0) || 2474 (!ieee->check_nic_enough_desc(ieee->dev, queue_index)) || 2475 (ieee->queue_stop)) { 2476 /* insert the skb packet to the wait queue 2477 * as for the completion function, it does not need 2478 * to check it any more. 2479 */ 2480 if (queue_len < 200) 2481 skb_queue_tail(&ieee->skb_waitQ[queue_index], 2482 txb->fragments[i]); 2483 else 2484 kfree_skb(txb->fragments[i]); 2485 } else { 2486 ieee->softmac_data_hard_start_xmit( 2487 txb->fragments[i], 2488 ieee->dev, ieee->rate); 2489 } 2490 } 2491 2492 rtllib_txb_free(txb); 2493 2494 spin_unlock_irqrestore(&ieee->lock, flags); 2495 2496 } 2497 2498 void rtllib_reset_queue(struct rtllib_device *ieee) 2499 { 2500 unsigned long flags; 2501 2502 spin_lock_irqsave(&ieee->lock, flags); 2503 init_mgmt_queue(ieee); 2504 if (ieee->tx_pending.txb) { 2505 rtllib_txb_free(ieee->tx_pending.txb); 2506 ieee->tx_pending.txb = NULL; 2507 } 2508 ieee->queue_stop = 0; 2509 spin_unlock_irqrestore(&ieee->lock, flags); 2510 2511 } 2512 EXPORT_SYMBOL(rtllib_reset_queue); 2513 2514 void rtllib_stop_all_queues(struct rtllib_device *ieee) 2515 { 2516 unsigned int i; 2517 2518 for (i = 0; i < ieee->dev->num_tx_queues; i++) 2519 netdev_get_tx_queue(ieee->dev, i)->trans_start = jiffies; 2520 2521 netif_tx_stop_all_queues(ieee->dev); 2522 } 2523 2524 void rtllib_wake_all_queues(struct rtllib_device *ieee) 2525 { 2526 netif_tx_wake_all_queues(ieee->dev); 2527 } 2528 2529 /* called in user context only */ 2530 static void rtllib_start_master_bss(struct rtllib_device *ieee) 2531 { 2532 ieee->assoc_id = 1; 2533 2534 if (ieee->current_network.ssid_len == 0) { 2535 strncpy(ieee->current_network.ssid, 2536 RTLLIB_DEFAULT_TX_ESSID, 2537 IW_ESSID_MAX_SIZE); 2538 2539 ieee->current_network.ssid_len = 2540 strlen(RTLLIB_DEFAULT_TX_ESSID); 2541 ieee->ssid_set = 1; 2542 } 2543 2544 ether_addr_copy(ieee->current_network.bssid, ieee->dev->dev_addr); 2545 2546 ieee->set_chan(ieee->dev, ieee->current_network.channel); 2547 ieee->state = RTLLIB_LINKED; 2548 ieee->link_change(ieee->dev); 2549 notify_wx_assoc_event(ieee); 2550 2551 if (ieee->data_hard_resume) 2552 ieee->data_hard_resume(ieee->dev); 2553 2554 netif_carrier_on(ieee->dev); 2555 } 2556 2557 static void rtllib_start_monitor_mode(struct rtllib_device *ieee) 2558 { 2559 /* reset hardware status */ 2560 if (ieee->raw_tx) { 2561 if (ieee->data_hard_resume) 2562 ieee->data_hard_resume(ieee->dev); 2563 2564 netif_carrier_on(ieee->dev); 2565 } 2566 } 2567 2568 static void rtllib_start_ibss_wq(void *data) 2569 { 2570 struct rtllib_device *ieee = container_of_dwork_rsl(data, 2571 struct rtllib_device, start_ibss_wq); 2572 /* iwconfig mode ad-hoc will schedule this and return 2573 * on the other hand this will block further iwconfig SET 2574 * operations because of the wx_mutex hold. 2575 * Anyway some most set operations set a flag to speed-up 2576 * (abort) this wq (when syncro scanning) before sleeping 2577 * on the mutex 2578 */ 2579 if (!ieee->proto_started) { 2580 netdev_info(ieee->dev, "==========oh driver down return\n"); 2581 return; 2582 } 2583 mutex_lock(&ieee->wx_mutex); 2584 2585 if (ieee->current_network.ssid_len == 0) { 2586 strcpy(ieee->current_network.ssid, RTLLIB_DEFAULT_TX_ESSID); 2587 ieee->current_network.ssid_len = strlen(RTLLIB_DEFAULT_TX_ESSID); 2588 ieee->ssid_set = 1; 2589 } 2590 2591 ieee->state = RTLLIB_NOLINK; 2592 ieee->mode = IEEE_G; 2593 /* check if we have this cell in our network list */ 2594 rtllib_softmac_check_all_nets(ieee); 2595 2596 2597 /* if not then the state is not linked. Maybe the user switched to 2598 * ad-hoc mode just after being in monitor mode, or just after 2599 * being very few time in managed mode (so the card have had no 2600 * time to scan all the chans..) or we have just run up the iface 2601 * after setting ad-hoc mode. So we have to give another try.. 2602 * Here, in ibss mode, should be safe to do this without extra care 2603 * (in bss mode we had to make sure no-one tried to associate when 2604 * we had just checked the ieee->state and we was going to start the 2605 * scan) because in ibss mode the rtllib_new_net function, when 2606 * finds a good net, just set the ieee->state to RTLLIB_LINKED, 2607 * so, at worst, we waste a bit of time to initiate an unneeded syncro 2608 * scan, that will stop at the first round because it sees the state 2609 * associated. 2610 */ 2611 if (ieee->state == RTLLIB_NOLINK) 2612 rtllib_start_scan_syncro(ieee, 0); 2613 2614 /* the network definitively is not here.. create a new cell */ 2615 if (ieee->state == RTLLIB_NOLINK) { 2616 netdev_info(ieee->dev, "creating new IBSS cell\n"); 2617 ieee->current_network.channel = ieee->bss_start_channel; 2618 if (!ieee->wap_set) 2619 eth_random_addr(ieee->current_network.bssid); 2620 2621 if (ieee->modulation & RTLLIB_CCK_MODULATION) { 2622 2623 ieee->current_network.rates_len = 4; 2624 2625 ieee->current_network.rates[0] = 2626 RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_1MB; 2627 ieee->current_network.rates[1] = 2628 RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_2MB; 2629 ieee->current_network.rates[2] = 2630 RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_5MB; 2631 ieee->current_network.rates[3] = 2632 RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_11MB; 2633 2634 } else 2635 ieee->current_network.rates_len = 0; 2636 2637 if (ieee->modulation & RTLLIB_OFDM_MODULATION) { 2638 ieee->current_network.rates_ex_len = 8; 2639 2640 ieee->current_network.rates_ex[0] = 2641 RTLLIB_OFDM_RATE_6MB; 2642 ieee->current_network.rates_ex[1] = 2643 RTLLIB_OFDM_RATE_9MB; 2644 ieee->current_network.rates_ex[2] = 2645 RTLLIB_OFDM_RATE_12MB; 2646 ieee->current_network.rates_ex[3] = 2647 RTLLIB_OFDM_RATE_18MB; 2648 ieee->current_network.rates_ex[4] = 2649 RTLLIB_OFDM_RATE_24MB; 2650 ieee->current_network.rates_ex[5] = 2651 RTLLIB_OFDM_RATE_36MB; 2652 ieee->current_network.rates_ex[6] = 2653 RTLLIB_OFDM_RATE_48MB; 2654 ieee->current_network.rates_ex[7] = 2655 RTLLIB_OFDM_RATE_54MB; 2656 2657 ieee->rate = 108; 2658 } else { 2659 ieee->current_network.rates_ex_len = 0; 2660 ieee->rate = 22; 2661 } 2662 2663 ieee->current_network.qos_data.supported = 0; 2664 ieee->SetWirelessMode(ieee->dev, IEEE_G); 2665 ieee->current_network.mode = ieee->mode; 2666 ieee->current_network.atim_window = 0; 2667 ieee->current_network.capability = WLAN_CAPABILITY_IBSS; 2668 } 2669 2670 netdev_info(ieee->dev, "%s(): ieee->mode = %d\n", __func__, ieee->mode); 2671 if ((ieee->mode == IEEE_N_24G) || (ieee->mode == IEEE_N_5G)) 2672 HTUseDefaultSetting(ieee); 2673 else 2674 ieee->pHTInfo->bCurrentHTSupport = false; 2675 2676 ieee->SetHwRegHandler(ieee->dev, HW_VAR_MEDIA_STATUS, 2677 (u8 *)(&ieee->state)); 2678 2679 ieee->state = RTLLIB_LINKED; 2680 ieee->link_change(ieee->dev); 2681 2682 HTSetConnectBwMode(ieee, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT); 2683 if (ieee->LedControlHandler != NULL) 2684 ieee->LedControlHandler(ieee->dev, LED_CTL_LINK); 2685 2686 rtllib_start_send_beacons(ieee); 2687 2688 notify_wx_assoc_event(ieee); 2689 2690 if (ieee->data_hard_resume) 2691 ieee->data_hard_resume(ieee->dev); 2692 2693 netif_carrier_on(ieee->dev); 2694 2695 mutex_unlock(&ieee->wx_mutex); 2696 } 2697 2698 inline void rtllib_start_ibss(struct rtllib_device *ieee) 2699 { 2700 schedule_delayed_work(&ieee->start_ibss_wq, msecs_to_jiffies(150)); 2701 } 2702 2703 /* this is called only in user context, with wx_mutex held */ 2704 static void rtllib_start_bss(struct rtllib_device *ieee) 2705 { 2706 unsigned long flags; 2707 2708 if (IS_DOT11D_ENABLE(ieee) && !IS_COUNTRY_IE_VALID(ieee)) { 2709 if (!ieee->global_domain) 2710 return; 2711 } 2712 /* check if we have already found the net we 2713 * are interested in (if any). 2714 * if not (we are disassociated and we are not 2715 * in associating / authenticating phase) start the background scanning. 2716 */ 2717 rtllib_softmac_check_all_nets(ieee); 2718 2719 /* ensure no-one start an associating process (thus setting 2720 * the ieee->state to rtllib_ASSOCIATING) while we 2721 * have just checked it and we are going to enable scan. 2722 * The rtllib_new_net function is always called with 2723 * lock held (from both rtllib_softmac_check_all_nets and 2724 * the rx path), so we cannot be in the middle of such function 2725 */ 2726 spin_lock_irqsave(&ieee->lock, flags); 2727 2728 if (ieee->state == RTLLIB_NOLINK) 2729 rtllib_start_scan(ieee); 2730 spin_unlock_irqrestore(&ieee->lock, flags); 2731 } 2732 2733 static void rtllib_link_change_wq(void *data) 2734 { 2735 struct rtllib_device *ieee = container_of_dwork_rsl(data, 2736 struct rtllib_device, link_change_wq); 2737 ieee->link_change(ieee->dev); 2738 } 2739 /* called only in userspace context */ 2740 void rtllib_disassociate(struct rtllib_device *ieee) 2741 { 2742 netif_carrier_off(ieee->dev); 2743 if (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE) 2744 rtllib_reset_queue(ieee); 2745 2746 if (ieee->data_hard_stop) 2747 ieee->data_hard_stop(ieee->dev); 2748 if (IS_DOT11D_ENABLE(ieee)) 2749 dot11d_reset(ieee); 2750 ieee->state = RTLLIB_NOLINK; 2751 ieee->is_set_key = false; 2752 ieee->wap_set = 0; 2753 2754 schedule_delayed_work(&ieee->link_change_wq, 0); 2755 2756 notify_wx_assoc_event(ieee); 2757 } 2758 2759 static void rtllib_associate_retry_wq(void *data) 2760 { 2761 struct rtllib_device *ieee = container_of_dwork_rsl(data, 2762 struct rtllib_device, associate_retry_wq); 2763 unsigned long flags; 2764 2765 mutex_lock(&ieee->wx_mutex); 2766 if (!ieee->proto_started) 2767 goto exit; 2768 2769 if (ieee->state != RTLLIB_ASSOCIATING_RETRY) 2770 goto exit; 2771 2772 /* until we do not set the state to RTLLIB_NOLINK 2773 * there are no possibility to have someone else trying 2774 * to start an association procedure (we get here with 2775 * ieee->state = RTLLIB_ASSOCIATING). 2776 * When we set the state to RTLLIB_NOLINK it is possible 2777 * that the RX path run an attempt to associate, but 2778 * both rtllib_softmac_check_all_nets and the 2779 * RX path works with ieee->lock held so there are no 2780 * problems. If we are still disassociated then start a scan. 2781 * the lock here is necessary to ensure no one try to start 2782 * an association procedure when we have just checked the 2783 * state and we are going to start the scan. 2784 */ 2785 ieee->beinretry = true; 2786 ieee->state = RTLLIB_NOLINK; 2787 2788 rtllib_softmac_check_all_nets(ieee); 2789 2790 spin_lock_irqsave(&ieee->lock, flags); 2791 2792 if (ieee->state == RTLLIB_NOLINK) 2793 rtllib_start_scan(ieee); 2794 spin_unlock_irqrestore(&ieee->lock, flags); 2795 2796 ieee->beinretry = false; 2797 exit: 2798 mutex_unlock(&ieee->wx_mutex); 2799 } 2800 2801 static struct sk_buff *rtllib_get_beacon_(struct rtllib_device *ieee) 2802 { 2803 static const u8 broadcast_addr[] = { 2804 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 2805 }; 2806 struct sk_buff *skb; 2807 struct rtllib_probe_response *b; 2808 2809 skb = rtllib_probe_resp(ieee, broadcast_addr); 2810 2811 if (!skb) 2812 return NULL; 2813 2814 b = (struct rtllib_probe_response *) skb->data; 2815 b->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_BEACON); 2816 2817 return skb; 2818 2819 } 2820 2821 struct sk_buff *rtllib_get_beacon(struct rtllib_device *ieee) 2822 { 2823 struct sk_buff *skb; 2824 struct rtllib_probe_response *b; 2825 2826 skb = rtllib_get_beacon_(ieee); 2827 if (!skb) 2828 return NULL; 2829 2830 b = (struct rtllib_probe_response *) skb->data; 2831 b->header.seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4); 2832 2833 if (ieee->seq_ctrl[0] == 0xFFF) 2834 ieee->seq_ctrl[0] = 0; 2835 else 2836 ieee->seq_ctrl[0]++; 2837 2838 return skb; 2839 } 2840 EXPORT_SYMBOL(rtllib_get_beacon); 2841 2842 void rtllib_softmac_stop_protocol(struct rtllib_device *ieee, u8 mesh_flag, 2843 u8 shutdown) 2844 { 2845 rtllib_stop_scan_syncro(ieee); 2846 mutex_lock(&ieee->wx_mutex); 2847 rtllib_stop_protocol(ieee, shutdown); 2848 mutex_unlock(&ieee->wx_mutex); 2849 } 2850 EXPORT_SYMBOL(rtllib_softmac_stop_protocol); 2851 2852 2853 void rtllib_stop_protocol(struct rtllib_device *ieee, u8 shutdown) 2854 { 2855 if (!ieee->proto_started) 2856 return; 2857 2858 if (shutdown) { 2859 ieee->proto_started = 0; 2860 ieee->proto_stoppping = 1; 2861 if (ieee->rtllib_ips_leave != NULL) 2862 ieee->rtllib_ips_leave(ieee->dev); 2863 } 2864 2865 rtllib_stop_send_beacons(ieee); 2866 del_timer_sync(&ieee->associate_timer); 2867 cancel_delayed_work_sync(&ieee->associate_retry_wq); 2868 cancel_delayed_work_sync(&ieee->start_ibss_wq); 2869 cancel_delayed_work_sync(&ieee->link_change_wq); 2870 rtllib_stop_scan(ieee); 2871 2872 if (ieee->state <= RTLLIB_ASSOCIATING_AUTHENTICATED) 2873 ieee->state = RTLLIB_NOLINK; 2874 2875 if (ieee->state == RTLLIB_LINKED) { 2876 if (ieee->iw_mode == IW_MODE_INFRA) 2877 SendDisassociation(ieee, 1, WLAN_REASON_DEAUTH_LEAVING); 2878 rtllib_disassociate(ieee); 2879 } 2880 2881 if (shutdown) { 2882 RemoveAllTS(ieee); 2883 ieee->proto_stoppping = 0; 2884 } 2885 kfree(ieee->assocreq_ies); 2886 ieee->assocreq_ies = NULL; 2887 ieee->assocreq_ies_len = 0; 2888 kfree(ieee->assocresp_ies); 2889 ieee->assocresp_ies = NULL; 2890 ieee->assocresp_ies_len = 0; 2891 } 2892 2893 void rtllib_softmac_start_protocol(struct rtllib_device *ieee, u8 mesh_flag) 2894 { 2895 mutex_lock(&ieee->wx_mutex); 2896 rtllib_start_protocol(ieee); 2897 mutex_unlock(&ieee->wx_mutex); 2898 } 2899 EXPORT_SYMBOL(rtllib_softmac_start_protocol); 2900 2901 void rtllib_start_protocol(struct rtllib_device *ieee) 2902 { 2903 short ch = 0; 2904 int i = 0; 2905 2906 rtllib_update_active_chan_map(ieee); 2907 2908 if (ieee->proto_started) 2909 return; 2910 2911 ieee->proto_started = 1; 2912 2913 if (ieee->current_network.channel == 0) { 2914 do { 2915 ch++; 2916 if (ch > MAX_CHANNEL_NUMBER) 2917 return; /* no channel found */ 2918 } while (!ieee->active_channel_map[ch]); 2919 ieee->current_network.channel = ch; 2920 } 2921 2922 if (ieee->current_network.beacon_interval == 0) 2923 ieee->current_network.beacon_interval = 100; 2924 2925 for (i = 0; i < 17; i++) { 2926 ieee->last_rxseq_num[i] = -1; 2927 ieee->last_rxfrag_num[i] = -1; 2928 ieee->last_packet_time[i] = 0; 2929 } 2930 2931 if (ieee->UpdateBeaconInterruptHandler) 2932 ieee->UpdateBeaconInterruptHandler(ieee->dev, false); 2933 2934 ieee->wmm_acm = 0; 2935 /* if the user set the MAC of the ad-hoc cell and then 2936 * switch to managed mode, shall we make sure that association 2937 * attempts does not fail just because the user provide the essid 2938 * and the nic is still checking for the AP MAC ?? 2939 */ 2940 if (ieee->iw_mode == IW_MODE_INFRA) { 2941 rtllib_start_bss(ieee); 2942 } else if (ieee->iw_mode == IW_MODE_ADHOC) { 2943 if (ieee->UpdateBeaconInterruptHandler) 2944 ieee->UpdateBeaconInterruptHandler(ieee->dev, true); 2945 2946 rtllib_start_ibss(ieee); 2947 2948 } else if (ieee->iw_mode == IW_MODE_MASTER) { 2949 rtllib_start_master_bss(ieee); 2950 } else if (ieee->iw_mode == IW_MODE_MONITOR) { 2951 rtllib_start_monitor_mode(ieee); 2952 } 2953 } 2954 2955 void rtllib_softmac_init(struct rtllib_device *ieee) 2956 { 2957 int i; 2958 2959 memset(&ieee->current_network, 0, sizeof(struct rtllib_network)); 2960 2961 ieee->state = RTLLIB_NOLINK; 2962 for (i = 0; i < 5; i++) 2963 ieee->seq_ctrl[i] = 0; 2964 ieee->dot11d_info = kzalloc(sizeof(struct rt_dot11d_info), GFP_ATOMIC); 2965 if (!ieee->dot11d_info) 2966 netdev_err(ieee->dev, "Can't alloc memory for DOT11D\n"); 2967 ieee->LinkDetectInfo.SlotIndex = 0; 2968 ieee->LinkDetectInfo.SlotNum = 2; 2969 ieee->LinkDetectInfo.NumRecvBcnInPeriod = 0; 2970 ieee->LinkDetectInfo.NumRecvDataInPeriod = 0; 2971 ieee->LinkDetectInfo.NumTxOkInPeriod = 0; 2972 ieee->LinkDetectInfo.NumRxOkInPeriod = 0; 2973 ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0; 2974 ieee->bIsAggregateFrame = false; 2975 ieee->assoc_id = 0; 2976 ieee->queue_stop = 0; 2977 ieee->scanning_continue = 0; 2978 ieee->softmac_features = 0; 2979 ieee->wap_set = 0; 2980 ieee->ssid_set = 0; 2981 ieee->proto_started = 0; 2982 ieee->proto_stoppping = 0; 2983 ieee->basic_rate = RTLLIB_DEFAULT_BASIC_RATE; 2984 ieee->rate = 22; 2985 ieee->ps = RTLLIB_PS_DISABLED; 2986 ieee->sta_sleep = LPS_IS_WAKE; 2987 2988 ieee->Regdot11HTOperationalRateSet[0] = 0xff; 2989 ieee->Regdot11HTOperationalRateSet[1] = 0xff; 2990 ieee->Regdot11HTOperationalRateSet[4] = 0x01; 2991 2992 ieee->Regdot11TxHTOperationalRateSet[0] = 0xff; 2993 ieee->Regdot11TxHTOperationalRateSet[1] = 0xff; 2994 ieee->Regdot11TxHTOperationalRateSet[4] = 0x01; 2995 2996 ieee->FirstIe_InScan = false; 2997 ieee->actscanning = false; 2998 ieee->beinretry = false; 2999 ieee->is_set_key = false; 3000 init_mgmt_queue(ieee); 3001 3002 ieee->tx_pending.txb = NULL; 3003 3004 timer_setup(&ieee->associate_timer, rtllib_associate_abort_cb, 0); 3005 3006 timer_setup(&ieee->beacon_timer, rtllib_send_beacon_cb, 0); 3007 3008 INIT_DELAYED_WORK_RSL(&ieee->link_change_wq, 3009 (void *)rtllib_link_change_wq, ieee); 3010 INIT_DELAYED_WORK_RSL(&ieee->start_ibss_wq, 3011 (void *)rtllib_start_ibss_wq, ieee); 3012 INIT_WORK_RSL(&ieee->associate_complete_wq, 3013 (void *)rtllib_associate_complete_wq, ieee); 3014 INIT_DELAYED_WORK_RSL(&ieee->associate_procedure_wq, 3015 (void *)rtllib_associate_procedure_wq, ieee); 3016 INIT_DELAYED_WORK_RSL(&ieee->softmac_scan_wq, 3017 (void *)rtllib_softmac_scan_wq, ieee); 3018 INIT_DELAYED_WORK_RSL(&ieee->associate_retry_wq, 3019 (void *)rtllib_associate_retry_wq, ieee); 3020 INIT_WORK_RSL(&ieee->wx_sync_scan_wq, (void *)rtllib_wx_sync_scan_wq, 3021 ieee); 3022 3023 mutex_init(&ieee->wx_mutex); 3024 mutex_init(&ieee->scan_mutex); 3025 mutex_init(&ieee->ips_mutex); 3026 3027 spin_lock_init(&ieee->mgmt_tx_lock); 3028 spin_lock_init(&ieee->beacon_lock); 3029 3030 tasklet_setup(&ieee->ps_task, rtllib_sta_ps); 3031 3032 } 3033 3034 void rtllib_softmac_free(struct rtllib_device *ieee) 3035 { 3036 mutex_lock(&ieee->wx_mutex); 3037 kfree(ieee->dot11d_info); 3038 ieee->dot11d_info = NULL; 3039 del_timer_sync(&ieee->associate_timer); 3040 3041 cancel_delayed_work_sync(&ieee->associate_retry_wq); 3042 cancel_delayed_work_sync(&ieee->associate_procedure_wq); 3043 cancel_delayed_work_sync(&ieee->softmac_scan_wq); 3044 cancel_delayed_work_sync(&ieee->start_ibss_wq); 3045 cancel_delayed_work_sync(&ieee->hw_wakeup_wq); 3046 cancel_delayed_work_sync(&ieee->hw_sleep_wq); 3047 cancel_delayed_work_sync(&ieee->link_change_wq); 3048 cancel_work_sync(&ieee->associate_complete_wq); 3049 cancel_work_sync(&ieee->ips_leave_wq); 3050 cancel_work_sync(&ieee->wx_sync_scan_wq); 3051 mutex_unlock(&ieee->wx_mutex); 3052 tasklet_kill(&ieee->ps_task); 3053 } 3054 3055 static inline struct sk_buff * 3056 rtllib_disauth_skb(struct rtllib_network *beacon, 3057 struct rtllib_device *ieee, u16 asRsn) 3058 { 3059 struct sk_buff *skb; 3060 struct rtllib_disauth *disauth; 3061 int len = sizeof(struct rtllib_disauth) + ieee->tx_headroom; 3062 3063 skb = dev_alloc_skb(len); 3064 if (!skb) 3065 return NULL; 3066 3067 skb_reserve(skb, ieee->tx_headroom); 3068 3069 disauth = skb_put(skb, sizeof(struct rtllib_disauth)); 3070 disauth->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_DEAUTH); 3071 disauth->header.duration_id = 0; 3072 3073 ether_addr_copy(disauth->header.addr1, beacon->bssid); 3074 ether_addr_copy(disauth->header.addr2, ieee->dev->dev_addr); 3075 ether_addr_copy(disauth->header.addr3, beacon->bssid); 3076 3077 disauth->reason = cpu_to_le16(asRsn); 3078 return skb; 3079 } 3080 3081 static inline struct sk_buff * 3082 rtllib_disassociate_skb(struct rtllib_network *beacon, 3083 struct rtllib_device *ieee, u16 asRsn) 3084 { 3085 struct sk_buff *skb; 3086 struct rtllib_disassoc *disass; 3087 int len = sizeof(struct rtllib_disassoc) + ieee->tx_headroom; 3088 3089 skb = dev_alloc_skb(len); 3090 3091 if (!skb) 3092 return NULL; 3093 3094 skb_reserve(skb, ieee->tx_headroom); 3095 3096 disass = skb_put(skb, sizeof(struct rtllib_disassoc)); 3097 disass->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_DISASSOC); 3098 disass->header.duration_id = 0; 3099 3100 ether_addr_copy(disass->header.addr1, beacon->bssid); 3101 ether_addr_copy(disass->header.addr2, ieee->dev->dev_addr); 3102 ether_addr_copy(disass->header.addr3, beacon->bssid); 3103 3104 disass->reason = cpu_to_le16(asRsn); 3105 return skb; 3106 } 3107 3108 void SendDisassociation(struct rtllib_device *ieee, bool deauth, u16 asRsn) 3109 { 3110 struct rtllib_network *beacon = &ieee->current_network; 3111 struct sk_buff *skb; 3112 3113 if (deauth) 3114 skb = rtllib_disauth_skb(beacon, ieee, asRsn); 3115 else 3116 skb = rtllib_disassociate_skb(beacon, ieee, asRsn); 3117 3118 if (skb) 3119 softmac_mgmt_xmit(skb, ieee); 3120 } 3121 3122 u8 rtllib_ap_sec_type(struct rtllib_device *ieee) 3123 { 3124 static u8 ccmp_ie[4] = {0x00, 0x50, 0xf2, 0x04}; 3125 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04}; 3126 int wpa_ie_len = ieee->wpa_ie_len; 3127 struct lib80211_crypt_data *crypt; 3128 int encrypt; 3129 3130 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx]; 3131 encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY) 3132 || (ieee->host_encrypt && crypt && crypt->ops && 3133 (strcmp(crypt->ops->name, "R-WEP") == 0)); 3134 3135 /* simply judge */ 3136 if (encrypt && (wpa_ie_len == 0)) { 3137 return SEC_ALG_WEP; 3138 } else if ((wpa_ie_len != 0)) { 3139 if (((ieee->wpa_ie[0] == 0xdd) && 3140 (!memcmp(&(ieee->wpa_ie[14]), ccmp_ie, 4))) || 3141 ((ieee->wpa_ie[0] == 0x30) && 3142 (!memcmp(&ieee->wpa_ie[10], ccmp_rsn_ie, 4)))) 3143 return SEC_ALG_CCMP; 3144 else 3145 return SEC_ALG_TKIP; 3146 } else { 3147 return SEC_ALG_NONE; 3148 } 3149 } 3150 3151 static void rtllib_MgntDisconnectIBSS(struct rtllib_device *rtllib) 3152 { 3153 u8 OpMode; 3154 u8 i; 3155 bool bFilterOutNonAssociatedBSSID = false; 3156 3157 rtllib->state = RTLLIB_NOLINK; 3158 3159 for (i = 0; i < 6; i++) 3160 rtllib->current_network.bssid[i] = 0x55; 3161 3162 rtllib->OpMode = RT_OP_MODE_NO_LINK; 3163 rtllib->SetHwRegHandler(rtllib->dev, HW_VAR_BSSID, 3164 rtllib->current_network.bssid); 3165 OpMode = RT_OP_MODE_NO_LINK; 3166 rtllib->SetHwRegHandler(rtllib->dev, HW_VAR_MEDIA_STATUS, &OpMode); 3167 rtllib_stop_send_beacons(rtllib); 3168 3169 bFilterOutNonAssociatedBSSID = false; 3170 rtllib->SetHwRegHandler(rtllib->dev, HW_VAR_CECHK_BSSID, 3171 (u8 *)(&bFilterOutNonAssociatedBSSID)); 3172 notify_wx_assoc_event(rtllib); 3173 3174 } 3175 3176 static void rtllib_MlmeDisassociateRequest(struct rtllib_device *rtllib, 3177 u8 *asSta, u8 asRsn) 3178 { 3179 u8 i; 3180 u8 OpMode; 3181 3182 RemovePeerTS(rtllib, asSta); 3183 3184 if (memcmp(rtllib->current_network.bssid, asSta, 6) == 0) { 3185 rtllib->state = RTLLIB_NOLINK; 3186 3187 for (i = 0; i < 6; i++) 3188 rtllib->current_network.bssid[i] = 0x22; 3189 OpMode = RT_OP_MODE_NO_LINK; 3190 rtllib->OpMode = RT_OP_MODE_NO_LINK; 3191 rtllib->SetHwRegHandler(rtllib->dev, HW_VAR_MEDIA_STATUS, 3192 (u8 *)(&OpMode)); 3193 rtllib_disassociate(rtllib); 3194 3195 rtllib->SetHwRegHandler(rtllib->dev, HW_VAR_BSSID, 3196 rtllib->current_network.bssid); 3197 3198 } 3199 3200 } 3201 3202 static void 3203 rtllib_MgntDisconnectAP( 3204 struct rtllib_device *rtllib, 3205 u8 asRsn 3206 ) 3207 { 3208 bool bFilterOutNonAssociatedBSSID = false; 3209 3210 bFilterOutNonAssociatedBSSID = false; 3211 rtllib->SetHwRegHandler(rtllib->dev, HW_VAR_CECHK_BSSID, 3212 (u8 *)(&bFilterOutNonAssociatedBSSID)); 3213 rtllib_MlmeDisassociateRequest(rtllib, rtllib->current_network.bssid, 3214 asRsn); 3215 3216 rtllib->state = RTLLIB_NOLINK; 3217 } 3218 3219 bool rtllib_MgntDisconnect(struct rtllib_device *rtllib, u8 asRsn) 3220 { 3221 if (rtllib->ps != RTLLIB_PS_DISABLED) 3222 rtllib->sta_wake_up(rtllib->dev); 3223 3224 if (rtllib->state == RTLLIB_LINKED) { 3225 if (rtllib->iw_mode == IW_MODE_ADHOC) 3226 rtllib_MgntDisconnectIBSS(rtllib); 3227 if (rtllib->iw_mode == IW_MODE_INFRA) 3228 rtllib_MgntDisconnectAP(rtllib, asRsn); 3229 3230 } 3231 3232 return true; 3233 } 3234 EXPORT_SYMBOL(rtllib_MgntDisconnect); 3235 3236 void notify_wx_assoc_event(struct rtllib_device *ieee) 3237 { 3238 union iwreq_data wrqu; 3239 3240 if (ieee->cannot_notify) 3241 return; 3242 3243 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 3244 if (ieee->state == RTLLIB_LINKED) 3245 memcpy(wrqu.ap_addr.sa_data, ieee->current_network.bssid, 3246 ETH_ALEN); 3247 else { 3248 3249 netdev_info(ieee->dev, "%s(): Tell user space disconnected\n", 3250 __func__); 3251 eth_zero_addr(wrqu.ap_addr.sa_data); 3252 } 3253 wireless_send_event(ieee->dev, SIOCGIWAP, &wrqu, NULL); 3254 } 3255 EXPORT_SYMBOL(notify_wx_assoc_event); 3256