hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Staging: rtl8192u: make it compile 

Add it to staging Kbuild and fixes some API differences that prevents
compilation.

It seems that the ieee80211 stack is very close to rtl8192su one.

Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Mauro Carvalho Chehab 2009-11-03 07:17:24 -02:00 committed by Greg Kroah-Hartman
parent 8fc8598e61
commit f61fb9356d
10 changed files with 108 additions and 575 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/staging/Kconfig
View File

@ -77,6 +77,8 @@ source "drivers/staging/rtl8187se/Kconfig"
source "drivers/staging/rtl8192su/Kconfig" source "drivers/staging/rtl8192su/Kconfig"
source "drivers/staging/rtl8192u/Kconfig"
source "drivers/staging/rtl8192e/Kconfig" source "drivers/staging/rtl8192e/Kconfig"
source "drivers/staging/mimio/Kconfig" source "drivers/staging/mimio/Kconfig"

1
drivers/staging/Makefile
View File

@ -21,6 +21,7 @@ obj-$(CONFIG_PANEL) += panel/
obj-$(CONFIG_ALTERA_PCIE_CHDMA) += altpciechdma/ obj-$(CONFIG_ALTERA_PCIE_CHDMA) += altpciechdma/
obj-$(CONFIG_R8187SE) += rtl8187se/ obj-$(CONFIG_R8187SE) += rtl8187se/
obj-$(CONFIG_RTL8192SU) += rtl8192su/ obj-$(CONFIG_RTL8192SU) += rtl8192su/
obj-$(CONFIG_RTL8192U) += rtl8192u/
obj-$(CONFIG_RTL8192E) += rtl8192e/ obj-$(CONFIG_RTL8192E) += rtl8192e/
obj-$(CONFIG_INPUT_MIMIO) += mimio/ obj-$(CONFIG_INPUT_MIMIO) += mimio/
obj-$(CONFIG_TRANZPORT) += frontier/ obj-$(CONFIG_TRANZPORT) += frontier/

1
drivers/staging/rtl8192u/Makefile
View File

@ -10,6 +10,7 @@ EXTRA_CFLAGS += -DTHOMAS_BEACON -DTHOMAS_TASKLET -DTHOMAS_SKB -DTHOMAS_TURBO
#EXTRA_CFLAGS += -DUSB_RX_AGGREGATION_SUPPORT #EXTRA_CFLAGS += -DUSB_RX_AGGREGATION_SUPPORT
EXTRA_CFLAGS += -DUSE_ONE_PIPE EXTRA_CFLAGS += -DUSE_ONE_PIPE
EXTRA_CFLAGS += -DENABLE_DOT11D EXTRA_CFLAGS += -DENABLE_DOT11D
EXTRA_CFLAGS += -Idrivers/staging/rtl8192u/ieee80211
r8192u_usb-objs := r8192U_core.o r8180_93cx6.o r8192U_wx.o \ r8192u_usb-objs := r8192U_core.o r8180_93cx6.o r8192U_wx.o \
r8190_rtl8256.o r819xU_phy.o r819xU_firmware.o \ r8190_rtl8256.o r819xU_phy.o r819xU_firmware.o \

6
drivers/staging/rtl8192u/ieee80211.h
View File

@ -39,9 +39,9 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/wireless.h> #include <linux/wireless.h>
#include "../../ieee80211/rtl819x_HT.h" #include "ieee80211/rtl819x_HT.h"
#include "../../ieee80211/rtl819x_BA.h" #include "ieee80211/rtl819x_BA.h"
#include "../../ieee80211/rtl819x_TS.h" #include "ieee80211/rtl819x_TS.h"
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)) #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
#ifndef bool #ifndef bool

35
drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c
View File

@ -53,14 +53,8 @@ void ieee80211_crypt_deinit_entries(struct ieee80211_device *ieee,
list_del(ptr); list_del(ptr);
if (entry->ops) { if (entry->ops)
entry->ops->deinit(entry->priv); entry->ops->deinit(entry->priv);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
module_put(entry->ops->owner);
#else
__MOD_DEC_USE_COUNT(entry->ops->owner);
#endif
}
kfree(entry); kfree(entry);
} }
} }
@ -208,8 +202,7 @@ static struct ieee80211_crypto_ops ieee80211_crypt_null = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}; };
int __init ieee80211_crypto_init(void)
static int __init ieee80211_crypto_init(void)
{ {
int ret = -ENOMEM; int ret = -ENOMEM;
@ -230,8 +223,7 @@ out:
return ret; return ret;
} }
void __exit ieee80211_crypto_deinit(void)
static void __exit ieee80211_crypto_deinit(void)
{ {
struct list_head *ptr, *n; struct list_head *ptr, *n;
@ -250,24 +242,3 @@ static void __exit ieee80211_crypto_deinit(void)
kfree(hcrypt); kfree(hcrypt);
} }
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
EXPORT_SYMBOL(ieee80211_crypt_deinit_entries);
EXPORT_SYMBOL(ieee80211_crypt_deinit_handler);
EXPORT_SYMBOL(ieee80211_crypt_delayed_deinit);
EXPORT_SYMBOL(ieee80211_register_crypto_ops);
EXPORT_SYMBOL(ieee80211_unregister_crypto_ops);
EXPORT_SYMBOL(ieee80211_get_crypto_ops);
#else
EXPORT_SYMBOL_NOVERS(ieee80211_crypt_deinit_entries);
EXPORT_SYMBOL_NOVERS(ieee80211_crypt_deinit_handler);
EXPORT_SYMBOL_NOVERS(ieee80211_crypt_delayed_deinit);
EXPORT_SYMBOL_NOVERS(ieee80211_register_crypto_ops);
EXPORT_SYMBOL_NOVERS(ieee80211_unregister_crypto_ops);
EXPORT_SYMBOL_NOVERS(ieee80211_get_crypto_ops);
#endif
module_init(ieee80211_crypto_init);
module_exit(ieee80211_crypto_deinit);

62
drivers/staging/rtl8192u/ieee80211/ieee80211_crypt_ccmp.c
View File

