drivers/staging/rtl8192su/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 = kmalloc(
  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         memset(ieee->networks, 0,
  78                MAX_NETWORK_COUNT * sizeof(struct ieee80211_network));
  79
  80         return 0;
  81 }
  82
  83 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
  84 {
  85         if (!ieee->networks)
  86                 return;
  87         kfree(ieee->networks);
  88         ieee->networks = NULL;
  89 }
  90
  91 static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
  92 {
  93         int i;
  94
  95         INIT_LIST_HEAD(&ieee->network_free_list);
  96         INIT_LIST_HEAD(&ieee->network_list);
  97         for (i = 0; i < MAX_NETWORK_COUNT; i++)
  98                 list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
  99 }
 100
 101
 102 struct net_device *alloc_ieee80211(int sizeof_priv)
 103 {
 104         struct ieee80211_device *ieee;
 105         struct net_device *dev;
 106         int i,err;
 107
 108         IEEE80211_DEBUG_INFO("Initializing...\n");
 109
 110         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
 111         if (!dev) {
 112                 IEEE80211_ERROR("Unable to network device.\n");
 113                 goto failed;
 114         }
 115
 116 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 117         ieee = netdev_priv(dev);
 118 #else
 119         ieee = (struct ieee80211_device *)dev->priv;
 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; //defalt 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 = (RT_HIGH_THROUGHPUT*)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 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
 245                                 module_put(crypt->ops->owner);
 246 #else
 247                                 __MOD_DEC_USE_COUNT(crypt->ops->owner);
 248 #endif
 249                         }
 250                         kfree(crypt);
 251                         ieee->crypt[i] = NULL;
 252                 }
 253         }
 254
 255         ieee80211_networks_free(ieee);
 256 #if 0
 257         for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++) {
 258                 list_for_each_safe(p, q, &ieee->ibss_mac_hash[i]) {
 259                         kfree(list_entry(p, struct ieee_ibss_seq, list));
 260                         list_del(p);
 261                 }
 262         }
 263
 264 #endif
 265 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 266         free_netdev(dev);
 267 #else
 268         kfree(dev);
 269 #endif
 270 }
 271
 272 #ifdef CONFIG_IEEE80211_DEBUG
 273
 274 u32 ieee80211_debug_level = 0;
 275 static int debug = \
 276         //                  IEEE80211_DL_INFO   |
 277         //                  IEEE80211_DL_WX     |
 278         //                  IEEE80211_DL_SCAN   |
 279         //                  IEEE80211_DL_STATE  |
 280         //                  IEEE80211_DL_MGMT   |
 281         //                  IEEE80211_DL_FRAG   |
 282         //                  IEEE80211_DL_EAP    |
 283         //                  IEEE80211_DL_DROP   |
 284         //                  IEEE80211_DL_TX     |
 285         //                  IEEE80211_DL_RX     |
 286                             //IEEE80211_DL_QOS    |
 287         //                  IEEE80211_DL_HT     |
 288         //                  IEEE80211_DL_TS     |
 289 //                          IEEE80211_DL_BA     |
 290         //                  IEEE80211_DL_REORDER|
 291 //                          IEEE80211_DL_TRACE  |
 292                             //IEEE80211_DL_DATA |
 293                             IEEE80211_DL_ERR      //awayls open this flags to show error out
 294                             ;
 295 struct proc_dir_entry *ieee80211_proc = NULL;
 296
 297 static int show_debug_level(char *page, char **start, off_t offset,
 298                             int count, int *eof, void *data)
 299 {
 300         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 301 }
 302
 303 static int store_debug_level(struct file *file, const char *buffer,
 304                              unsigned long count, void *data)
 305 {
 306         char buf[] = "0x00000000";
 307         unsigned long len = min(sizeof(buf) - 1, (u32)count);
 308         char *p = (char *)buf;
 309         unsigned long val;
 310
 311         if (copy_from_user(buf, buffer, len))
 312                 return count;
 313         buf[len] = 0;
 314         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
 315                 p++;
 316                 if (p[0] == 'x' || p[0] == 'X')
 317                         p++;
 318                 val = simple_strtoul(p, &p, 16);
 319         } else
 320                 val = simple_strtoul(p, &p, 10);
 321         if (p == buf)
 322                 printk(KERN_INFO DRV_NAME
 323                        ": %s is not in hex or decimal form.\n", buf);
 324         else
 325                 ieee80211_debug_level = val;
 326
 327         return strnlen(buf, count);
 328 }
 329
 330 static int __init ieee80211_init(void)
 331 {
 332         struct proc_dir_entry *e;
 333
 334         ieee80211_debug_level = debug;
 335 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 336         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
 337 #else
 338         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
 339 #endif
 340         if (ieee80211_proc == NULL) {
 341                 IEEE80211_ERROR("Unable to create " DRV_NAME
 342                                 " proc directory\n");
 343                 return -EIO;
 344         }
 345         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 346                               ieee80211_proc);
 347         if (!e) {
 348 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 349                 remove_proc_entry(DRV_NAME, proc_net);
 350 #else
 351                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 352 #endif
 353                 ieee80211_proc = NULL;
 354                 return -EIO;
 355         }
 356         e->read_proc = show_debug_level;
 357         e->write_proc = store_debug_level;
 358         e->data = NULL;
 359
 360         return 0;
 361 }
 362
 363 static void __exit ieee80211_exit(void)
 364 {
 365         if (ieee80211_proc) {
 366                 remove_proc_entry("debug_level", ieee80211_proc);
 367 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 368                 remove_proc_entry(DRV_NAME, proc_net);
 369 #else
 370                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 371 #endif
 372                 ieee80211_proc = NULL;
 373         }
 374 }
 375
 376 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 377 #include <linux/moduleparam.h>
 378 module_param(debug, int, 0444);
 379 MODULE_PARM_DESC(debug, "debug output mask");
 380
 381
 382 module_exit(ieee80211_exit);
 383 module_init(ieee80211_init);
 384 #endif
 385 #endif
 386
 387 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 388 EXPORT_SYMBOL(alloc_ieee80211);
 389 EXPORT_SYMBOL(free_ieee80211);
 390 #else
 391 EXPORT_SYMBOL_NOVERS(alloc_ieee80211);
 392 EXPORT_SYMBOL_NOVERS(free_ieee80211);
 393 #endif