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

   1 /*******************************************************************************
   2
   3   Copyright(c) 2004 Intel Corporation. All rights reserved.
   4
   5   Portions of this file are based on the WEP enablement code provided by the
   6   Host AP project hostap-drivers v0.1.3
   7   Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
   8   <jkmaline@cc.hut.fi>
   9   Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
  10
  11   This program is free software; you can redistribute it and/or modify it
  12   under the terms of version 2 of the GNU General Public License as
  13   published by the Free Software Foundation.
  14
  15   This program is distributed in the hope that it will be useful, but WITHOUT
  16   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  18   more details.
  19
  20   You should have received a copy of the GNU General Public License along with
  21   this program; if not, write to the Free Software Foundation, Inc., 59
  22   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23
  24   The full GNU General Public License is included in this distribution in the
  25   file called LICENSE.
  26
  27   Contact Information:
  28   James P. Ketrenos <ipw2100-admin@linux.intel.com>
  29   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  30
  31 *******************************************************************************/
  32
  33 #include <linux/compiler.h>
  34 //#include <linux/config.h>
  35 #include <linux/errno.h>
  36 #include <linux/if_arp.h>
  37 #include <linux/in6.h>
  38 #include <linux/in.h>
  39 #include <linux/ip.h>
  40 #include <linux/kernel.h>
  41 #include <linux/module.h>
  42 #include <linux/netdevice.h>
  43 #include <linux/pci.h>
  44 #include <linux/proc_fs.h>
  45 #include <linux/skbuff.h>
  46 #include <linux/slab.h>
  47 #include <linux/tcp.h>
  48 #include <linux/types.h>
  49 #include <linux/version.h>
  50 #include <linux/wireless.h>
  51 #include <linux/etherdevice.h>
  52 #include <asm/uaccess.h>
  53 #include <net/arp.h>
  54
  55 #include "ieee80211.h"
  56
  57 MODULE_DESCRIPTION("802.11 data/management/control stack");
  58 MODULE_AUTHOR("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
  59 MODULE_LICENSE("GPL");
  60
  61 #define DRV_NAME "ieee80211"
  62
  63 static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
  64 {
  65         if (ieee->networks)
  66                 return 0;
  67
  68         ieee->networks = kcalloc(
  69                 MAX_NETWORK_COUNT, sizeof(struct ieee80211_network),
  70                 GFP_KERNEL);
  71         if (!ieee->networks) {
  72                 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
  73                        ieee->dev->name);
  74                 return -ENOMEM;
  75         }
  76
  77         return 0;
  78 }
  79
  80 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
  81 {
  82         if (!ieee->networks)
  83                 return;
  84         kfree(ieee->networks);
  85         ieee->networks = NULL;
  86 }
  87
  88 static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
  89 {
  90         int i;
  91
  92         INIT_LIST_HEAD(&ieee->network_free_list);
  93         INIT_LIST_HEAD(&ieee->network_list);
  94         for (i = 0; i < MAX_NETWORK_COUNT; i++)
  95                 list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
  96 }
  97
  98
  99 struct net_device *alloc_ieee80211(int sizeof_priv)
 100 {
 101         struct ieee80211_device *ieee;
 102         struct net_device *dev;
 103         int i,err;
 104
 105         IEEE80211_DEBUG_INFO("Initializing...\n");
 106
 107         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
 108         if (!dev) {
 109                 IEEE80211_ERROR("Unable to network device.\n");
 110                 goto failed;
 111         }
 112
 113 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 114         ieee = netdev_priv(dev);
 115 #else
 116         ieee = (struct ieee80211_device *)dev->priv;
 117 #endif
 118 #if 0
 119         dev->hard_start_xmit = ieee80211_rtl_xmit;
 120 #endif
 121
 122         memset(ieee, 0, sizeof(struct ieee80211_device)+sizeof_priv);
 123         ieee->dev = dev;
 124
 125         err = ieee80211_networks_allocate(ieee);
 126         if (err) {
 127                 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
 128                                 err);
 129                 goto failed;
 130         }
 131         ieee80211_networks_initialize(ieee);
 132
 133
 134         /* Default fragmentation threshold is maximum payload size */
 135         ieee->fts = DEFAULT_FTS;
 136         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
 137         ieee->open_wep = 1;
 138
 139         /* Default to enabling full open WEP with host based encrypt/decrypt */
 140         ieee->host_encrypt = 1;
 141         ieee->host_decrypt = 1;
 142         ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
 143
 144         INIT_LIST_HEAD(&ieee->crypt_deinit_list);
 145         init_timer(&ieee->crypt_deinit_timer);
 146         ieee->crypt_deinit_timer.data = (unsigned long)ieee;
 147         ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
 148
 149         spin_lock_init(&ieee->lock);
 150         spin_lock_init(&ieee->wpax_suitlist_lock);
 151         spin_lock_init(&ieee->bw_spinlock);
 152         spin_lock_init(&ieee->reorder_spinlock);
 153         //added by WB
 154         atomic_set(&(ieee->atm_chnlop), 0);
 155         atomic_set(&(ieee->atm_swbw), 0);
 156
 157         ieee->wpax_type_set = 0;
 158         ieee->wpa_enabled = 0;
 159         ieee->tkip_countermeasures = 0;
 160         ieee->drop_unencrypted = 0;
 161         ieee->privacy_invoked = 0;
 162         ieee->ieee802_1x = 1;
 163         ieee->raw_tx = 0;
 164         //ieee->hwsec_support = 1; //default support hw security. //use module_param instead.
 165         ieee->hwsec_active = 0; //disable hwsec, switch it on when necessary.
 166
 167         ieee80211_softmac_init(ieee);
 168
 169 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
 170         ieee->pHTInfo = kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
 171 #else
 172         ieee->pHTInfo = (RT_HIGH_THROUGHPUT*)kmalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
 173         memset(ieee->pHTInfo,0,sizeof(RT_HIGH_THROUGHPUT));
 174 #endif
 175         if (ieee->pHTInfo == NULL)
 176         {
 177                 IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n");
 178                 return NULL;
 179         }
 180         HTUpdateDefaultSetting(ieee);
 181         HTInitializeHTInfo(ieee); //may move to other place.
 182         TSInitialize(ieee);
 183 #if 0
 184 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
 185         INIT_WORK(&ieee->ht_onAssRsp, (void(*)(void*)) HTOnAssocRsp_wq);
 186 #else
 187         INIT_WORK(&ieee->ht_onAssRsp, (void(*)(void*)) HTOnAssocRsp_wq, ieee);
 188 #endif
 189 #endif
 190         for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++)
 191                 INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]);
 192
 193         for (i = 0; i < 17; i++) {
 194           ieee->last_rxseq_num[i] = -1;
 195           ieee->last_rxfrag_num[i] = -1;
 196           ieee->last_packet_time[i] = 0;
 197         }
 198
 199 //These function were added to load crypte module autoly
 200         ieee80211_tkip_null();
 201         ieee80211_wep_null();
 202         ieee80211_ccmp_null();
 203
 204         return dev;
 205
 206  failed:
 207         if (dev)
 208 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 209                 free_netdev(dev);
 210 #else
 211                 kfree(dev);
 212 #endif
 213         return NULL;
 214 }
 215
 216
 217 void free_ieee80211(struct net_device *dev)
 218 {
 219 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 220         struct ieee80211_device *ieee = netdev_priv(dev);
 221 #else
 222         struct ieee80211_device *ieee = (struct ieee80211_device *)dev->priv;
 223 #endif
 224         int i;
 225         //struct list_head *p, *q;
 226 //      del_timer_sync(&ieee->SwBwTimer);
 227 #if 1
 228         if (ieee->pHTInfo != NULL)
 229         {
 230                 kfree(ieee->pHTInfo);
 231                 ieee->pHTInfo = NULL;
 232         }
 233 #endif
 234         RemoveAllTS(ieee);
 235         ieee80211_softmac_free(ieee);
 236         del_timer_sync(&ieee->crypt_deinit_timer);
 237         ieee80211_crypt_deinit_entries(ieee, 1);
 238
 239         for (i = 0; i < WEP_KEYS; i++) {
 240                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
 241                 if (crypt) {
 242                         if (crypt->ops)
 243                                 crypt->ops->deinit(crypt->priv);
 244                         kfree(crypt);
 245                         ieee->crypt[i] = NULL;
 246                 }
 247         }
 248
 249         ieee80211_networks_free(ieee);
 250 #if 0
 251         for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++) {
 252                 list_for_each_safe(p, q, &ieee->ibss_mac_hash[i]) {
 253                         kfree(list_entry(p, struct ieee_ibss_seq, list));
 254                         list_del(p);
 255                 }
 256         }
 257
 258 #endif
 259 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 260         free_netdev(dev);
 261 #else
 262         kfree(dev);
 263 #endif
 264 }
 265
 266 #ifdef CONFIG_IEEE80211_DEBUG
 267
 268 u32 ieee80211_debug_level = 0;
 269 static int debug = \
 270         //                  IEEE80211_DL_INFO   |
 271         //                  IEEE80211_DL_WX     |
 272         //                  IEEE80211_DL_SCAN   |
 273         //                  IEEE80211_DL_STATE  |
 274         //                  IEEE80211_DL_MGMT   |
 275         //                  IEEE80211_DL_FRAG   |
 276         //                  IEEE80211_DL_EAP    |
 277         //                  IEEE80211_DL_DROP   |
 278         //                  IEEE80211_DL_TX     |
 279         //                  IEEE80211_DL_RX     |
 280                             //IEEE80211_DL_QOS    |
 281         //                  IEEE80211_DL_HT     |
 282         //                  IEEE80211_DL_TS     |
 283 //                          IEEE80211_DL_BA     |
 284         //                  IEEE80211_DL_REORDER|
 285 //                          IEEE80211_DL_TRACE  |
 286                             //IEEE80211_DL_DATA |
 287                             IEEE80211_DL_ERR      //awayls open this flags to show error out
 288                             ;
 289 struct proc_dir_entry *ieee80211_proc = NULL;
 290
 291 static int show_debug_level(char *page, char **start, off_t offset,
 292                             int count, int *eof, void *data)
 293 {
 294         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 295 }
 296
 297 static int store_debug_level(struct file *file, const char *buffer,
 298                              unsigned long count, void *data)
 299 {
 300         char buf[] = "0x00000000";
 301         unsigned long len = min(sizeof(buf) - 1, (u32)count);
 302         char *p = (char *)buf;
 303         unsigned long val;
 304
 305         if (copy_from_user(buf, buffer, len))
 306                 return count;
 307         buf[len] = 0;
 308         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
 309                 p++;
 310                 if (p[0] == 'x' || p[0] == 'X')
 311                         p++;
 312                 val = simple_strtoul(p, &p, 16);
 313         } else
 314                 val = simple_strtoul(p, &p, 10);
 315         if (p == buf)
 316                 printk(KERN_INFO DRV_NAME
 317                        ": %s is not in hex or decimal form.\n", buf);
 318         else
 319                 ieee80211_debug_level = val;
 320
 321         return strnlen(buf, count);
 322 }
 323
 324 extern int ieee80211_crypto_init(void);
 325 extern void ieee80211_crypto_deinit(void);
 326 extern int ieee80211_crypto_tkip_init(void);
 327 extern void ieee80211_crypto_tkip_exit(void);
 328 extern int ieee80211_crypto_ccmp_init(void);
 329 extern void ieee80211_crypto_ccmp_exit(void);
 330 extern int ieee80211_crypto_wep_init(void);
 331 extern void ieee80211_crypto_wep_exit(void);
 332
 333 int __init ieee80211_rtl_init(void)
 334 {
 335         struct proc_dir_entry *e;
 336         int retval;
 337
 338         retval = ieee80211_crypto_init();
 339         if (retval)
 340                 return retval;
 341         retval = ieee80211_crypto_tkip_init();
 342         if (retval) {
 343                 ieee80211_crypto_deinit();
 344                 return retval;
 345         }
 346         retval = ieee80211_crypto_ccmp_init();
 347         if (retval) {
 348                 ieee80211_crypto_tkip_exit();
 349                 ieee80211_crypto_deinit();
 350                 return retval;
 351         }
 352         retval = ieee80211_crypto_wep_init();
 353         if (retval) {
 354                 ieee80211_crypto_ccmp_exit();
 355                 ieee80211_crypto_tkip_exit();
 356                 ieee80211_crypto_deinit();
 357                 return retval;
 358         }
 359
 360         ieee80211_debug_level = debug;
 361 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 362         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
 363 #else
 364         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
 365 #endif
 366         if (ieee80211_proc == NULL) {
 367                 IEEE80211_ERROR("Unable to create " DRV_NAME
 368                                 " proc directory\n");
 369                 return -EIO;
 370         }
 371         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 372                               ieee80211_proc);
 373         if (!e) {
 374 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 375                 remove_proc_entry(DRV_NAME, proc_net);
 376 #else
 377                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 378 #endif
 379                 ieee80211_proc = NULL;
 380                 return -EIO;
 381         }
 382         e->read_proc = show_debug_level;
 383         e->write_proc = store_debug_level;
 384         e->data = NULL;
 385
 386         return 0;
 387 }
 388
 389 void __exit ieee80211_rtl_exit(void)
 390 {
 391         if (ieee80211_proc) {
 392                 remove_proc_entry("debug_level", ieee80211_proc);
 393 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 394                 remove_proc_entry(DRV_NAME, proc_net);
 395 #else
 396                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 397 #endif
 398                 ieee80211_proc = NULL;
 399         }
 400         ieee80211_crypto_wep_exit();
 401         ieee80211_crypto_ccmp_exit();
 402         ieee80211_crypto_tkip_exit();
 403         ieee80211_crypto_deinit();
 404 }
 405
 406 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 407 #include <linux/moduleparam.h>
 408 module_param(debug, int, 0444);
 409 MODULE_PARM_DESC(debug, "debug output mask");
 410
 411
 412 //module_exit(ieee80211_rtl_exit);
 413 //module_init(ieee80211_rtl_init);
 414 #endif
 415 #endif
 416
 417 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 418 //EXPORT_SYMBOL(alloc_ieee80211);
 419 //EXPORT_SYMBOL(free_ieee80211);
 420 #else
 421 EXPORT_SYMBOL_NOVERS(alloc_ieee80211);
 422 EXPORT_SYMBOL_NOVERS(free_ieee80211);
 423 #endif