drivers/staging/rtl8187se/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 #include <net/net_namespace.h>
  55
  56 #include "ieee80211.h"
  57
  58 MODULE_DESCRIPTION("802.11 data/management/control stack");
  59 MODULE_AUTHOR("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
  60 MODULE_LICENSE("GPL");
  61
  62 #define DRV_NAME "ieee80211"
  63
  64 static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
  65 {
  66         if (ieee->networks)
  67                 return 0;
  68
  69         ieee->networks = kmalloc(
  70                 MAX_NETWORK_COUNT * sizeof(struct ieee80211_network),
  71                 GFP_KERNEL);
  72         if (!ieee->networks) {
  73                 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
  74                        ieee->dev->name);
  75                 return -ENOMEM;
  76         }
  77
  78         memset(ieee->networks, 0,
  79                MAX_NETWORK_COUNT * sizeof(struct ieee80211_network));
  80
  81         return 0;
  82 }
  83
  84 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
  85 {
  86         if (!ieee->networks)
  87                 return;
  88         kfree(ieee->networks);
  89         ieee->networks = NULL;
  90 }
  91
  92 static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
  93 {
  94         int i;
  95
  96         INIT_LIST_HEAD(&ieee->network_free_list);
  97         INIT_LIST_HEAD(&ieee->network_list);
  98         for (i = 0; i < MAX_NETWORK_COUNT; i++)
  99                 list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
 100 }
 101
 102
 103 struct net_device *alloc_ieee80211(int sizeof_priv)
 104 {
 105         struct ieee80211_device *ieee;
 106         struct net_device *dev;
 107         int i,err;
 108
 109         IEEE80211_DEBUG_INFO("Initializing...\n");
 110
 111         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
 112         if (!dev) {
 113                 IEEE80211_ERROR("Unable to network device.\n");
 114                 goto failed;
 115         }
 116         ieee = netdev_priv(dev);
 117
 118         ieee->dev = dev;
 119
 120         err = ieee80211_networks_allocate(ieee);
 121         if (err) {
 122                 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
 123                                 err);
 124                 goto failed;
 125         }
 126         ieee80211_networks_initialize(ieee);
 127
 128         /* Default fragmentation threshold is maximum payload size */
 129         ieee->fts = DEFAULT_FTS;
 130         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
 131         ieee->open_wep = 1;
 132
 133         /* Default to enabling full open WEP with host based encrypt/decrypt */
 134         ieee->host_encrypt = 1;
 135         ieee->host_decrypt = 1;
 136         ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
 137
 138         INIT_LIST_HEAD(&ieee->crypt_deinit_list);
 139         init_timer(&ieee->crypt_deinit_timer);
 140         ieee->crypt_deinit_timer.data = (unsigned long)ieee;
 141         ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
 142
 143         spin_lock_init(&ieee->lock);
 144         spin_lock_init(&ieee->wpax_suitlist_lock);
 145
 146         ieee->wpax_type_set = 0;
 147         ieee->wpa_enabled = 0;
 148         ieee->tkip_countermeasures = 0;
 149         ieee->drop_unencrypted = 0;
 150         ieee->privacy_invoked = 0;
 151         ieee->ieee802_1x = 1;
 152         ieee->raw_tx = 0;
 153
 154         ieee80211_softmac_init(ieee);
 155
 156         for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++)
 157                 INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]);
 158
 159         for (i = 0; i < 17; i++) {
 160           ieee->last_rxseq_num[i] = -1;
 161           ieee->last_rxfrag_num[i] = -1;
 162           ieee->last_packet_time[i] = 0;
 163         }
 164 //These function were added to load crypte module autoly
 165         ieee80211_tkip_null();
 166         ieee80211_wep_null();
 167         ieee80211_ccmp_null();
 168         return dev;
 169
 170  failed:
 171         if (dev)
 172                 free_netdev(dev);
 173         return NULL;
 174 }
 175
 176
 177 void free_ieee80211(struct net_device *dev)
 178 {
 179         struct ieee80211_device *ieee = netdev_priv(dev);
 180
 181         int i;
 182         struct list_head *p, *q;
 183
 184
 185         ieee80211_softmac_free(ieee);
 186         del_timer_sync(&ieee->crypt_deinit_timer);
 187         ieee80211_crypt_deinit_entries(ieee, 1);
 188
 189         for (i = 0; i < WEP_KEYS; i++) {
 190                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
 191                 if (crypt) {
 192                         if (crypt->ops) {
 193                                 crypt->ops->deinit(crypt->priv);
 194                                 module_put(crypt->ops->owner);
 195                         }
 196                         kfree(crypt);
 197                         ieee->crypt[i] = NULL;
 198                 }
 199         }
 200
 201         ieee80211_networks_free(ieee);
 202
 203         for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++) {
 204                 list_for_each_safe(p, q, &ieee->ibss_mac_hash[i]) {
 205                         kfree(list_entry(p, struct ieee_ibss_seq, list));
 206                         list_del(p);
 207                 }
 208         }
 209
 210
 211         free_netdev(dev);
 212 }
 213
 214 //#ifdef CONFIG_IEEE80211_DEBUG
 215 #if 0
 216
 217 static int debug = 0;
 218 u32 ieee80211_debug_level = 0;
 219 struct proc_dir_entry *ieee80211_proc = NULL;
 220
 221 static int show_debug_level(char *page, char **start, off_t offset,
 222                             int count, int *eof, void *data)
 223 {
 224         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 225 }
 226
 227 static int store_debug_level(struct file *file, const char *buffer,
 228                              unsigned long count, void *data)
 229 {
 230         char buf[] = "0x00000000";
 231         unsigned long len = min(sizeof(buf) - 1, (u32)count);
 232         char *p = (char *)buf;
 233         unsigned long val;
 234
 235         if (copy_from_user(buf, buffer, len))
 236                 return count;
 237         buf[len] = 0;
 238         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
 239                 p++;
 240                 if (p[0] == 'x' || p[0] == 'X')
 241                         p++;
 242                 val = simple_strtoul(p, &p, 16);
 243         } else
 244                 val = simple_strtoul(p, &p, 10);
 245         if (p == buf)
 246                 printk(KERN_INFO DRV_NAME
 247                        ": %s is not in hex or decimal form.\n", buf);
 248         else
 249                 ieee80211_debug_level = val;
 250
 251         return strnlen(buf, count);
 252 }
 253
 254 static int __init ieee80211_init(void)
 255 {
 256         struct proc_dir_entry *e;
 257
 258         ieee80211_debug_level = debug;
 259         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
 260         if (ieee80211_proc == NULL) {
 261                 IEEE80211_ERROR("Unable to create " DRV_NAME
 262                                 " proc directory\n");
 263                 return -EIO;
 264         }
 265         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 266                               ieee80211_proc);
 267         if (!e) {
 268                 remove_proc_entry(DRV_NAME, proc_net);
 269                 ieee80211_proc = NULL;
 270                 return -EIO;
 271         }
 272         e->read_proc = show_debug_level;
 273         e->write_proc = store_debug_level;
 274         e->data = NULL;
 275
 276         return 0;
 277 }
 278
 279 static void __exit ieee80211_exit(void)
 280 {
 281         if (ieee80211_proc) {
 282                 remove_proc_entry("debug_level", ieee80211_proc);
 283                 remove_proc_entry(DRV_NAME, proc_net);
 284                 ieee80211_proc = NULL;
 285         }
 286 }
 287
 288 #include <linux/moduleparam.h>
 289 module_param(debug, int, 0444);
 290 MODULE_PARM_DESC(debug, "debug output mask");
 291
 292
 293 module_exit(ieee80211_exit);
 294 module_init(ieee80211_init);
 295 #endif
 296
 297 #if 0
 298 EXPORT_SYMBOL(alloc_ieee80211);
 299 EXPORT_SYMBOL(free_ieee80211);
 300 #endif