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/version.h>
  49 #include <linux/wireless.h>
  50 #include <linux/etherdevice.h>
  51 #include <asm/uaccess.h>
  52 #include <net/arp.h>
  53
  54 #include "ieee80211.h"
  55
  56 MODULE_DESCRIPTION("802.11 data/management/control stack");
  57 MODULE_AUTHOR("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
  58 MODULE_LICENSE("GPL");
  59
  60 #define DRV_NAME "ieee80211"
  61
  62 static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
  63 {
  64         if (ieee->networks)
  65                 return 0;
  66
  67         ieee->networks = kcalloc(
  68                 MAX_NETWORK_COUNT, sizeof(struct ieee80211_network),
  69                 GFP_KERNEL);
  70         if (!ieee->networks) {
  71                 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
  72                         ieee->dev->name);
  73                 return -ENOMEM;
  74         }
  75
  76         return 0;
  77 }
  78
  79 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
  80 {
  81         if (!ieee->networks)
  82                 return;
  83         kfree(ieee->networks);
  84         ieee->networks = NULL;
  85 }
  86
  87 static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
  88 {
  89         int i;
  90
  91         INIT_LIST_HEAD(&ieee->network_free_list);
  92         INIT_LIST_HEAD(&ieee->network_list);
  93         for (i = 0; i < MAX_NETWORK_COUNT; i++)
  94                 list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
  95 }
  96
  97
  98 struct net_device *alloc_ieee80211(int sizeof_priv)
  99 {
 100         struct ieee80211_device *ieee;
 101         struct net_device *dev;
 102         int i, err;
 103
 104         IEEE80211_DEBUG_INFO("Initializing...\n");
 105
 106         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
 107         if (!dev) {
 108                 IEEE80211_ERROR("Unable to network device.\n");
 109                 goto failed;
 110         }
 111
 112         ieee = netdev_priv(dev);
 113
 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
 146         /* added by WB */
 147         atomic_set(&(ieee->atm_chnlop), 0);
 148         atomic_set(&(ieee->atm_swbw), 0);
 149
 150         ieee->wpax_type_set = 0;
 151         ieee->wpa_enabled = 0;
 152         ieee->tkip_countermeasures = 0;
 153         ieee->drop_unencrypted = 0;
 154         ieee->privacy_invoked = 0;
 155         ieee->ieee802_1x = 1;
 156         ieee->raw_tx = 0;
 157         /* ieee->hwsec_support = 1; default support hw security: use module_param instead */
 158         ieee->hwsec_active = 0; /* disable hwsec, switch it on when necessary */
 159
 160         ieee80211_softmac_init(ieee);
 161
 162         ieee->pHTInfo = kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
 163         if (ieee->pHTInfo == NULL)
 164         {
 165                 IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n");
 166                 return NULL;
 167         }
 168         HTUpdateDefaultSetting(ieee);
 169         HTInitializeHTInfo(ieee); /* may move to other place */
 170         TSInitialize(ieee);
 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         /* Functions to load crypt module automatically */
 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         return NULL;
 191 }
 192
 193
 194 void free_ieee80211(struct net_device *dev)
 195 {
 196         struct ieee80211_device *ieee = netdev_priv(dev);
 197         int i;
 198         if (ieee->pHTInfo != NULL)
 199         {
 200                 kfree(ieee->pHTInfo);
 201                 ieee->pHTInfo = NULL;
 202         }
 203         RemoveAllTS(ieee);
 204         ieee80211_softmac_free(ieee);
 205         del_timer_sync(&ieee->crypt_deinit_timer);
 206         ieee80211_crypt_deinit_entries(ieee, 1);
 207
 208         for (i = 0; i < WEP_KEYS; i++) {
 209                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
 210                 if (crypt) {
 211                         if (crypt->ops)
 212                                 crypt->ops->deinit(crypt->priv);
 213                         kfree(crypt);
 214                         ieee->crypt[i] = NULL;
 215                 }
 216         }
 217
 218         ieee80211_networks_free(ieee);
 219         free_netdev(dev);
 220 }
 221
 222 #ifdef CONFIG_IEEE80211_DEBUG
 223
 224 u32 ieee80211_debug_level = 0;
 225 static int debug = \
 226         /* IEEE80211_DL_INFO    | */
 227         /* IEEE80211_DL_WX      | */
 228         /* IEEE80211_DL_SCAN    | */
 229         /* IEEE80211_DL_STATE   | */
 230         /* IEEE80211_DL_MGMT    | */
 231         /* IEEE80211_DL_FRAG    | */
 232         /* IEEE80211_DL_EAP     | */
 233         /* IEEE80211_DL_DROP    | */
 234         /* IEEE80211_DL_TX      | */
 235         /* IEEE80211_DL_RX      | */
 236         /* IEEE80211_DL_QOS     | */
 237         /* IEEE80211_DL_HT      | */
 238         /* IEEE80211_DL_TS      | */
 239         /* IEEE80211_DL_BA      | */
 240         /* IEEE80211_DL_REORDER | */
 241         /* IEEE80211_DL_TRACE   | */
 242         /* IEEE80211_DL_DATA    | */
 243         IEEE80211_DL_ERR        /* always open this flag to show error out */
 244         ;
 245 struct proc_dir_entry *ieee80211_proc = NULL;
 246
 247 static int show_debug_level(char *page, char **start, off_t offset,
 248                         int count, int *eof, void *data)
 249 {
 250         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 251 }
 252
 253 static int store_debug_level(struct file *file, const char *buffer,
 254                         unsigned long count, void *data)
 255 {
 256         char buf[] = "0x00000000";
 257         unsigned long len = min(sizeof(buf) - 1, (u32)count);
 258         char *p = (char *)buf;
 259         unsigned long val;
 260
 261         if (copy_from_user(buf, buffer, len))
 262                 return count;
 263         buf[len] = 0;
 264         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
 265                 p++;
 266                 if (p[0] == 'x' || p[0] == 'X')
 267                         p++;
 268                 val = simple_strtoul(p, &p, 16);
 269         } else
 270                 val = simple_strtoul(p, &p, 10);
 271         if (p == buf)
 272                 printk(KERN_INFO DRV_NAME
 273                         ": %s is not in hex or decimal form.\n", buf);
 274         else
 275                 ieee80211_debug_level = val;
 276
 277         return strnlen(buf, count);
 278 }
 279
 280 extern int ieee80211_crypto_init(void);
 281 extern void ieee80211_crypto_deinit(void);
 282 extern int ieee80211_crypto_tkip_init(void);
 283 extern void ieee80211_crypto_tkip_exit(void);
 284 extern int ieee80211_crypto_ccmp_init(void);
 285 extern void ieee80211_crypto_ccmp_exit(void);
 286 extern int ieee80211_crypto_wep_init(void);
 287 extern void ieee80211_crypto_wep_exit(void);
 288
 289 int __init ieee80211_rtl_init(void)
 290 {
 291         struct proc_dir_entry *e;
 292         int retval;
 293
 294         retval = ieee80211_crypto_init();
 295         if (retval)
 296                 return retval;
 297         retval = ieee80211_crypto_tkip_init();
 298         if (retval) {
 299                 ieee80211_crypto_deinit();
 300                 return retval;
 301         }
 302         retval = ieee80211_crypto_ccmp_init();
 303         if (retval) {
 304                 ieee80211_crypto_tkip_exit();
 305                 ieee80211_crypto_deinit();
 306                 return retval;
 307         }
 308         retval = ieee80211_crypto_wep_init();
 309         if (retval) {
 310                 ieee80211_crypto_ccmp_exit();
 311                 ieee80211_crypto_tkip_exit();
 312                 ieee80211_crypto_deinit();
 313                 return retval;
 314         }
 315
 316         ieee80211_debug_level = debug;
 317         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
 318         if (ieee80211_proc == NULL) {
 319                 IEEE80211_ERROR("Unable to create " DRV_NAME
 320                                 " proc directory\n");
 321                 return -EIO;
 322         }
 323         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 324                         ieee80211_proc);
 325         if (!e) {
 326                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 327                 ieee80211_proc = NULL;
 328                 return -EIO;
 329         }
 330         e->read_proc = show_debug_level;
 331         e->write_proc = store_debug_level;
 332         e->data = NULL;
 333
 334         return 0;
 335 }
 336
 337 void __exit ieee80211_rtl_exit(void)
 338 {
 339         if (ieee80211_proc) {
 340                 remove_proc_entry("debug_level", ieee80211_proc);
 341                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 342                 ieee80211_proc = NULL;
 343         }
 344         ieee80211_crypto_wep_exit();
 345         ieee80211_crypto_ccmp_exit();
 346         ieee80211_crypto_tkip_exit();
 347         ieee80211_crypto_deinit();
 348 }
 349
 350 #include <linux/moduleparam.h>
 351 module_param(debug, int, 0444);
 352 MODULE_PARM_DESC(debug, "debug output mask");
 353
 354
 355 #endif
 356