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/errno.h>
  35 #include <linux/if_arp.h>
  36 #include <linux/in6.h>
  37 #include <linux/in.h>
  38 #include <linux/ip.h>
  39 #include <linux/kernel.h>
  40 #include <linux/module.h>
  41 #include <linux/netdevice.h>
  42 #include <linux/pci.h>
  43 #include <linux/proc_fs.h>
  44 #include <linux/skbuff.h>
  45 #include <linux/slab.h>
  46 #include <linux/tcp.h>
  47 #include <linux/types.h>
  48 #include <linux/wireless.h>
  49 #include <linux/etherdevice.h>
  50 #include <asm/uaccess.h>
  51 #include <net/arp.h>
  52
  53 #include "ieee80211.h"
  54
  55 MODULE_DESCRIPTION("802.11 data/management/control stack");
  56 MODULE_AUTHOR("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
  57 MODULE_LICENSE("GPL");
  58
  59 #define DRV_NAME "ieee80211"
  60
  61 static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
  62 {
  63         if (ieee->networks)
  64                 return 0;
  65
  66         ieee->networks = kcalloc(
  67                 MAX_NETWORK_COUNT, sizeof(struct ieee80211_network),
  68                 GFP_KERNEL);
  69         if (!ieee->networks) {
  70                 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
  71                         ieee->dev->name);
  72                 return -ENOMEM;
  73         }
  74
  75         return 0;
  76 }
  77
  78 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
  79 {
  80         if (!ieee->networks)
  81                 return;
  82         kfree(ieee->networks);
  83         ieee->networks = NULL;
  84 }
  85
  86 static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
  87 {
  88         int i;
  89
  90         INIT_LIST_HEAD(&ieee->network_free_list);
  91         INIT_LIST_HEAD(&ieee->network_list);
  92         for (i = 0; i < MAX_NETWORK_COUNT; i++)
  93                 list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
  94 }
  95
  96
  97 struct net_device *alloc_ieee80211(int sizeof_priv)
  98 {
  99         struct ieee80211_device *ieee;
 100         struct net_device *dev;
 101         int i, err;
 102
 103         IEEE80211_DEBUG_INFO("Initializing...\n");
 104
 105         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
 106         if (!dev) {
 107                 IEEE80211_ERROR("Unable to network device.\n");
 108                 goto failed;
 109         }
 110
 111         ieee = netdev_priv(dev);
 112
 113         memset(ieee, 0, sizeof(struct ieee80211_device) + sizeof_priv);
 114         ieee->dev = dev;
 115
 116         err = ieee80211_networks_allocate(ieee);
 117         if (err) {
 118                 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
 119                                 err);
 120                 goto failed;
 121         }
 122         ieee80211_networks_initialize(ieee);
 123
 124
 125         /* Default fragmentation threshold is maximum payload size */
 126         ieee->fts = DEFAULT_FTS;
 127         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
 128         ieee->open_wep = 1;
 129
 130         /* Default to enabling full open WEP with host based encrypt/decrypt */
 131         ieee->host_encrypt = 1;
 132         ieee->host_decrypt = 1;
 133         ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
 134
 135         INIT_LIST_HEAD(&ieee->crypt_deinit_list);
 136         init_timer(&ieee->crypt_deinit_timer);
 137         ieee->crypt_deinit_timer.data = (unsigned long)ieee;
 138         ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
 139
 140         spin_lock_init(&ieee->lock);
 141         spin_lock_init(&ieee->wpax_suitlist_lock);
 142         spin_lock_init(&ieee->bw_spinlock);
 143         spin_lock_init(&ieee->reorder_spinlock);
 144
 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; default 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         for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++)
 171                 INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]);
 172
 173         for (i = 0; i < 17; i++) {
 174                 ieee->last_rxseq_num[i] = -1;
 175                 ieee->last_rxfrag_num[i] = -1;
 176                 ieee->last_packet_time[i] = 0;
 177         }
 178
 179         /* Functions to load crypt module automatically */
 180         ieee80211_tkip_null();
 181         ieee80211_wep_null();
 182         ieee80211_ccmp_null();
 183
 184         return dev;
 185
 186 failed:
 187         if (dev)
 188                 free_netdev(dev);
 189         return NULL;
 190 }
 191
 192
 193 void free_ieee80211(struct net_device *dev)
 194 {
 195         struct ieee80211_device *ieee = netdev_priv(dev);
 196         int i;
 197         kfree(ieee->pHTInfo);
 198         ieee->pHTInfo = NULL;
 199         RemoveAllTS(ieee);
 200         ieee80211_softmac_free(ieee);
 201         del_timer_sync(&ieee->crypt_deinit_timer);
 202         ieee80211_crypt_deinit_entries(ieee, 1);
 203
 204         for (i = 0; i < WEP_KEYS; i++) {
 205                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
 206                 if (crypt) {
 207                         if (crypt->ops)
 208                                 crypt->ops->deinit(crypt->priv);
 209                         kfree(crypt);
 210                         ieee->crypt[i] = NULL;
 211                 }
 212         }
 213
 214         ieee80211_networks_free(ieee);
 215         free_netdev(dev);
 216 }
 217
 218 #ifdef CONFIG_IEEE80211_DEBUG
 219
 220 u32 ieee80211_debug_level = 0;
 221 static int debug =
 222         /* IEEE80211_DL_INFO    | */
 223         /* IEEE80211_DL_WX      | */
 224         /* IEEE80211_DL_SCAN    | */
 225         /* IEEE80211_DL_STATE   | */
 226         /* IEEE80211_DL_MGMT    | */
 227         /* IEEE80211_DL_FRAG    | */
 228         /* IEEE80211_DL_EAP     | */
 229         /* IEEE80211_DL_DROP    | */
 230         /* IEEE80211_DL_TX      | */
 231         /* IEEE80211_DL_RX      | */
 232         /* IEEE80211_DL_QOS     | */
 233         /* IEEE80211_DL_HT      | */
 234         /* IEEE80211_DL_TS      | */
 235         /* IEEE80211_DL_BA      | */
 236         /* IEEE80211_DL_REORDER | */
 237         /* IEEE80211_DL_TRACE   | */
 238         /* IEEE80211_DL_DATA    | */
 239         IEEE80211_DL_ERR        /* always open this flag to show error out */
 240         ;
 241 struct proc_dir_entry *ieee80211_proc = NULL;
 242
 243 static int show_debug_level(char *page, char **start, off_t offset,
 244                         int count, int *eof, void *data)
 245 {
 246         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 247 }
 248
 249 static int store_debug_level(struct file *file, const char *buffer,
 250                         unsigned long count, void *data)
 251 {
 252         char buf[] = "0x00000000";
 253         unsigned long len = min(sizeof(buf) - 1, (u32)count);
 254         char *p = (char *)buf;
 255         unsigned long val;
 256
 257         if (copy_from_user(buf, buffer, len))
 258                 return count;
 259         buf[len] = 0;
 260         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
 261                 p++;
 262                 if (p[0] == 'x' || p[0] == 'X')
 263                         p++;
 264                 val = simple_strtoul(p, &p, 16);
 265         } else
 266                 val = simple_strtoul(p, &p, 10);
 267         if (p == buf)
 268                 printk(KERN_INFO DRV_NAME
 269                         ": %s is not in hex or decimal form.\n", buf);
 270         else
 271                 ieee80211_debug_level = val;
 272
 273         return strnlen(buf, count);
 274 }
 275
 276 extern int ieee80211_crypto_init(void);
 277 extern void ieee80211_crypto_deinit(void);
 278 extern int ieee80211_crypto_tkip_init(void);
 279 extern void ieee80211_crypto_tkip_exit(void);
 280 extern int ieee80211_crypto_ccmp_init(void);
 281 extern void ieee80211_crypto_ccmp_exit(void);
 282 extern int ieee80211_crypto_wep_init(void);
 283 extern void ieee80211_crypto_wep_exit(void);
 284
 285 int __init ieee80211_rtl_init(void)
 286 {
 287         struct proc_dir_entry *e;
 288         int retval;
 289
 290         retval = ieee80211_crypto_init();
 291         if (retval)
 292                 return retval;
 293         retval = ieee80211_crypto_tkip_init();
 294         if (retval) {
 295                 ieee80211_crypto_deinit();
 296                 return retval;
 297         }
 298         retval = ieee80211_crypto_ccmp_init();
 299         if (retval) {
 300                 ieee80211_crypto_tkip_exit();
 301                 ieee80211_crypto_deinit();
 302                 return retval;
 303         }
 304         retval = ieee80211_crypto_wep_init();
 305         if (retval) {
 306                 ieee80211_crypto_ccmp_exit();
 307                 ieee80211_crypto_tkip_exit();
 308                 ieee80211_crypto_deinit();
 309                 return retval;
 310         }
 311
 312         ieee80211_debug_level = debug;
 313         ieee80211_proc = proc_mkdir(DRV_NAME, init_net.proc_net);
 314         if (ieee80211_proc == NULL) {
 315                 IEEE80211_ERROR("Unable to create " DRV_NAME
 316                                 " proc directory\n");
 317                 return -EIO;
 318         }
 319         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 320                         ieee80211_proc);
 321         if (!e) {
 322                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 323                 ieee80211_proc = NULL;
 324                 return -EIO;
 325         }
 326         e->read_proc = show_debug_level;
 327         e->write_proc = store_debug_level;
 328         e->data = NULL;
 329
 330         return 0;
 331 }
 332
 333 void __exit ieee80211_rtl_exit(void)
 334 {
 335         if (ieee80211_proc) {
 336                 remove_proc_entry("debug_level", ieee80211_proc);
 337                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 338                 ieee80211_proc = NULL;
 339         }
 340         ieee80211_crypto_wep_exit();
 341         ieee80211_crypto_ccmp_exit();
 342         ieee80211_crypto_tkip_exit();
 343         ieee80211_crypto_deinit();
 344 }
 345
 346 #include <linux/moduleparam.h>
 347 module_param(debug, int, 0444);
 348 MODULE_PARM_DESC(debug, "debug output mask");
 349
 350
 351 #endif
 352