SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/rtl8192su/ieee80211/ieee80211_softmac.c

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