@ -24,27 +24,13 @@
#include "ieee80211.h" #include "ieee80211.h"
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
#include "rtl_crypto.h"
#else
#include <linux/crypto.h> #include <linux/crypto.h>
#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
#include <asm/scatterlist.h>
#else
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#endif
//#include <asm/scatterlist.h>
MODULE_AUTHOR("Jouni Malinen"); MODULE_AUTHOR("Jouni Malinen");
MODULE_DESCRIPTION("Host AP crypt: CCMP"); MODULE_DESCRIPTION("Host AP crypt: CCMP");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
#ifndef OPENSUSE_SLED
#define OPENSUSE_SLED 0
#endif
#define AES_BLOCK_LEN 16 #define AES_BLOCK_LEN 16
#define CCMP_HDR_LEN 8 #define CCMP_HDR_LEN 8
#define CCMP_MIC_LEN 8 #define CCMP_MIC_LEN 8
@ -75,21 +61,7 @@ struct ieee80211_ccmp_data {
void ieee80211_ccmp_aes_encrypt(struct crypto_tfm *tfm, void ieee80211_ccmp_aes_encrypt(struct crypto_tfm *tfm,
const u8 pt[16], u8 ct[16]) const u8 pt[16], u8 ct[16])
{ {
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
struct scatterlist src, dst;
src.page = virt_to_page(pt);
src.offset = offset_in_page(pt);
src.length = AES_BLOCK_LEN;
dst.page = virt_to_page(ct);
dst.offset = offset_in_page(ct);
dst.length = AES_BLOCK_LEN;
crypto_cipher_encrypt(tfm, &dst, &src, AES_BLOCK_LEN);
#else
crypto_cipher_encrypt_one((void*)tfm, ct, pt); crypto_cipher_encrypt_one((void*)tfm, ct, pt);
#endif
} }
static void * ieee80211_ccmp_init(int key_idx) static void * ieee80211_ccmp_init(int key_idx)
@ -102,14 +74,6 @@ static void * ieee80211_ccmp_init(int key_idx)
memset(priv, 0, sizeof(*priv)); memset(priv, 0, sizeof(*priv));
priv->key_idx = key_idx; priv->key_idx = key_idx;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
priv->tfm = crypto_alloc_tfm("aes", 0);
if (priv->tfm == NULL) {
printk(KERN_DEBUG "ieee80211_crypt_ccmp: could not allocate "
"crypto API aes\n");
goto fail;
}
#else
priv->tfm = (void*)crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC); priv->tfm = (void*)crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
if (IS_ERR(priv->tfm)) { if (IS_ERR(priv->tfm)) {
printk(KERN_DEBUG "ieee80211_crypt_ccmp: could not allocate " printk(KERN_DEBUG "ieee80211_crypt_ccmp: could not allocate "
@ -117,17 +81,13 @@ static void * ieee80211_ccmp_init(int key_idx)
priv->tfm = NULL; priv->tfm = NULL;
goto fail; goto fail;
} }
#endif
return priv; return priv;
fail: fail:
if (priv) { if (priv) {
if (priv->tfm) if (priv->tfm)
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21))
crypto_free_tfm(priv->tfm);
#else
crypto_free_cipher((void*)priv->tfm); crypto_free_cipher((void*)priv->tfm);
#endif
kfree(priv); kfree(priv);
} }
@ -138,12 +98,9 @@ fail:
static void ieee80211_ccmp_deinit(void *priv) static void ieee80211_ccmp_deinit(void *priv)
{ {
struct ieee80211_ccmp_data *_priv = priv; struct ieee80211_ccmp_data *_priv = priv;
if (_priv && _priv->tfm) if (_priv && _priv->tfm)
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21))
crypto_free_tfm(_priv->tfm);
#else
crypto_free_cipher((void*)_priv->tfm); crypto_free_cipher((void*)_priv->tfm);
#endif
kfree(priv); kfree(priv);
} }
@ -512,23 +469,12 @@ static struct ieee80211_crypto_ops ieee80211_crypt_ccmp = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}; };
int __init ieee80211_crypto_ccmp_init(void)
static int __init ieee80211_crypto_ccmp_init(void)
{ {
return ieee80211_register_crypto_ops(&ieee80211_crypt_ccmp); return ieee80211_register_crypto_ops(&ieee80211_crypt_ccmp);
} }
void __exit ieee80211_crypto_ccmp_exit(void)
static void __exit ieee80211_crypto_ccmp_exit(void)
{ {
ieee80211_unregister_crypto_ops(&ieee80211_crypt_ccmp); ieee80211_unregister_crypto_ops(&ieee80211_crypt_ccmp);
} }
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
EXPORT_SYMBOL(ieee80211_ccmp_null);
#else
EXPORT_SYMBOL_NOVERS(ieee80211_ccmp_null);
#endif
module_init(ieee80211_crypto_ccmp_init);
module_exit(ieee80211_crypto_ccmp_exit);

270
drivers/staging/rtl8192u/ieee80211/ieee80211_crypt_tkip.c
View File

