drivers/staging/rtl8192u/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         ieee = netdev_priv(dev);
 114         memset(ieee, 0, sizeof(struct ieee80211_device)+sizeof_priv);
 115         ieee->dev = dev;
 116
 117         err = ieee80211_networks_allocate(ieee);
 118         if (err) {
 119                 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
 120                                 err);
 121                 goto failed;
 122         }
 123         ieee80211_networks_initialize(ieee);
 124
 125
 126         /* Default fragmentation threshold is maximum payload size */
 127         ieee->fts = DEFAULT_FTS;
 128         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
 129         ieee->open_wep = 1;
 130
 131         /* Default to enabling full open WEP with host based encrypt/decrypt */
 132         ieee->host_encrypt = 1;
 133         ieee->host_decrypt = 1;
 134         ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
 135
 136         INIT_LIST_HEAD(&ieee->crypt_deinit_list);
 137         init_timer(&ieee->crypt_deinit_timer);
 138         ieee->crypt_deinit_timer.data = (unsigned long)ieee;
 139         ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
 140
 141         spin_lock_init(&ieee->lock);
 142         spin_lock_init(&ieee->wpax_suitlist_lock);
 143         spin_lock_init(&ieee->bw_spinlock);
 144         spin_lock_init(&ieee->reorder_spinlock);
 145         //added by WB
 146         atomic_set(&(ieee->atm_chnlop), 0);
 147         atomic_set(&(ieee->atm_swbw), 0);
 148
 149         ieee->wpax_type_set = 0;
 150         ieee->wpa_enabled = 0;
 151         ieee->tkip_countermeasures = 0;
 152         ieee->drop_unencrypted = 0;
 153         ieee->privacy_invoked = 0;
 154         ieee->ieee802_1x = 1;
 155         ieee->raw_tx = 0;
 156         //ieee->hwsec_support = 1; //defalt support hw security. //use module_param instead.
 157         ieee->hwsec_active = 0; //disable hwsec, switch it on when necessary.
 158
 159         ieee80211_softmac_init(ieee);
 160
 161         ieee->pHTInfo = kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
 162         if (ieee->pHTInfo == NULL)
 163         {
 164                 IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n");
 165                 return NULL;
 166         }
 167         HTUpdateDefaultSetting(ieee);
 168         HTInitializeHTInfo(ieee); //may move to other place.
 169         TSInitialize(ieee);
 170
 171         for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++)
 172                 INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]);
 173
 174         for (i = 0; i < 17; i++) {
 175           ieee->last_rxseq_num[i] = -1;
 176           ieee->last_rxfrag_num[i] = -1;
 177           ieee->last_packet_time[i] = 0;
 178         }
 179
 180 //These function were added to load crypte module autoly
 181         ieee80211_tkip_null();
 182         ieee80211_wep_null();
 183         ieee80211_ccmp_null();
 184
 185         return dev;
 186
 187  failed:
 188         if (dev)
 189                 free_netdev(dev);
 190
 191         return NULL;
 192 }
 193
 194
 195 void free_ieee80211(struct net_device *dev)
 196 {
 197         struct ieee80211_device *ieee = netdev_priv(dev);
 198         int i;
 199         //struct list_head *p, *q;
 200 //      del_timer_sync(&ieee->SwBwTimer);
 201         if (ieee->pHTInfo != NULL)
 202         {
 203                 kfree(ieee->pHTInfo);
 204                 ieee->pHTInfo = NULL;
 205         }
 206         RemoveAllTS(ieee);
 207         ieee80211_softmac_free(ieee);
 208         del_timer_sync(&ieee->crypt_deinit_timer);
 209         ieee80211_crypt_deinit_entries(ieee, 1);
 210
 211         for (i = 0; i < WEP_KEYS; i++) {
 212                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
 213                 if (crypt) {
 214                         if (crypt->ops)
 215                                 crypt->ops->deinit(crypt->priv);
 216                         kfree(crypt);
 217                         ieee->crypt[i] = NULL;
 218                 }
 219         }
 220
 221         ieee80211_networks_free(ieee);
 222         free_netdev(dev);
 223 }
 224
 225 #ifdef CONFIG_IEEE80211_DEBUG
 226
 227 u32 ieee80211_debug_level = 0;
 228 static int debug = \
 229         //                  IEEE80211_DL_INFO   |
 230         //                  IEEE80211_DL_WX     |
 231         //                  IEEE80211_DL_SCAN   |
 232         //                  IEEE80211_DL_STATE  |
 233         //                  IEEE80211_DL_MGMT   |
 234         //                  IEEE80211_DL_FRAG   |
 235         //                  IEEE80211_DL_EAP    |
 236         //                  IEEE80211_DL_DROP   |
 237         //                  IEEE80211_DL_TX     |
 238         //                  IEEE80211_DL_RX     |
 239                             //IEEE80211_DL_QOS    |
 240         //                  IEEE80211_DL_HT     |
 241         //                  IEEE80211_DL_TS     |
 242 //                          IEEE80211_DL_BA     |
 243         //                  IEEE80211_DL_REORDER|
 244 //                          IEEE80211_DL_TRACE  |
 245                             //IEEE80211_DL_DATA |
 246                             IEEE80211_DL_ERR      //awayls open this flags to show error out
 247                             ;
 248 struct proc_dir_entry *ieee80211_proc = NULL;
 249
 250 static int show_debug_level(char *page, char **start, off_t offset,
 251                             int count, int *eof, void *data)
 252 {
 253         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 254 }
 255
 256 static int store_debug_level(struct file *file, const char *buffer,
 257                              unsigned long count, void *data)
 258 {
 259         char buf[] = "0x00000000";
 260         unsigned long len = min_t(unsigned long, sizeof(buf) - 1, count);
 261         char *p = (char *)buf;
 262         unsigned long val;
 263
 264         if (copy_from_user(buf, buffer, len))
 265                 return count;
 266         buf[len] = 0;
 267         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
 268                 p++;
 269                 if (p[0] == 'x' || p[0] == 'X')
 270                         p++;
 271                 val = simple_strtoul(p, &p, 16);
 272         } else
 273                 val = simple_strtoul(p, &p, 10);
 274         if (p == buf)
 275                 printk(KERN_INFO DRV_NAME
 276                        ": %s is not in hex or decimal form.\n", buf);
 277         else
 278                 ieee80211_debug_level = val;
 279
 280         return strnlen(buf, count);
 281 }
 282
 283 int __init ieee80211_debug_init(void)
 284 {
 285         struct proc_dir_entry *e;
 286
 287         ieee80211_debug_level = debug;
 288
 289         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
 290         if (ieee80211_proc == NULL) {
 291                 IEEE80211_ERROR("Unable to create " DRV_NAME
 292                                 " proc directory\n");
 293                 return -EIO;
 294         }
 295         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 296                               ieee80211_proc);
 297         if (!e) {
 298                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 299                 ieee80211_proc = NULL;
 300                 return -EIO;
 301         }
 302         e->read_proc = show_debug_level;
 303         e->write_proc = store_debug_level;
 304         e->data = NULL;
 305
 306         return 0;
 307 }
 308
 309 void __exit ieee80211_debug_exit(void)
 310 {
 311         if (ieee80211_proc) {
 312                 remove_proc_entry("debug_level", ieee80211_proc);
 313                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 314                 ieee80211_proc = NULL;
 315         }
 316 }
 317
 318 #include <linux/moduleparam.h>
 319 module_param(debug, int, 0444);
 320 MODULE_PARM_DESC(debug, "debug output mask");
 321 #endif