drivers/staging/rtl8187se/ieee80211/ieee80211_softmac_wx.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  * Some pieces of code might be stolen from ipw2100 driver
   8  * copyright of who own it's copyright ;-)
   9  *
  10  * PS wx handler mostly stolen from hostap, copyright who
  11  * own it's copyright ;-)
  12  *
  13  * released under the GPL
  14  */
  15
  16
  17 #include "ieee80211.h"
  18
  19 /* FIXME: add A freqs */
  20
  21 const long ieee80211_wlan_frequencies[] = {
  22         2412, 2417, 2422, 2427,
  23         2432, 2437, 2442, 2447,
  24         2452, 2457, 2462, 2467,
  25         2472, 2484
  26 };
  27
  28
  29 int ieee80211_wx_set_freq(struct ieee80211_device *ieee, struct iw_request_info *a,
  30                              union iwreq_data *wrqu, char *b)
  31 {
  32         int ret;
  33         struct iw_freq *fwrq = & wrqu->freq;
  34 //      printk("in %s\n",__func__);
  35         down(&ieee->wx_sem);
  36
  37         if(ieee->iw_mode == IW_MODE_INFRA){
  38                 ret = -EOPNOTSUPP;
  39                 goto out;
  40         }
  41
  42         /* if setting by freq convert to channel */
  43         if (fwrq->e == 1) {
  44                 if ((fwrq->m >= (int) 2.412e8 &&
  45                      fwrq->m <= (int) 2.487e8)) {
  46                         int f = fwrq->m / 100000;
  47                         int c = 0;
  48
  49                         while ((c < 14) && (f != ieee80211_wlan_frequencies[c]))
  50                                 c++;
  51
  52                         /* hack to fall through */
  53                         fwrq->e = 0;
  54                         fwrq->m = c + 1;
  55                 }
  56         }
  57
  58         if (fwrq->e > 0 || fwrq->m > 14 || fwrq->m < 1 ){
  59                 ret = -EOPNOTSUPP;
  60                 goto out;
  61
  62         }else { /* Set the channel */
  63
  64
  65                 ieee->current_network.channel = fwrq->m;
  66                 ieee->set_chan(ieee->dev, ieee->current_network.channel);
  67
  68                 if(ieee->iw_mode == IW_MODE_ADHOC || ieee->iw_mode == IW_MODE_MASTER)
  69                         if(ieee->state == IEEE80211_LINKED){
  70
  71                         ieee80211_stop_send_beacons(ieee);
  72                         ieee80211_start_send_beacons(ieee);
  73                         }
  74         }
  75
  76         ret = 0;
  77 out:
  78         up(&ieee->wx_sem);
  79         return ret;
  80 }
  81
  82
  83 int ieee80211_wx_get_freq(struct ieee80211_device *ieee,
  84                              struct iw_request_info *a,
  85                              union iwreq_data *wrqu, char *b)
  86 {
  87         struct iw_freq *fwrq = & wrqu->freq;
  88
  89         if (ieee->current_network.channel == 0)
  90                 return -1;
  91
  92         fwrq->m = ieee->current_network.channel;
  93         fwrq->e = 0;
  94
  95         return 0;
  96 }
  97
  98 int ieee80211_wx_get_wap(struct ieee80211_device *ieee,
  99                             struct iw_request_info *info,
 100                             union iwreq_data *wrqu, char *extra)
 101 {
 102         unsigned long flags;
 103
 104         wrqu->ap_addr.sa_family = ARPHRD_ETHER;
 105
 106         if (ieee->iw_mode == IW_MODE_MONITOR)
 107                 return -1;
 108
 109         /* We want avoid to give to the user inconsistent infos*/
 110         spin_lock_irqsave(&ieee->lock, flags);
 111
 112         if (ieee->state != IEEE80211_LINKED &&
 113                 ieee->state != IEEE80211_LINKED_SCANNING &&
 114                 ieee->wap_set == 0)
 115
 116                 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
 117         else
 118                 memcpy(wrqu->ap_addr.sa_data,
 119                        ieee->current_network.bssid, ETH_ALEN);
 120
 121         spin_unlock_irqrestore(&ieee->lock, flags);
 122
 123         return 0;
 124 }
 125
 126
 127 int ieee80211_wx_set_wap(struct ieee80211_device *ieee,
 128                          struct iw_request_info *info,
 129                          union iwreq_data *awrq,
 130                          char *extra)
 131 {
 132
 133         int ret = 0;
 134         u8 zero[] = {0,0,0,0,0,0};
 135         unsigned long flags;
 136
 137         short ifup = ieee->proto_started;//dev->flags & IFF_UP;
 138         struct sockaddr *temp = (struct sockaddr *)awrq;
 139
 140         //printk("=======Set WAP:");
 141         ieee->sync_scan_hurryup = 1;
 142
 143         down(&ieee->wx_sem);
 144         /* use ifconfig hw ether */
 145         if (ieee->iw_mode == IW_MODE_MASTER){
 146                 ret = -1;
 147                 goto out;
 148         }
 149
 150         if (temp->sa_family != ARPHRD_ETHER){
 151                 ret = -EINVAL;
 152                 goto out;
 153         }
 154
 155         if (ifup)
 156                 ieee80211_stop_protocol(ieee);
 157
 158         /* just to avoid to give inconsistent infos in the
 159          * get wx method. not really needed otherwise
 160          */
 161         spin_lock_irqsave(&ieee->lock, flags);
 162
 163         memcpy(ieee->current_network.bssid, temp->sa_data, ETH_ALEN);
 164         ieee->wap_set = memcmp(temp->sa_data, zero,ETH_ALEN)!=0;
 165         //printk(" %x:%x:%x:%x:%x:%x\n", ieee->current_network.bssid[0],ieee->current_network.bssid[1],ieee->current_network.bssid[2],ieee->current_network.bssid[3],ieee->current_network.bssid[4],ieee->current_network.bssid[5]);
 166
 167         spin_unlock_irqrestore(&ieee->lock, flags);
 168
 169         if (ifup)
 170                 ieee80211_start_protocol(ieee);
 171
 172 out:
 173         up(&ieee->wx_sem);
 174         return ret;
 175 }
 176
 177  int ieee80211_wx_get_essid(struct ieee80211_device *ieee, struct iw_request_info *a,union iwreq_data *wrqu,char *b)
 178 {
 179         int len,ret = 0;
 180         unsigned long flags;
 181
 182         if (ieee->iw_mode == IW_MODE_MONITOR)
 183                 return -1;
 184
 185         /* We want avoid to give to the user inconsistent infos*/
 186         spin_lock_irqsave(&ieee->lock, flags);
 187
 188         if (ieee->current_network.ssid[0] == '\0' ||
 189                 ieee->current_network.ssid_len == 0){
 190                 ret = -1;
 191                 goto out;
 192         }
 193
 194         if (ieee->state != IEEE80211_LINKED &&
 195                 ieee->state != IEEE80211_LINKED_SCANNING &&
 196                 ieee->ssid_set == 0){
 197                 ret = -1;
 198                 goto out;
 199         }
 200         len = ieee->current_network.ssid_len;
 201         wrqu->essid.length = len;
 202         strncpy(b,ieee->current_network.ssid,len);
 203         wrqu->essid.flags = 1;
 204
 205 out:
 206         spin_unlock_irqrestore(&ieee->lock, flags);
 207
 208         return ret;
 209
 210 }
 211
 212 int ieee80211_wx_set_rate(struct ieee80211_device *ieee,
 213                              struct iw_request_info *info,
 214                              union iwreq_data *wrqu, char *extra)
 215 {
 216
 217         u32 target_rate = wrqu->bitrate.value;
 218
 219         //added by lizhaoming for auto mode
 220         if(target_rate == -1){
 221         ieee->rate = 110;
 222         } else {
 223         ieee->rate = target_rate/100000;
 224         }
 225         //FIXME: we might want to limit rate also in management protocols.
 226         return 0;
 227 }
 228
 229
 230
 231 int ieee80211_wx_get_rate(struct ieee80211_device *ieee,
 232                              struct iw_request_info *info,
 233                              union iwreq_data *wrqu, char *extra)
 234 {
 235
 236         wrqu->bitrate.value = ieee->rate * 100000;
 237
 238         return 0;
 239 }
 240
 241 int ieee80211_wx_set_mode(struct ieee80211_device *ieee, struct iw_request_info *a,
 242                              union iwreq_data *wrqu, char *b)
 243 {
 244
 245         ieee->sync_scan_hurryup = 1;
 246
 247         down(&ieee->wx_sem);
 248
 249         if (wrqu->mode == ieee->iw_mode)
 250                 goto out;
 251
 252         if (wrqu->mode == IW_MODE_MONITOR){
 253
 254                 ieee->dev->type = ARPHRD_IEEE80211;
 255         }else{
 256                 ieee->dev->type = ARPHRD_ETHER;
 257         }
 258
 259         if (!ieee->proto_started){
 260                 ieee->iw_mode = wrqu->mode;
 261         }else{
 262                 ieee80211_stop_protocol(ieee);
 263                 ieee->iw_mode = wrqu->mode;
 264                 ieee80211_start_protocol(ieee);
 265         }
 266
 267 out:
 268         up(&ieee->wx_sem);
 269         return 0;
 270 }
 271
 272
 273 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
 274 void ieee80211_wx_sync_scan_wq(struct work_struct *work)
 275 {
 276         struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, wx_sync_scan_wq);
 277 #else
 278 void ieee80211_wx_sync_scan_wq(struct ieee80211_device *ieee)
 279 {
 280 #endif
 281 //void ieee80211_wx_sync_scan_wq(struct ieee80211_device *ieee)
 282 //{
 283         short chan;
 284
 285         chan = ieee->current_network.channel;
 286
 287         netif_carrier_off(ieee->dev);
 288
 289         if (ieee->data_hard_stop)
 290                 ieee->data_hard_stop(ieee->dev);
 291
 292         ieee80211_stop_send_beacons(ieee);
 293
 294         ieee->state = IEEE80211_LINKED_SCANNING;
 295         ieee->link_change(ieee->dev);
 296
 297         ieee80211_start_scan_syncro(ieee);
 298
 299         ieee->set_chan(ieee->dev, chan);
 300
 301         ieee->state = IEEE80211_LINKED;
 302         ieee->link_change(ieee->dev);
 303
 304         if (ieee->data_hard_resume)
 305                 ieee->data_hard_resume(ieee->dev);
 306
 307         if(ieee->iw_mode == IW_MODE_ADHOC || ieee->iw_mode == IW_MODE_MASTER)
 308                 ieee80211_start_send_beacons(ieee);
 309
 310         netif_carrier_on(ieee->dev);
 311
 312         //YJ,add,080828, In prevent of lossing ping packet during scanning
 313         //ieee80211_sta_ps_send_null_frame(ieee, false);
 314         //YJ,add,080828,end
 315
 316         up(&ieee->wx_sem);
 317
 318 }
 319
 320 int ieee80211_wx_set_scan(struct ieee80211_device *ieee, struct iw_request_info *a,
 321                              union iwreq_data *wrqu, char *b)
 322 {
 323         int ret = 0;
 324
 325         down(&ieee->wx_sem);
 326
 327         if (ieee->iw_mode == IW_MODE_MONITOR || !(ieee->proto_started)){
 328                 ret = -1;
 329                 goto out;
 330         }
 331         //YJ,add,080828
 332         //In prevent of lossing ping packet during scanning
 333         //ieee80211_sta_ps_send_null_frame(ieee, true);
 334         //YJ,add,080828,end
 335
 336         if ( ieee->state == IEEE80211_LINKED){
 337                 queue_work(ieee->wq, &ieee->wx_sync_scan_wq);
 338                 /* intentionally forget to up sem */
 339                 return 0;
 340         }
 341
 342 out:
 343         up(&ieee->wx_sem);
 344         return ret;
 345 }
 346
 347 int ieee80211_wx_set_essid(struct ieee80211_device *ieee,
 348                               struct iw_request_info *a,
 349                               union iwreq_data *wrqu, char *extra)
 350 {
 351
 352         int ret=0,len;
 353         short proto_started;
 354         unsigned long flags;
 355
 356         ieee->sync_scan_hurryup = 1;
 357
 358         down(&ieee->wx_sem);
 359
 360         proto_started = ieee->proto_started;
 361
 362         if (wrqu->essid.length > IW_ESSID_MAX_SIZE){
 363                 ret= -E2BIG;
 364                 goto out;
 365         }
 366
 367         if (ieee->iw_mode == IW_MODE_MONITOR){
 368                 ret= -1;
 369                 goto out;
 370         }
 371
 372         if(proto_started)
 373                 ieee80211_stop_protocol(ieee);
 374
 375         /* this is just to be sure that the GET wx callback
 376          * has consisten infos. not needed otherwise
 377          */
 378         spin_lock_irqsave(&ieee->lock, flags);
 379
 380         if (wrqu->essid.flags && wrqu->essid.length) {
 381 //YJ,modified,080819
 382 #if LINUX_VERSION_CODE <  KERNEL_VERSION(2,6,20)
 383                 len = ((wrqu->essid.length-1) < IW_ESSID_MAX_SIZE) ? (wrqu->essid.length-1) : IW_ESSID_MAX_SIZE;
 384 #else
 385                 len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ? (wrqu->essid.length) : IW_ESSID_MAX_SIZE;
 386 #endif
 387                 memset(ieee->current_network.ssid, 0, ieee->current_network.ssid_len); //YJ,add,080819
 388                 strncpy(ieee->current_network.ssid, extra, len);
 389                 ieee->current_network.ssid_len = len;
 390                 ieee->ssid_set = 1;
 391 //YJ,modified,080819,end
 392
 393                 //YJ,add,080819,for hidden ap
 394                 if(len == 0){
 395                         memset(ieee->current_network.bssid, 0, ETH_ALEN);
 396                         ieee->current_network.capability = 0;
 397                 }
 398                 //YJ,add,080819,for hidden ap,end
 399         }
 400         else{
 401                 ieee->ssid_set = 0;
 402                 ieee->current_network.ssid[0] = '\0';
 403                 ieee->current_network.ssid_len = 0;
 404         }
 405         //printk("==========set essid %s!\n",ieee->current_network.ssid);
 406         spin_unlock_irqrestore(&ieee->lock, flags);
 407
 408         if (proto_started)
 409                 ieee80211_start_protocol(ieee);
 410 out:
 411         up(&ieee->wx_sem);
 412         return ret;
 413 }
 414
 415  int ieee80211_wx_get_mode(struct ieee80211_device *ieee, struct iw_request_info *a,
 416                              union iwreq_data *wrqu, char *b)
 417 {
 418
 419         wrqu->mode = ieee->iw_mode;
 420         return 0;
 421 }
 422
 423  int ieee80211_wx_set_rawtx(struct ieee80211_device *ieee,
 424                                struct iw_request_info *info,
 425                                union iwreq_data *wrqu, char *extra)
 426 {
 427
 428         int *parms = (int *)extra;
 429         int enable = (parms[0] > 0);
 430         short prev = ieee->raw_tx;
 431
 432         down(&ieee->wx_sem);
 433
 434         if(enable)
 435                 ieee->raw_tx = 1;
 436         else
 437                 ieee->raw_tx = 0;
 438
 439         printk(KERN_INFO"raw TX is %s\n",
 440               ieee->raw_tx ? "enabled" : "disabled");
 441
 442         if(ieee->iw_mode == IW_MODE_MONITOR)
 443         {
 444                 if(prev == 0 && ieee->raw_tx){
 445                         if (ieee->data_hard_resume)
 446                                 ieee->data_hard_resume(ieee->dev);
 447
 448                         netif_carrier_on(ieee->dev);
 449                 }
 450
 451                 if(prev && ieee->raw_tx == 1)
 452                         netif_carrier_off(ieee->dev);
 453         }
 454
 455         up(&ieee->wx_sem);
 456
 457         return 0;
 458 }
 459
 460 int ieee80211_wx_get_name(struct ieee80211_device *ieee,
 461                              struct iw_request_info *info,
 462                              union iwreq_data *wrqu, char *extra)
 463 {
 464         strlcpy(wrqu->name, "802.11", IFNAMSIZ);
 465         if(ieee->modulation & IEEE80211_CCK_MODULATION){
 466                 strlcat(wrqu->name, "b", IFNAMSIZ);
 467                 if(ieee->modulation & IEEE80211_OFDM_MODULATION)
 468                         strlcat(wrqu->name, "/g", IFNAMSIZ);
 469         }else if(ieee->modulation & IEEE80211_OFDM_MODULATION)
 470                 strlcat(wrqu->name, "g", IFNAMSIZ);
 471
 472         if((ieee->state == IEEE80211_LINKED) ||
 473                 (ieee->state == IEEE80211_LINKED_SCANNING))
 474                 strlcat(wrqu->name,"  link", IFNAMSIZ);
 475         else if(ieee->state != IEEE80211_NOLINK)
 476                 strlcat(wrqu->name," .....", IFNAMSIZ);
 477
 478
 479         return 0;
 480 }
 481
 482
 483 /* this is mostly stolen from hostap */
 484 int ieee80211_wx_set_power(struct ieee80211_device *ieee,
 485                                  struct iw_request_info *info,
 486                                  union iwreq_data *wrqu, char *extra)
 487 {
 488         int ret = 0;
 489
 490         if(
 491                 (!ieee->sta_wake_up) ||
 492                 (!ieee->ps_request_tx_ack) ||
 493                 (!ieee->enter_sleep_state) ||
 494                 (!ieee->ps_is_queue_empty)){
 495
 496                 printk("ERROR. PS mode is tryied to be use but\
 497 driver missed a callback\n\n");
 498
 499                 return -1;
 500         }
 501
 502         down(&ieee->wx_sem);
 503
 504         if (wrqu->power.disabled){
 505                 ieee->ps = IEEE80211_PS_DISABLED;
 506
 507                 goto exit;
 508         }
 509         switch (wrqu->power.flags & IW_POWER_MODE) {
 510         case IW_POWER_UNICAST_R:
 511                 ieee->ps = IEEE80211_PS_UNICAST;
 512
 513                 break;
 514         case IW_POWER_ALL_R:
 515                 ieee->ps = IEEE80211_PS_UNICAST | IEEE80211_PS_MBCAST;
 516                 break;
 517
 518         case IW_POWER_ON:
 519                 ieee->ps = IEEE80211_PS_DISABLED;
 520                 break;
 521
 522         default:
 523                 ret = -EINVAL;
 524                 goto exit;
 525         }
 526
 527         if (wrqu->power.flags & IW_POWER_TIMEOUT) {
 528
 529                 ieee->ps_timeout = wrqu->power.value / 1000;
 530                 printk("Timeout %d\n",ieee->ps_timeout);
 531         }
 532
 533         if (wrqu->power.flags & IW_POWER_PERIOD) {
 534
 535                 ret = -EOPNOTSUPP;
 536                 goto exit;
 537                 //wrq->value / 1024;
 538
 539         }
 540 exit:
 541         up(&ieee->wx_sem);
 542         return ret;
 543
 544 }
 545
 546 /* this is stolen from hostap */
 547 int ieee80211_wx_get_power(struct ieee80211_device *ieee,
 548                                  struct iw_request_info *info,
 549                                  union iwreq_data *wrqu, char *extra)
 550 {
 551         int ret =0;
 552
 553         down(&ieee->wx_sem);
 554
 555         if(ieee->ps == IEEE80211_PS_DISABLED){
 556                 wrqu->power.disabled = 1;
 557                 goto exit;
 558         }
 559
 560         wrqu->power.disabled = 0;
 561
 562 //      if ((wrqu->power.flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
 563                 wrqu->power.flags = IW_POWER_TIMEOUT;
 564                 wrqu->power.value = ieee->ps_timeout * 1000;
 565 //      } else {
 566 //              ret = -EOPNOTSUPP;
 567 //              goto exit;
 568                 //wrqu->power.flags = IW_POWER_PERIOD;
 569                 //wrqu->power.value = ieee->current_network.dtim_period *
 570                 //      ieee->current_network.beacon_interval * 1024;
 571 //      }
 572
 573
 574         if (ieee->ps & IEEE80211_PS_MBCAST)
 575                 wrqu->power.flags |= IW_POWER_ALL_R;
 576         else
 577                 wrqu->power.flags |= IW_POWER_UNICAST_R;
 578
 579 exit:
 580         up(&ieee->wx_sem);
 581         return ret;
 582
 583 }
 584
 585 #if 0
 586 EXPORT_SYMBOL(ieee80211_wx_get_essid);
 587 EXPORT_SYMBOL(ieee80211_wx_set_essid);
 588 EXPORT_SYMBOL(ieee80211_wx_set_rate);
 589 EXPORT_SYMBOL(ieee80211_wx_get_rate);
 590 EXPORT_SYMBOL(ieee80211_wx_set_wap);
 591 EXPORT_SYMBOL(ieee80211_wx_get_wap);
 592 EXPORT_SYMBOL(ieee80211_wx_set_mode);
 593 EXPORT_SYMBOL(ieee80211_wx_get_mode);
 594 EXPORT_SYMBOL(ieee80211_wx_set_scan);
 595 EXPORT_SYMBOL(ieee80211_wx_get_freq);
 596 EXPORT_SYMBOL(ieee80211_wx_set_freq);
 597 EXPORT_SYMBOL(ieee80211_wx_set_rawtx);
 598 EXPORT_SYMBOL(ieee80211_wx_get_name);
 599 EXPORT_SYMBOL(ieee80211_wx_set_power);
 600 EXPORT_SYMBOL(ieee80211_wx_get_power);
 601 EXPORT_SYMBOL(ieee80211_wlan_frequencies);
 602 #endif