@ -22,33 +22,15 @@
#include <asm/string.h> #include <asm/string.h>
#include "ieee80211.h" #include "ieee80211.h"
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,20))
//#include "crypto_compat.h"
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
#include "rtl_crypto.h"
#else
#include <linux/crypto.h> #include <linux/crypto.h>
#endif
//#include <asm/scatterlist.h>
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
#include <asm/scatterlist.h>
#else
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#endif
#include <linux/crc32.h> #include <linux/crc32.h>
MODULE_AUTHOR("Jouni Malinen"); MODULE_AUTHOR("Jouni Malinen");
MODULE_DESCRIPTION("Host AP crypt: TKIP"); MODULE_DESCRIPTION("Host AP crypt: TKIP");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
#ifndef OPENSUSE_SLED
#define OPENSUSE_SLED 0
#endif
struct ieee80211_tkip_data { struct ieee80211_tkip_data {
#define TKIP_KEY_LEN 32 #define TKIP_KEY_LEN 32
u8 key[TKIP_KEY_LEN]; u8 key[TKIP_KEY_LEN];
@ -71,17 +53,12 @@ struct ieee80211_tkip_data {
u32 dot11RSNAStatsTKIPLocalMICFailures; u32 dot11RSNAStatsTKIPLocalMICFailures;
int key_idx; int key_idx;
#if((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)) || (OPENSUSE_SLED))
struct crypto_blkcipher *rx_tfm_arc4; struct crypto_blkcipher *rx_tfm_arc4;
struct crypto_hash *rx_tfm_michael; struct crypto_hash *rx_tfm_michael;
struct crypto_blkcipher *tx_tfm_arc4; struct crypto_blkcipher *tx_tfm_arc4;
struct crypto_hash *tx_tfm_michael; struct crypto_hash *tx_tfm_michael;
#else
struct crypto_tfm *tx_tfm_arc4;
struct crypto_tfm *tx_tfm_michael;
struct crypto_tfm *rx_tfm_arc4;
struct crypto_tfm *rx_tfm_michael;
#endif
/* scratch buffers for virt_to_page() (crypto API) */ /* scratch buffers for virt_to_page() (crypto API) */
u8 rx_hdr[16], tx_hdr[16]; u8 rx_hdr[16], tx_hdr[16];
}; };
@ -95,35 +72,7 @@ static void * ieee80211_tkip_init(int key_idx)
goto fail; goto fail;
memset(priv, 0, sizeof(*priv)); memset(priv, 0, sizeof(*priv));
priv->key_idx = key_idx; priv->key_idx = key_idx;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
priv->tx_tfm_arc4 = crypto_alloc_tfm("arc4", 0);
if (priv->tx_tfm_arc4 == NULL) {
printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
"crypto API arc4\n");
goto fail;
}
priv->tx_tfm_michael = crypto_alloc_tfm("michael_mic", 0);
if (priv->tx_tfm_michael == NULL) {
printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
"crypto API michael_mic\n");
goto fail;
}
priv->rx_tfm_arc4 = crypto_alloc_tfm("arc4", 0);
if (priv->rx_tfm_arc4 == NULL) {
printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
"crypto API arc4\n");
goto fail;
}
priv->rx_tfm_michael = crypto_alloc_tfm("michael_mic", 0);
if (priv->rx_tfm_michael == NULL) {
printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
"crypto API michael_mic\n");
goto fail;
}
#else
priv->tx_tfm_arc4 = crypto_alloc_blkcipher("ecb(arc4)", 0, priv->tx_tfm_arc4 = crypto_alloc_blkcipher("ecb(arc4)", 0,
CRYPTO_ALG_ASYNC); CRYPTO_ALG_ASYNC);
if (IS_ERR(priv->tx_tfm_arc4)) { if (IS_ERR(priv->tx_tfm_arc4)) {
@ -159,22 +108,11 @@ static void * ieee80211_tkip_init(int key_idx)
priv->rx_tfm_michael = NULL; priv->rx_tfm_michael = NULL;
goto fail; goto fail;
} }
#endif
return priv; return priv;
fail: fail:
if (priv) { if (priv) {
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
if (priv->tx_tfm_michael)
crypto_free_tfm(priv->tx_tfm_michael);
if (priv->tx_tfm_arc4)
crypto_free_tfm(priv->tx_tfm_arc4);
if (priv->rx_tfm_michael)
crypto_free_tfm(priv->rx_tfm_michael);
if (priv->rx_tfm_arc4)
crypto_free_tfm(priv->rx_tfm_arc4);
#else
if (priv->tx_tfm_michael) if (priv->tx_tfm_michael)
crypto_free_hash(priv->tx_tfm_michael); crypto_free_hash(priv->tx_tfm_michael);
if (priv->tx_tfm_arc4) if (priv->tx_tfm_arc4)
@ -183,7 +121,6 @@ fail:
crypto_free_hash(priv->rx_tfm_michael); crypto_free_hash(priv->rx_tfm_michael);
if (priv->rx_tfm_arc4) if (priv->rx_tfm_arc4)
crypto_free_blkcipher(priv->rx_tfm_arc4); crypto_free_blkcipher(priv->rx_tfm_arc4);
#endif
kfree(priv); kfree(priv);
} }
@ -194,16 +131,7 @@ fail:
static void ieee80211_tkip_deinit(void *priv) static void ieee80211_tkip_deinit(void *priv)
{ {
struct ieee80211_tkip_data *_priv = priv; struct ieee80211_tkip_data *_priv = priv;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
if (_priv->tx_tfm_michael)
crypto_free_tfm(_priv->tx_tfm_michael);
if (_priv->tx_tfm_arc4)
crypto_free_tfm(_priv->tx_tfm_arc4);
if (_priv->rx_tfm_michael)
crypto_free_tfm(_priv->rx_tfm_michael);
if (_priv->rx_tfm_arc4)
crypto_free_tfm(_priv->rx_tfm_arc4);
#else
if (_priv) { if (_priv) {
if (_priv->tx_tfm_michael) if (_priv->tx_tfm_michael)
crypto_free_hash(_priv->tx_tfm_michael); crypto_free_hash(_priv->tx_tfm_michael);
@ -214,7 +142,6 @@ static void ieee80211_tkip_deinit(void *priv)
if (_priv->rx_tfm_arc4) if (_priv->rx_tfm_arc4)
crypto_free_blkcipher(_priv->rx_tfm_arc4); crypto_free_blkcipher(_priv->rx_tfm_arc4);
} }
#endif
kfree(priv); kfree(priv);
} }
@ -384,11 +311,8 @@ static int ieee80211_tkip_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
u8 *pos; u8 *pos;
struct ieee80211_hdr_4addr *hdr; struct ieee80211_hdr_4addr *hdr;
cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE); cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
#if((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)) || (OPENSUSE_SLED))
struct blkcipher_desc desc = {.tfm = tkey->tx_tfm_arc4}; struct blkcipher_desc desc = {.tfm = tkey->tx_tfm_arc4};
int ret = 0; int ret = 0;
#endif
u8 rc4key[16], *icv; u8 rc4key[16], *icv;
u32 crc; u32 crc;
struct scatterlist sg; struct scatterlist sg;
@ -399,18 +323,6 @@ static int ieee80211_tkip_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
hdr = (struct ieee80211_hdr_4addr *) skb->data; hdr = (struct ieee80211_hdr_4addr *) skb->data;
#if 0
printk("@@ tkey\n");
printk("%x|", ((u32*)tkey->key)[0]);
printk("%x|", ((u32*)tkey->key)[1]);
printk("%x|", ((u32*)tkey->key)[2]);
printk("%x|", ((u32*)tkey->key)[3]);
printk("%x|", ((u32*)tkey->key)[4]);
printk("%x|", ((u32*)tkey->key)[5]);
printk("%x|", ((u32*)tkey->key)[6]);
printk("%x\n", ((u32*)tkey->key)[7]);
#endif
if (!tcb_desc->bHwSec) if (!tcb_desc->bHwSec)
{ {
if (!tkey->tx_phase1_done) { if (!tkey->tx_phase1_done) {
@ -451,33 +363,14 @@ printk("%x\n", ((u32*)tkey->key)[7]);
if (!tcb_desc->bHwSec) if (!tcb_desc->bHwSec)
{ {
icv = skb_put(skb, 4); icv = skb_put(skb, 4);
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
crc = ~crc32_le(~0, pos, len); crc = ~crc32_le(~0, pos, len);
#else
crc = ~ether_crc_le(len, pos);
#endif
icv[0] = crc; icv[0] = crc;
icv[1] = crc >> 8; icv[1] = crc >> 8;
icv[2] = crc >> 16; icv[2] = crc >> 16;
icv[3] = crc >> 24; icv[3] = crc >> 24;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
crypto_cipher_setkey(tkey->tx_tfm_arc4, rc4key, 16);
sg.page = virt_to_page(pos);
sg.offset = offset_in_page(pos);
sg.length = len + 4;
crypto_cipher_encrypt(tkey->tx_tfm_arc4, &sg, &sg, len + 4);
#else
crypto_blkcipher_setkey(tkey->tx_tfm_arc4, rc4key, 16); crypto_blkcipher_setkey(tkey->tx_tfm_arc4, rc4key, 16);
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
sg.page = virt_to_page(pos);
sg.offset = offset_in_page(pos);
sg.length = len + 4;
#else
sg_init_one(&sg, pos, len+4); sg_init_one(&sg, pos, len+4);
#endif
ret= crypto_blkcipher_encrypt(&desc, &sg, &sg, len + 4); ret= crypto_blkcipher_encrypt(&desc, &sg, &sg, len + 4);
#endif
} }
tkey->tx_iv16++; tkey->tx_iv16++;
@ -487,11 +380,7 @@ printk("%x\n", ((u32*)tkey->key)[7]);
} }
if (!tcb_desc->bHwSec) if (!tcb_desc->bHwSec)
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
return 0;
#else
return ret; return ret;
#endif
else else
return 0; return 0;
@ -506,9 +395,7 @@ static int ieee80211_tkip_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
u16 iv16; u16 iv16;
struct ieee80211_hdr_4addr *hdr; struct ieee80211_hdr_4addr *hdr;
cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE); cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
#if((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)) || (OPENSUSE_SLED))
struct blkcipher_desc desc = {.tfm = tkey->rx_tfm_arc4}; struct blkcipher_desc desc = {.tfm = tkey->rx_tfm_arc4};
#endif
u8 rc4key[16]; u8 rc4key[16];
u8 icv[4]; u8 icv[4];
u32 crc; u32 crc;
@ -567,21 +454,9 @@ static int ieee80211_tkip_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
plen = skb->len - hdr_len - 12; plen = skb->len - hdr_len - 12;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
crypto_cipher_setkey(tkey->rx_tfm_arc4, rc4key, 16);
sg.page = virt_to_page(pos);
sg.offset = offset_in_page(pos);
sg.length = plen + 4;
crypto_cipher_decrypt(tkey->rx_tfm_arc4, &sg, &sg, plen + 4);
#else
crypto_blkcipher_setkey(tkey->rx_tfm_arc4, rc4key, 16); crypto_blkcipher_setkey(tkey->rx_tfm_arc4, rc4key, 16);
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
sg.page = virt_to_page(pos);
sg.offset = offset_in_page(pos);
sg.length = plen + 4;
#else
sg_init_one(&sg, pos, plen+4); sg_init_one(&sg, pos, plen+4);
#endif
if (crypto_blkcipher_decrypt(&desc, &sg, &sg, plen + 4)) { if (crypto_blkcipher_decrypt(&desc, &sg, &sg, plen + 4)) {
if (net_ratelimit()) { if (net_ratelimit()) {
printk(KERN_DEBUG ": TKIP: failed to decrypt " printk(KERN_DEBUG ": TKIP: failed to decrypt "
@ -590,13 +465,8 @@ static int ieee80211_tkip_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
} }
return -7; return -7;
} }
#endif
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
crc = ~crc32_le(~0, pos, plen); crc = ~crc32_le(~0, pos, plen);
#else
crc = ~ether_crc_le(plen, pos);
#endif
icv[0] = crc; icv[0] = crc;
icv[1] = crc >> 8; icv[1] = crc >> 8;
icv[2] = crc >> 16; icv[2] = crc >> 16;
@ -628,63 +498,9 @@ static int ieee80211_tkip_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
skb_pull(skb, 8); skb_pull(skb, 8);
skb_trim(skb, skb->len - 4); skb_trim(skb, skb->len - 4);
//john's test
#ifdef JOHN_DUMP
if( ((u16*)skb->data)[0] & 0x4000){
printk("@@ rx decrypted skb->data");
int i;
for(i=0;i<skb->len;i++){
if( (i%24)==0 ) printk("\n");
printk("%2x ", ((u8*)skb->data)[i]);
}
printk("\n");
}
#endif /*JOHN_DUMP*/
return keyidx; return keyidx;
} }
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
static int michael_mic(struct crypto_tfm * tfm_michael, u8 *key, u8 *hdr,
u8 *data, size_t data_len, u8 *mic)
{
struct scatterlist sg[2];
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
struct hash_desc desc;
int ret = 0;
#endif
if (tfm_michael == NULL){
printk(KERN_WARNING "michael_mic: tfm_michael == NULL\n");
return -1;
}
sg[0].page = virt_to_page(hdr);
sg[0].offset = offset_in_page(hdr);
sg[0].length = 16;
sg[1].page = virt_to_page(data);
sg[1].offset = offset_in_page(data);
sg[1].length = data_len;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
crypto_digest_init(tfm_michael);
crypto_digest_setkey(tfm_michael, key, 8);
crypto_digest_update(tfm_michael, sg, 2);
crypto_digest_final(tfm_michael, mic);
return 0;
#else
if (crypto_hash_setkey(tkey->tfm_michael, key, 8))
return -1;
// return 0;
desc.tfm = tkey->tfm_michael;
desc.flags = 0;
ret = crypto_hash_digest(&desc, sg, data_len + 16, mic);
return ret;
#endif
}
#else
static int michael_mic(struct crypto_hash *tfm_michael, u8 * key, u8 * hdr, static int michael_mic(struct crypto_hash *tfm_michael, u8 * key, u8 * hdr,
u8 * data, size_t data_len, u8 * mic) u8 * data, size_t data_len, u8 * mic)
{ {
@ -695,19 +511,10 @@ static int michael_mic(struct crypto_hash *tfm_michael, u8 * key, u8 * hdr,
printk(KERN_WARNING "michael_mic: tfm_michael == NULL\n"); printk(KERN_WARNING "michael_mic: tfm_michael == NULL\n");
return -1; return -1;
} }
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
sg[0].page = virt_to_page(hdr);
sg[0].offset = offset_in_page(hdr);
sg[0].length = 16;
sg[1].page = virt_to_page(data);
sg[1].offset = offset_in_page(data);
sg[1].length = data_len;
#else
sg_init_table(sg, 2); sg_init_table(sg, 2);
sg_set_buf(&sg[0], hdr, 16); sg_set_buf(&sg[0], hdr, 16);
sg_set_buf(&sg[1], data, data_len); sg_set_buf(&sg[1], data, data_len);
#endif
if (crypto_hash_setkey(tfm_michael, key, 8)) if (crypto_hash_setkey(tfm_michael, key, 8))
return -1; return -1;
@ -716,9 +523,6 @@ static int michael_mic(struct crypto_hash *tfm_michael, u8 * key, u8 * hdr,
desc.flags = 0; desc.flags = 0;
return crypto_hash_digest(&desc, sg, data_len + 16, mic); return crypto_hash_digest(&desc, sg, data_len + 16, mic);
} }
#endif
static void michael_mic_hdr(struct sk_buff *skb, u8 *hdr) static void michael_mic_hdr(struct sk_buff *skb, u8 *hdr)
{ {
@ -775,20 +579,14 @@ static int ieee80211_michael_mic_add(struct sk_buff *skb, int hdr_len, void *pri
} }
// } // }
pos = skb_put(skb, 8); pos = skb_put(skb, 8);
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
if (michael_mic(tkey->tx_tfm_michael, &tkey->key[16], tkey->tx_hdr, if (michael_mic(tkey->tx_tfm_michael, &tkey->key[16], tkey->tx_hdr,
skb->data + hdr_len, skb->len - 8 - hdr_len, pos)) skb->data + hdr_len, skb->len - 8 - hdr_len, pos))
#else
if (michael_mic(tkey->tx_tfm_michael, &tkey->key[16], tkey->tx_hdr,
skb->data + hdr_len, skb->len - 8 - hdr_len, pos))
#endif
return -1; return -1;
return 0; return 0;
} }
#if WIRELESS_EXT >= 18
static void ieee80211_michael_mic_failure(struct net_device *dev, static void ieee80211_michael_mic_failure(struct net_device *dev,
struct ieee80211_hdr_4addr *hdr, struct ieee80211_hdr_4addr *hdr,
int keyidx) int keyidx)
@ -809,29 +607,6 @@ static void ieee80211_michael_mic_failure(struct net_device *dev,
wrqu.data.length = sizeof(ev); wrqu.data.length = sizeof(ev);
wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, (char *) &ev); wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, (char *) &ev);
} }
#elif WIRELESS_EXT >= 15
static void ieee80211_michael_mic_failure(struct net_device *dev,
struct ieee80211_hdr_4addr *hdr,
int keyidx)
{
union iwreq_data wrqu;
char buf[128];
/* TODO: needed parameters: count, keyid, key type, TSC */
sprintf(buf, "MLME-MICHAELMICFAILURE.indication(keyid=%d %scast addr="
MAC_FMT ")", keyidx, hdr->addr1[0] & 0x01 ? "broad" : "uni",
MAC_ARG(hdr->addr2));
memset(&wrqu, 0, sizeof(wrqu));
wrqu.data.length = strlen(buf);
wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
}
#else /* WIRELESS_EXT >= 15 */
static inline void ieee80211_michael_mic_failure(struct net_device *dev,
struct ieee80211_hdr_4addr *hdr,
int keyidx)
{
}
#endif /* WIRELESS_EXT >= 15 */
static int ieee80211_michael_mic_verify(struct sk_buff *skb, int keyidx, static int ieee80211_michael_mic_verify(struct sk_buff *skb, int keyidx,
int hdr_len, void *priv) int hdr_len, void *priv)
@ -853,13 +628,8 @@ static int ieee80211_michael_mic_verify(struct sk_buff *skb, int keyidx,
} }
// } // }
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
if (michael_mic(tkey->rx_tfm_michael, &tkey->key[24], tkey->rx_hdr, if (michael_mic(tkey->rx_tfm_michael, &tkey->key[24], tkey->rx_hdr,
skb->data + hdr_len, skb->len - 8 - hdr_len, mic)) skb->data + hdr_len, skb->len - 8 - hdr_len, mic))
#else
if (michael_mic(tkey->rx_tfm_michael, &tkey->key[24], tkey->rx_hdr,
skb->data + hdr_len, skb->len - 8 - hdr_len, mic))
#endif
return -1; return -1;
if (memcmp(mic, skb->data + skb->len - 8, 8) != 0) { if (memcmp(mic, skb->data + skb->len - 8, 8) != 0) {
struct ieee80211_hdr_4addr *hdr; struct ieee80211_hdr_4addr *hdr;
@ -889,32 +659,18 @@ static int ieee80211_tkip_set_key(void *key, int len, u8 *seq, void *priv)
{ {
struct ieee80211_tkip_data *tkey = priv; struct ieee80211_tkip_data *tkey = priv;
int keyidx; int keyidx;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
struct crypto_tfm *tfm = tkey->tx_tfm_michael;
struct crypto_tfm *tfm2 = tkey->tx_tfm_arc4;
struct crypto_tfm *tfm3 = tkey->rx_tfm_michael;
struct crypto_tfm *tfm4 = tkey->rx_tfm_arc4;
#else
struct crypto_hash *tfm = tkey->tx_tfm_michael; struct crypto_hash *tfm = tkey->tx_tfm_michael;
struct crypto_blkcipher *tfm2 = tkey->tx_tfm_arc4; struct crypto_blkcipher *tfm2 = tkey->tx_tfm_arc4;
struct crypto_hash *tfm3 = tkey->rx_tfm_michael; struct crypto_hash *tfm3 = tkey->rx_tfm_michael;
struct crypto_blkcipher *tfm4 = tkey->rx_tfm_arc4; struct crypto_blkcipher *tfm4 = tkey->rx_tfm_arc4;
#endif
keyidx = tkey->key_idx; keyidx = tkey->key_idx;
memset(tkey, 0, sizeof(*tkey)); memset(tkey, 0, sizeof(*tkey));
tkey->key_idx = keyidx; tkey->key_idx = keyidx;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
tkey->tx_tfm_michael = tfm; tkey->tx_tfm_michael = tfm;
tkey->tx_tfm_arc4 = tfm2; tkey->tx_tfm_arc4 = tfm2;
tkey->rx_tfm_michael = tfm3; tkey->rx_tfm_michael = tfm3;
tkey->rx_tfm_arc4 = tfm4; tkey->rx_tfm_arc4 = tfm4;
#else
tkey->tx_tfm_michael = tfm;
tkey->tx_tfm_arc4 = tfm2;
tkey->rx_tfm_michael = tfm3;
tkey->rx_tfm_arc4 = tfm4;
#endif
if (len == TKIP_KEY_LEN) { if (len == TKIP_KEY_LEN) {
memcpy(tkey->key, key, TKIP_KEY_LEN); memcpy(tkey->key, key, TKIP_KEY_LEN);
@ -1007,14 +763,12 @@ static struct ieee80211_crypto_ops ieee80211_crypt_tkip = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}; };
int __init ieee80211_crypto_tkip_init(void)
static int __init ieee80211_crypto_tkip_init(void)
{ {
return ieee80211_register_crypto_ops(&ieee80211_crypt_tkip); return ieee80211_register_crypto_ops(&ieee80211_crypt_tkip);
} }
void __exit ieee80211_crypto_tkip_exit(void)
static void __exit ieee80211_crypto_tkip_exit(void)
{ {
ieee80211_unregister_crypto_ops(&ieee80211_crypt_tkip); ieee80211_unregister_crypto_ops(&ieee80211_crypt_tkip);
} }
@ -1024,11 +778,3 @@ void ieee80211_tkip_null(void)
// printk("============>%s()\n", __FUNCTION__); // printk("============>%s()\n", __FUNCTION__);
return; return;
} }
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
EXPORT_SYMBOL(ieee80211_tkip_null);
#else
EXPORT_SYMBOL_NOVERS(ieee80211_tkip_null);
#endif
module_init(ieee80211_crypto_tkip_init);
module_exit(ieee80211_crypto_tkip_exit);

114
drivers/staging/rtl8192u/ieee80211/ieee80211_crypt_wep.c
View File

@ -20,41 +20,13 @@
#include "ieee80211.h" #include "ieee80211.h"
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,20))
//#include "crypto_compat.h"
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
#include "rtl_crypto.h"
#else
#include <linux/crypto.h> #include <linux/crypto.h>
#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
#include <asm/scatterlist.h>
#else
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#endif
//#include <asm/scatterlist.h>
#include <linux/crc32.h> #include <linux/crc32.h>
//
/*
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
#include "rtl_crypto.h"
#else
#include <linux/crypto.h>
#endif
#include <asm/scatterlist.h>
#include <linux/crc32.h>
*/
MODULE_AUTHOR("Jouni Malinen"); MODULE_AUTHOR("Jouni Malinen");
MODULE_DESCRIPTION("Host AP crypt: WEP"); MODULE_DESCRIPTION("Host AP crypt: WEP");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
#ifndef OPENSUSE_SLED
#define OPENSUSE_SLED 0
#endif
struct prism2_wep_data { struct prism2_wep_data {
u32 iv; u32 iv;
@ -62,12 +34,8 @@ struct prism2_wep_data {
u8 key[WEP_KEY_LEN + 1]; u8 key[WEP_KEY_LEN + 1];
u8 key_len; u8 key_len;
u8 key_idx; u8 key_idx;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
struct crypto_tfm *tfm;
#else
struct crypto_blkcipher *tx_tfm; struct crypto_blkcipher *tx_tfm;
struct crypto_blkcipher *rx_tfm; struct crypto_blkcipher *rx_tfm;
#endif
}; };
@ -81,14 +49,6 @@ static void * prism2_wep_init(int keyidx)
memset(priv, 0, sizeof(*priv)); memset(priv, 0, sizeof(*priv));
priv->key_idx = keyidx; priv->key_idx = keyidx;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
priv->tfm = crypto_alloc_tfm("arc4", 0);
if (priv->tfm == NULL) {
printk(KERN_DEBUG "ieee80211_crypt_wep: could not allocate "
"crypto API arc4\n");
goto fail;
}
#else
priv->tx_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC); priv->tx_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);
if (IS_ERR(priv->tx_tfm)) { if (IS_ERR(priv->tx_tfm)) {
printk(KERN_DEBUG "ieee80211_crypt_wep: could not allocate " printk(KERN_DEBUG "ieee80211_crypt_wep: could not allocate "
@ -103,7 +63,6 @@ static void * prism2_wep_init(int keyidx)
priv->rx_tfm = NULL; priv->rx_tfm = NULL;
goto fail; goto fail;
} }
#endif
/* start WEP IV from a random value */ /* start WEP IV from a random value */
get_random_bytes(&priv->iv, 4); get_random_bytes(&priv->iv, 4);
@ -111,13 +70,6 @@ static void * prism2_wep_init(int keyidx)
return priv; return priv;
fail: fail:
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
if (priv) {
if (priv->tfm)
crypto_free_tfm(priv->tfm);
kfree(priv);
}
#else
if (priv) { if (priv) {
if (priv->tx_tfm) if (priv->tx_tfm)
crypto_free_blkcipher(priv->tx_tfm); crypto_free_blkcipher(priv->tx_tfm);
@ -125,7 +77,7 @@ fail:
crypto_free_blkcipher(priv->rx_tfm); crypto_free_blkcipher(priv->rx_tfm);
kfree(priv); kfree(priv);
} }
#endif
return NULL; return NULL;
} }
@ -133,17 +85,13 @@ fail:
static void prism2_wep_deinit(void *priv) static void prism2_wep_deinit(void *priv)
{ {
struct prism2_wep_data *_priv = priv; struct prism2_wep_data *_priv = priv;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
if (_priv && _priv->tfm)
crypto_free_tfm(_priv->tfm);
#else
if (_priv) { if (_priv) {
if (_priv->tx_tfm) if (_priv->tx_tfm)
crypto_free_blkcipher(_priv->tx_tfm); crypto_free_blkcipher(_priv->tx_tfm);
if (_priv->rx_tfm) if (_priv->rx_tfm)
crypto_free_blkcipher(_priv->rx_tfm); crypto_free_blkcipher(_priv->rx_tfm);
} }
#endif
kfree(priv); kfree(priv);
} }
@ -160,9 +108,7 @@ static int prism2_wep_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
u8 key[WEP_KEY_LEN + 3]; u8 key[WEP_KEY_LEN + 3];
u8 *pos; u8 *pos;
cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE); cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
#if((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)) || (OPENSUSE_SLED))
struct blkcipher_desc desc = {.tfm = wep->tx_tfm}; struct blkcipher_desc desc = {.tfm = wep->tx_tfm};
#endif
u32 crc; u32 crc;
u8 *icv; u8 *icv;
struct scatterlist sg; struct scatterlist sg;
@ -201,35 +147,17 @@ static int prism2_wep_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
{ {
/* Append little-endian CRC32 and encrypt it to produce ICV */ /* Append little-endian CRC32 and encrypt it to produce ICV */
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
crc = ~crc32_le(~0, pos, len); crc = ~crc32_le(~0, pos, len);
#else
crc = ~ether_crc_le(len, pos);
#endif
icv = skb_put(skb, 4); icv = skb_put(skb, 4);
icv[0] = crc; icv[0] = crc;
icv[1] = crc >> 8; icv[1] = crc >> 8;
icv[2] = crc >> 16; icv[2] = crc >> 16;
icv[3] = crc >> 24; icv[3] = crc >> 24;
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
crypto_cipher_setkey(wep->tfm, key, klen);
sg.page = virt_to_page(pos);
sg.offset = offset_in_page(pos);
sg.length = len + 4;
crypto_cipher_encrypt(wep->tfm, &sg, &sg, len + 4);
return 0;
#else
crypto_blkcipher_setkey(wep->tx_tfm, key, klen); crypto_blkcipher_setkey(wep->tx_tfm, key, klen);
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
sg.page = virt_to_page(pos);
sg.offset = offset_in_page(pos);
sg.length = len + 4;
#else
sg_init_one(&sg, pos, len+4); sg_init_one(&sg, pos, len+4);
#endif
return crypto_blkcipher_encrypt(&desc, &sg, &sg, len + 4); return crypto_blkcipher_encrypt(&desc, &sg, &sg, len + 4);
#endif
} }
return 0; return 0;
@ -250,9 +178,7 @@ static int prism2_wep_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
u8 key[WEP_KEY_LEN + 3]; u8 key[WEP_KEY_LEN + 3];
u8 keyidx, *pos; u8 keyidx, *pos;
cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE); cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
#if((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)) || (OPENSUSE_SLED))
struct blkcipher_desc desc = {.tfm = wep->rx_tfm}; struct blkcipher_desc desc = {.tfm = wep->rx_tfm};
#endif
u32 crc; u32 crc;
u8 icv[4]; u8 icv[4];
struct scatterlist sg; struct scatterlist sg;
@ -277,29 +203,13 @@ static int prism2_wep_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
if (!tcb_desc->bHwSec) if (!tcb_desc->bHwSec)
{ {
#if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
crypto_cipher_setkey(wep->tfm, key, klen);
sg.page = virt_to_page(pos);
sg.offset = offset_in_page(pos);
sg.length = plen + 4;
crypto_cipher_decrypt(wep->tfm, &sg, &sg, plen + 4);
#else
crypto_blkcipher_setkey(wep->rx_tfm, key, klen); crypto_blkcipher_setkey(wep->rx_tfm, key, klen);
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
sg.page = virt_to_page(pos);
sg.offset = offset_in_page(pos);
sg.length = plen + 4;
#else
sg_init_one(&sg, pos, plen+4); sg_init_one(&sg, pos, plen+4);
#endif
if (crypto_blkcipher_decrypt(&desc, &sg, &sg, plen + 4)) if (crypto_blkcipher_decrypt(&desc, &sg, &sg, plen + 4))
return -7; return -7;
#endif
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
crc = ~crc32_le(~0, pos, plen); crc = ~crc32_le(~0, pos, plen);
#else
crc = ~ether_crc_le(plen, pos);
#endif
icv[0] = crc; icv[0] = crc;
icv[1] = crc >> 8; icv[1] = crc >> 8;
icv[2] = crc >> 16; icv[2] = crc >> 16;
@ -370,14 +280,12 @@ static struct ieee80211_crypto_ops ieee80211_crypt_wep = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
}; };
int __init ieee80211_crypto_wep_init(void)
static int __init ieee80211_crypto_wep_init(void)
{ {
return ieee80211_register_crypto_ops(&ieee80211_crypt_wep); return ieee80211_register_crypto_ops(&ieee80211_crypt_wep);
} }
void __exit ieee80211_crypto_wep_exit(void)
static void __exit ieee80211_crypto_wep_exit(void)
{ {
ieee80211_unregister_crypto_ops(&ieee80211_crypt_wep); ieee80211_unregister_crypto_ops(&ieee80211_crypt_wep);
} }
@ -387,11 +295,3 @@ void ieee80211_wep_null(void)
// printk("============>%s()\n", __FUNCTION__); // printk("============>%s()\n", __FUNCTION__);
return; return;
} }
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
EXPORT_SYMBOL(ieee80211_wep_null);
#else
EXPORT_SYMBOL_NOVERS(ieee80211_wep_null);
#endif
module_init(ieee80211_crypto_wep_init);
module_exit(ieee80211_crypto_wep_exit);

