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