82
drivers/staging/rtl8192u/ieee80211/ieee80211_module.c
View File

@ -113,13 +113,7 @@ struct net_device *alloc_ieee80211(int sizeof_priv)
goto failed; goto failed;
} }
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
ieee = netdev_priv(dev); ieee = netdev_priv(dev);
#else
ieee = (struct ieee80211_device *)dev->priv;
#endif
dev->hard_start_xmit = ieee80211_xmit;
memset(ieee, 0, sizeof(struct ieee80211_device)+sizeof_priv); memset(ieee, 0, sizeof(struct ieee80211_device)+sizeof_priv);
ieee->dev = dev; ieee->dev = dev;
@ -167,12 +161,7 @@ struct net_device *alloc_ieee80211(int sizeof_priv)
ieee80211_softmac_init(ieee); ieee80211_softmac_init(ieee);
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
ieee->pHTInfo = (RT_HIGH_THROUGHPUT*)kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL); ieee->pHTInfo = (RT_HIGH_THROUGHPUT*)kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
#else
ieee->pHTInfo = (RT_HIGH_THROUGHPUT*)kmalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
memset(ieee->pHTInfo,0,sizeof(RT_HIGH_THROUGHPUT));
#endif
if (ieee->pHTInfo == NULL) if (ieee->pHTInfo == NULL)
{ {
IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n"); IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n");
@ -181,13 +170,7 @@ struct net_device *alloc_ieee80211(int sizeof_priv)
HTUpdateDefaultSetting(ieee); HTUpdateDefaultSetting(ieee);
HTInitializeHTInfo(ieee); //may move to other place. HTInitializeHTInfo(ieee); //may move to other place.
TSInitialize(ieee); TSInitialize(ieee);
#if 0
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
INIT_WORK(&ieee->ht_onAssRsp, (void(*)(void*)) HTOnAssocRsp_wq);
#else
INIT_WORK(&ieee->ht_onAssRsp, (void(*)(void*)) HTOnAssocRsp_wq, ieee);
#endif
#endif
for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++) for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++)
INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]); INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]);
@ -206,22 +189,15 @@ struct net_device *alloc_ieee80211(int sizeof_priv)
failed: failed:
if (dev) if (dev)
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
free_netdev(dev); free_netdev(dev);
#else
kfree(dev);
#endif
return NULL; return NULL;
} }
void free_ieee80211(struct net_device *dev) void free_ieee80211(struct net_device *dev)
{ {
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
struct ieee80211_device *ieee = netdev_priv(dev); struct ieee80211_device *ieee = netdev_priv(dev);
#else
struct ieee80211_device *ieee = (struct ieee80211_device *)dev->priv;
#endif
int i; int i;
//struct list_head *p, *q; //struct list_head *p, *q;
// del_timer_sync(&ieee->SwBwTimer); // del_timer_sync(&ieee->SwBwTimer);
@ -240,34 +216,15 @@ void free_ieee80211(struct net_device *dev)
for (i = 0; i < WEP_KEYS; i++) { for (i = 0; i < WEP_KEYS; i++) {
struct ieee80211_crypt_data *crypt = ieee->crypt[i]; struct ieee80211_crypt_data *crypt = ieee->crypt[i];
if (crypt) { if (crypt) {
if (crypt->ops) { if (crypt->ops)
crypt->ops->deinit(crypt->priv); crypt->ops->deinit(crypt->priv);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
module_put(crypt->ops->owner);
#else
__MOD_DEC_USE_COUNT(crypt->ops->owner);
#endif
}
kfree(crypt); kfree(crypt);
ieee->crypt[i] = NULL; ieee->crypt[i] = NULL;
} }
} }
ieee80211_networks_free(ieee); ieee80211_networks_free(ieee);
#if 0
for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++) {
list_for_each_safe(p, q, &ieee->ibss_mac_hash[i]) {
kfree(list_entry(p, struct ieee_ibss_seq, list));
list_del(p);
}
}
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
free_netdev(dev); free_netdev(dev);
#else
kfree(dev);
#endif
} }
#ifdef CONFIG_IEEE80211_DEBUG #ifdef CONFIG_IEEE80211_DEBUG
@ -305,7 +262,7 @@ static int store_debug_level(struct file *file, const char *buffer,
unsigned long count, void *data) unsigned long count, void *data)
{ {
char buf[] = "0x00000000"; char buf[] = "0x00000000";
unsigned long len = min(sizeof(buf) - 1, (u32)count); unsigned long len = min(sizeof(buf) - 1, count);
char *p = (char *)buf; char *p = (char *)buf;
unsigned long val; unsigned long val;
@ -328,16 +285,13 @@ static int store_debug_level(struct file *file, const char *buffer,
return strnlen(buf, count); return strnlen(buf, count);
} }
static int __init ieee80211_init(void) int __init ieee80211_debug_init(void)
{ {
struct proc_dir_entry *e; struct proc_dir_entry *e;
ieee80211_debug_level = debug; ieee80211_debug_level = debug;
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
#else
ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net); ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
#endif
if (ieee80211_proc == NULL) { if (ieee80211_proc == NULL) {
IEEE80211_ERROR("Unable to create " DRV_NAME IEEE80211_ERROR("Unable to create " DRV_NAME
" proc directory\n"); " proc directory\n");
@ -346,11 +300,7 @@ static int __init ieee80211_init(void)
e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR, e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
ieee80211_proc); ieee80211_proc);
if (!e) { if (!e) {
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
remove_proc_entry(DRV_NAME, proc_net);
#else
remove_proc_entry(DRV_NAME, init_net.proc_net); remove_proc_entry(DRV_NAME, init_net.proc_net);
#endif
ieee80211_proc = NULL; ieee80211_proc = NULL;
return -EIO; return -EIO;
} }
@ -361,34 +311,16 @@ static int __init ieee80211_init(void)
return 0; return 0;
} }
static void __exit ieee80211_exit(void) void __exit ieee80211_debug_exit(void)
{ {
if (ieee80211_proc) { if (ieee80211_proc) {
remove_proc_entry("debug_level", ieee80211_proc); remove_proc_entry("debug_level", ieee80211_proc);
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
remove_proc_entry(DRV_NAME, proc_net);
#else
remove_proc_entry(DRV_NAME, init_net.proc_net); remove_proc_entry(DRV_NAME, init_net.proc_net);
#endif
ieee80211_proc = NULL; ieee80211_proc = NULL;
} }
} }
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
module_param(debug, int, 0444); module_param(debug, int, 0444);
MODULE_PARM_DESC(debug, "debug output mask"); MODULE_PARM_DESC(debug, "debug output mask");
module_exit(ieee80211_exit);
module_init(ieee80211_init);
#endif
#endif
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
EXPORT_SYMBOL(alloc_ieee80211);
EXPORT_SYMBOL(free_ieee80211);
#else
EXPORT_SYMBOL_NOVERS(alloc_ieee80211);
EXPORT_SYMBOL_NOVERS(free_ieee80211);
#endif #endif

110
drivers/staging/rtl8192u/r8192U_core.c
View File

@ -1175,18 +1175,14 @@ static int rtl8192_rx_initiate(struct net_device*dev)
} }
// printk("nomal packet IN request!\n"); // printk("nomal packet IN request!\n");
usb_fill_bulk_urb(entry, priv->udev, usb_fill_bulk_urb(entry, priv->udev,
usb_rcvbulkpipe(priv->udev, 3), skb->tail, usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
RX_URB_SIZE, rtl8192_rx_isr, skb); RX_URB_SIZE, rtl8192_rx_isr, skb);
info = (struct rtl8192_rx_info *) skb->cb; info = (struct rtl8192_rx_info *) skb->cb;
info->urb = entry; info->urb = entry;
info->dev = dev; info->dev = dev;
info->out_pipe = 3; //denote rx normal packet queue info->out_pipe = 3; //denote rx normal packet queue
skb_queue_tail(&priv->rx_queue, skb); skb_queue_tail(&priv->rx_queue, skb);
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
usb_submit_urb(entry, GFP_KERNEL); usb_submit_urb(entry, GFP_KERNEL);
#else
usb_submit_urb(entry);
#endif
} }
/* command packet rx procedure */ /* command packet rx procedure */
@ -1205,18 +1201,14 @@ static int rtl8192_rx_initiate(struct net_device*dev)
break; break;
} }
usb_fill_bulk_urb(entry, priv->udev, usb_fill_bulk_urb(entry, priv->udev,
usb_rcvbulkpipe(priv->udev, 9), skb->tail, usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
RX_URB_SIZE, rtl8192_rx_isr, skb); RX_URB_SIZE, rtl8192_rx_isr, skb);
info = (struct rtl8192_rx_info *) skb->cb; info = (struct rtl8192_rx_info *) skb->cb;
info->urb = entry; info->urb = entry;
info->dev = dev; info->dev = dev;
info->out_pipe = 9; //denote rx cmd packet queue info->out_pipe = 9; //denote rx cmd packet queue
skb_queue_tail(&priv->rx_queue, skb); skb_queue_tail(&priv->rx_queue, skb);
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
usb_submit_urb(entry, GFP_KERNEL); usb_submit_urb(entry, GFP_KERNEL);
#else
usb_submit_urb(entry);
#endif
} }
return 0; return 0;
@ -1586,7 +1578,7 @@ static void rtl8192_rx_isr(struct urb *urb)
} }
usb_fill_bulk_urb(urb, priv->udev, usb_fill_bulk_urb(urb, priv->udev,
usb_rcvbulkpipe(priv->udev, out_pipe), skb->tail, usb_rcvbulkpipe(priv->udev, out_pipe), skb_tail_pointer(skb),
RX_URB_SIZE, rtl8192_rx_isr, skb); RX_URB_SIZE, rtl8192_rx_isr, skb);
info = (struct rtl8192_rx_info *) skb->cb; info = (struct rtl8192_rx_info *) skb->cb;
@ -1594,14 +1586,10 @@ static void rtl8192_rx_isr(struct urb *urb)
info->dev = dev; info->dev = dev;
info->out_pipe = out_pipe; info->out_pipe = out_pipe;
urb->transfer_buffer = skb->tail; urb->transfer_buffer = skb_tail_pointer(skb);
urb->context = skb; urb->context = skb;
skb_queue_tail(&priv->rx_queue, skb); skb_queue_tail(&priv->rx_queue, skb);
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
err = usb_submit_urb(urb, GFP_ATOMIC); err = usb_submit_urb(urb, GFP_ATOMIC);
#else
err = usb_submit_urb(urb);
#endif
if(err && err != EPERM) if(err && err != EPERM)
printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status); printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
} }
@ -2953,25 +2941,21 @@ short rtl8192_usb_initendpoints(struct net_device *dev)
#ifdef THOMAS_BEACON #ifdef THOMAS_BEACON
{ {
int align = 0; long align = 0;
u32 oldaddr,newaddr; void *oldaddr, *newaddr;
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
priv->rx_urb[16] = usb_alloc_urb(0, GFP_KERNEL); priv->rx_urb[16] = usb_alloc_urb(0, GFP_KERNEL);
#else
priv->rx_urb[16] = usb_alloc_urb(0);
#endif
priv->oldaddr = kmalloc(16, GFP_KERNEL); priv->oldaddr = kmalloc(16, GFP_KERNEL);
oldaddr = (u32)priv->oldaddr; oldaddr = priv->oldaddr;
align = oldaddr&3; align = ((long)oldaddr) & 3;
if(align != 0 ){ if (align) {
newaddr = oldaddr + 4 - align; newaddr = oldaddr + 4 - align;
priv->rx_urb[16]->transfer_buffer_length = 16-4+align; priv->rx_urb[16]->transfer_buffer_length = 16 - 4 + align;
} } else {
else{
newaddr = oldaddr; newaddr = oldaddr;
priv->rx_urb[16]->transfer_buffer_length = 16; priv->rx_urb[16]->transfer_buffer_length = 16;
} }
priv->rx_urb[16]->transfer_buffer = (u32*)newaddr; priv->rx_urb[16]->transfer_buffer = newaddr;
} }
#endif #endif
@ -6831,6 +6815,18 @@ void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
} }
} }
static const struct net_device_ops rtl8192_netdev_ops = {
.ndo_open = rtl8192_open,
.ndo_stop = rtl8192_close,
.ndo_get_stats = rtl8192_stats,
.ndo_tx_timeout = tx_timeout,
.ndo_do_ioctl = rtl8192_ioctl,
.ndo_set_multicast_list = r8192_set_multicast,
.ndo_set_mac_address = r8192_set_mac_adr,
.ndo_validate_addr = eth_validate_addr,
.ndo_change_mtu = eth_change_mtu,
.ndo_start_xmit = ieee80211_xmit,
};
/**************************************************************************** /****************************************************************************
@ -6872,15 +6868,7 @@ static void * __devinit rtl8192_usb_probe(struct usb_device *udev,
#endif #endif
priv->udev=udev; priv->udev=udev;
dev->open = rtl8192_open; dev->netdev_ops = &rtl8192_netdev_ops;
dev->stop = rtl8192_close;
//dev->hard_start_xmit = rtl8192_8023_hard_start_xmit;
dev->tx_timeout = tx_timeout;
//dev->wireless_handlers = &r8192_wx_handlers_def;
dev->do_ioctl = rtl8192_ioctl;
dev->set_multicast_list = r8192_set_multicast;
dev->set_mac_address = r8192_set_mac_adr;
dev->get_stats = rtl8192_stats;
//DMESG("Oops: i'm coming\n"); //DMESG("Oops: i'm coming\n");
#if WIRELESS_EXT >= 12 #if WIRELESS_EXT >= 12
@ -7000,9 +6988,55 @@ static void __devexit rtl8192_usb_disconnect(struct usb_device *udev, void *ptr)
RT_TRACE(COMP_DOWN, "wlan driver removed\n"); RT_TRACE(COMP_DOWN, "wlan driver removed\n");
} }
/* fun with the built-in ieee80211 stack... */
extern int ieee80211_debug_init(void);
extern void ieee80211_debug_exit(void);
extern int ieee80211_crypto_init(void);
extern void ieee80211_crypto_deinit(void);
extern int ieee80211_crypto_tkip_init(void);
extern void ieee80211_crypto_tkip_exit(void);
extern int ieee80211_crypto_ccmp_init(void);
extern void ieee80211_crypto_ccmp_exit(void);
extern int ieee80211_crypto_wep_init(void);
extern void ieee80211_crypto_wep_exit(void);
static int __init rtl8192_usb_module_init(void) static int __init rtl8192_usb_module_init(void)
{ {
int ret;
#ifdef CONFIG_IEEE80211_DEBUG
ret = ieee80211_debug_init();
if (ret) {
printk(KERN_ERR "ieee80211_debug_init() failed %d\n", ret);
return ret;
}
#endif
ret = ieee80211_crypto_init();
if (ret) {
printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
return ret;
}
ret = ieee80211_crypto_tkip_init();
if (ret) {
printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n",
ret);
return ret;
}
ret = ieee80211_crypto_ccmp_init();
if (ret) {
printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n",
ret);
return ret;
}
ret = ieee80211_crypto_wep_init();
if (ret) {
printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
return ret;
}
printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n"); printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n"); printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
RT_TRACE(COMP_INIT, "Initializing module"); RT_TRACE(COMP_INIT, "Initializing module");