diff options
| author |   Greg Kroah-Hartman <gregkh@suse.de> | 2010-05-21 12:48:55 -0700 |
|---|---|---|
| committer | Greg Kroah-Hartman <gregkh@suse.de> | 2010-05-21 12:48:55 -0700 |
| commit | c8d1a126924fcbc1d61ceb830226e0c7afdcc841 (patch) | |
| tree | d3f3c850481c33b7f433175e83a189f958b1b868 /drivers/staging/rtl8192su | |
| parent | Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ryusuke/nilfs2 (diff) | |
| parent | Staging: ramzswap: Handler for swap slot free callback (diff) | |
| download | linux-dev-c8d1a126924fcbc1d61ceb830226e0c7afdcc841.tar.xz linux-dev-c8d1a126924fcbc1d61ceb830226e0c7afdcc841.zip | |
Merge staging-next tree into Linus's latest version
Conflicts:
drivers/staging/arlan/arlan-main.c
drivers/staging/comedi/drivers/cb_das16_cs.c
drivers/staging/cx25821/cx25821-alsa.c
drivers/staging/dt3155/dt3155_drv.c
drivers/staging/hv/hv.c
drivers/staging/netwave/netwave_cs.c
drivers/staging/wavelan/wavelan.c
drivers/staging/wavelan/wavelan_cs.c
drivers/staging/wlags49_h2/wl_cs.c
This required a bit of hand merging due to the conflicts
that happened in the later .34-rc releases, as well as
some staging driver changing coming in through other trees
(v4l and pcmcia).
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers/staging/rtl8192su')
24 files changed, 3526 insertions, 1584 deletions
diff --git a/drivers/staging/rtl8192su/Kconfig b/drivers/staging/rtl8192su/Kconfig index b72a96206f58..b422ea1ecf9c 100644 --- a/drivers/staging/rtl8192su/Kconfig +++ b/drivers/staging/rtl8192su/Kconfig @@ -3,5 +3,6 @@ config RTL8192SU depends on PCI && WLAN && USB select WIRELESS_EXT select WEXT_PRIV + select EEPROM_93CX6 default N ---help--- diff --git a/drivers/staging/rtl8192su/Makefile b/drivers/staging/rtl8192su/Makefile index c8b4332d108c..7133894afe76 100644 --- a/drivers/staging/rtl8192su/Makefile +++ b/drivers/staging/rtl8192su/Makefile @@ -9,7 +9,6 @@ EXTRA_CFLAGS += -DTHOMAS_BEACON #EXTRA_CFLAGS += -DMUTIPLE_BULK_OUT r8192s_usb-objs := \ - r8180_93cx6.o \ r8192U_wx.o \ r8192S_phy.o \ r8192S_rtl6052.o \ @@ -21,6 +20,7 @@ r8192s_usb-objs := \ r8192S_Efuse.o \ r8192U_core.o \ r8192U_pm.o \ + r8192SU_led.o \ ieee80211/ieee80211_crypt.o \ ieee80211/ieee80211_crypt_tkip.o \ ieee80211/ieee80211_crypt_ccmp.o \ diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211.h b/drivers/staging/rtl8192su/ieee80211/ieee80211.h index 32b261d15594..bcb2b12a8398 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211.h +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211.h @@ -1152,7 +1152,7 @@ struct ieee80211_device { spinlock_t reorder_spinlock; /* * for HT operation rate set, we use this one for HT data rate to - * seperate different descriptors the way fill this is the same as + * separate different descriptors the way fill this is the same as * in the IE */ u8 Regdot11HTOperationalRateSet[16]; /* use RATR format */ diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt.c b/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt.c index c4640e63196b..801942339437 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt.c +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt.c @@ -109,11 +109,10 @@ int ieee80211_register_crypto_ops(struct ieee80211_crypto_ops *ops) if (hcrypt == NULL) return -1; - alg = kmalloc(sizeof(*alg), GFP_KERNEL); + alg = kzalloc(sizeof(*alg), GFP_KERNEL); if (alg == NULL) return -ENOMEM; - memset(alg, 0, sizeof(*alg)); alg->ops = ops; spin_lock_irqsave(&hcrypt->lock, flags); @@ -206,11 +205,10 @@ int __init ieee80211_crypto_init(void) { int ret = -ENOMEM; - hcrypt = kmalloc(sizeof(*hcrypt), GFP_KERNEL); + hcrypt = kzalloc(sizeof(*hcrypt), GFP_KERNEL); if (!hcrypt) goto out; - memset(hcrypt, 0, sizeof(*hcrypt)); INIT_LIST_HEAD(&hcrypt->algs); spin_lock_init(&hcrypt->lock); diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_ccmp.c b/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_ccmp.c index 8a93f7d3eb38..77de957f1b1f 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_ccmp.c +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_ccmp.c @@ -68,10 +68,9 @@ static void * ieee80211_ccmp_init(int key_idx) { struct ieee80211_ccmp_data *priv; - priv = kmalloc(sizeof(*priv), GFP_ATOMIC); + priv = kzalloc(sizeof(*priv), GFP_ATOMIC); if (priv == NULL) goto fail; - memset(priv, 0, sizeof(*priv)); priv->key_idx = key_idx; priv->tfm = (void *)crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC); diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_tkip.c b/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_tkip.c index 7e48748da102..ade5f6f13667 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_tkip.c +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_tkip.c @@ -67,10 +67,9 @@ static void * ieee80211_tkip_init(int key_idx) { struct ieee80211_tkip_data *priv; - priv = kmalloc(sizeof(*priv), GFP_ATOMIC); + priv = kzalloc(sizeof(*priv), GFP_ATOMIC); if (priv == NULL) goto fail; - memset(priv, 0, sizeof(*priv)); priv->key_idx = key_idx; priv->tx_tfm_arc4 = crypto_alloc_blkcipher("ecb(arc4)", 0, diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_wep.c b/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_wep.c index 64f9cf01c94e..a1c0a59122b8 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_wep.c +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_crypt_wep.c @@ -43,10 +43,9 @@ static void * prism2_wep_init(int keyidx) { struct prism2_wep_data *priv; - priv = kmalloc(sizeof(*priv), GFP_ATOMIC); + priv = kzalloc(sizeof(*priv), GFP_ATOMIC); if (priv == NULL) goto fail; - memset(priv, 0, sizeof(*priv)); priv->key_idx = keyidx; priv->tx_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC); diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_module.c b/drivers/staging/rtl8192su/ieee80211/ieee80211_module.c index c024fa600729..a87650a517bd 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211_module.c +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_module.c @@ -65,8 +65,8 @@ static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee) if (ieee->networks) return 0; - ieee->networks = kmalloc( - MAX_NETWORK_COUNT * sizeof(struct ieee80211_network), + ieee->networks = kcalloc( + MAX_NETWORK_COUNT, sizeof(struct ieee80211_network), GFP_KERNEL); if (!ieee->networks) { printk(KERN_WARNING "%s: Out of memory allocating beacons\n", @@ -74,9 +74,6 @@ static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee) return -ENOMEM; } - memset(ieee->networks, 0, - MAX_NETWORK_COUNT * sizeof(struct ieee80211_network)); - return 0; } @@ -161,7 +158,7 @@ struct net_device *alloc_ieee80211(int sizeof_priv) ieee80211_softmac_init(ieee); - ieee->pHTInfo = (RT_HIGH_THROUGHPUT*)kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL); + ieee->pHTInfo = kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL); if (ieee->pHTInfo == NULL) { IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n"); diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_r8192s.h b/drivers/staging/rtl8192su/ieee80211/ieee80211_r8192s.h index 7d6c3bc143ae..1824cda790d8 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211_r8192s.h +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_r8192s.h @@ -172,18 +172,20 @@ enum { IG_Max }; -typedef enum _LED_CTL_MODE { - LED_CTL_POWER_ON = 1, - LED_CTL_LINK = 2, - LED_CTL_NO_LINK = 3, - LED_CTL_TX = 4, - LED_CTL_RX = 5, - LED_CTL_SITE_SURVEY = 6, - LED_CTL_POWER_OFF = 7, - LED_CTL_START_TO_LINK = 8, - LED_CTL_START_WPS = 9, - LED_CTL_STOP_WPS = 10, +typedef enum _LED_CTL_MODE{ + LED_CTL_POWER_ON = 1, + LED_CTL_LINK = 2, + LED_CTL_NO_LINK = 3, + LED_CTL_TX = 4, + LED_CTL_RX = 5, + LED_CTL_SITE_SURVEY = 6, + LED_CTL_POWER_OFF = 7, + LED_CTL_START_TO_LINK = 8, + LED_CTL_START_WPS = 9, + LED_CTL_STOP_WPS = 10, LED_CTL_START_WPS_BOTTON = 11, + LED_CTL_STOP_WPS_FAIL = 12, + LED_CTL_STOP_WPS_FAIL_OVERLAP = 13, } LED_CTL_MODE; typedef union _frameqos { diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_rx.c b/drivers/staging/rtl8192su/ieee80211/ieee80211_rx.c index cc80faf6598b..1f2bc7ac6f79 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211_rx.c +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_rx.c @@ -1191,7 +1191,7 @@ int ieee80211_rtl_rx(struct ieee80211_device *ieee, struct sk_buff *skb, /* skb: hdr + (possible reassembled) full plaintext payload */ payload = skb->data + hdrlen; //ethertype = (payload[6] << 8) | payload[7]; - rxb = (struct ieee80211_rxb*)kmalloc(sizeof(struct ieee80211_rxb),GFP_ATOMIC); + rxb = kmalloc(sizeof(struct ieee80211_rxb), GFP_ATOMIC); if(rxb == NULL) { IEEE80211_DEBUG(IEEE80211_DL_ERR,"%s(): kmalloc rxb error\n",__FUNCTION__); diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_softmac.c b/drivers/staging/rtl8192su/ieee80211/ieee80211_softmac.c index 84a4e23b60b3..4f1f2f08b2d7 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211_softmac.c +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_softmac.c @@ -1557,7 +1557,7 @@ static inline u16 auth_parse(struct sk_buff *skb, u8** challenge, int *chlen) if(*(t++) == MFIE_TYPE_CHALLENGE){ *chlen = *(t++); - *challenge = (u8*)kmalloc(*chlen, GFP_ATOMIC); + *challenge = kmalloc(*chlen, GFP_ATOMIC); memcpy(*challenge, t, *chlen); } } @@ -1691,7 +1691,8 @@ ieee80211_rx_auth_rq(struct ieee80211_device *ieee, struct sk_buff *skb) //IEEE80211DMESG("Rx probe"); ieee->softmac_stats.rx_auth_rq++; - if ((status = auth_rq_parse(skb, dest))!= -1){ + status = auth_rq_parse(skb, dest); + if (status != -1) { ieee80211_resp_to_auth(ieee, status, dest); } //DMESG("Dest is "MACSTR, MAC2STR(dest)); @@ -2698,10 +2699,9 @@ void ieee80211_softmac_init(struct ieee80211_device *ieee) for(i = 0; i < 5; i++) { ieee->seq_ctrl[i] = 0; } - ieee->pDot11dInfo = kmalloc(sizeof(RT_DOT11D_INFO), GFP_ATOMIC); + ieee->pDot11dInfo = kzalloc(sizeof(RT_DOT11D_INFO), GFP_ATOMIC); if (!ieee->pDot11dInfo) IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for DOT11D\n"); - memset(ieee->pDot11dInfo, 0, sizeof(RT_DOT11D_INFO)); //added for AP roaming ieee->LinkDetectInfo.SlotNum = 2; ieee->LinkDetectInfo.NumRecvBcnInPeriod=0; @@ -2844,11 +2844,11 @@ static int ieee80211_wpa_set_wpa_ie(struct ieee80211_device *ieee, return -EINVAL; if (param->u.wpa_ie.len) { - buf = kmalloc(param->u.wpa_ie.len, GFP_KERNEL); + buf = kmemdup(param->u.wpa_ie.data, param->u.wpa_ie.len, + GFP_KERNEL); if (buf == NULL) return -ENOMEM; - memcpy(buf, param->u.wpa_ie.data, param->u.wpa_ie.len); kfree(ieee->wpa_ie); ieee->wpa_ie = buf; ieee->wpa_ie_len = param->u.wpa_ie.len; @@ -3047,8 +3047,7 @@ static int ieee80211_wpa_set_encryption(struct ieee80211_device *ieee, ieee80211_crypt_delayed_deinit(ieee, crypt); - new_crypt = (struct ieee80211_crypt_data *) - kmalloc(sizeof(*new_crypt), GFP_KERNEL); + new_crypt = kmalloc(sizeof(*new_crypt), GFP_KERNEL); if (new_crypt == NULL) { ret = -ENOMEM; goto done; @@ -3181,7 +3180,7 @@ int ieee80211_wpa_supplicant_ioctl(struct ieee80211_device *ieee, struct iw_poin goto out; } - param = (struct ieee_param *)kmalloc(p->length, GFP_KERNEL); + param = kmalloc(p->length, GFP_KERNEL); if (param == NULL){ ret = -ENOMEM; goto out; diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c b/drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c index 727cc552c5ee..2ce5bd543eae 100644 --- a/drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c @@ -352,11 +352,10 @@ int ieee80211_wx_set_encode(struct ieee80211_device *ieee, struct ieee80211_crypt_data *new_crypt; /* take WEP into use */ - new_crypt = kmalloc(sizeof(struct ieee80211_crypt_data), + new_crypt = kzalloc(sizeof(struct ieee80211_crypt_data), GFP_KERNEL); if (new_crypt == NULL) return -ENOMEM; - memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data)); new_crypt->ops = ieee80211_get_crypto_ops("WEP"); if (!new_crypt->ops) new_crypt->ops = ieee80211_get_crypto_ops("WEP"); @@ -768,10 +767,9 @@ int ieee80211_wx_set_gen_ie(struct ieee80211_device *ieee, u8 *ie, size_t len) printk("len: %Zd, ie:%d\n", len, ie[1]); return -EINVAL; } - buf = kmalloc(len, GFP_KERNEL); + buf = kmemdup(ie, len, GFP_KERNEL); if (buf == NULL) return -ENOMEM; - memcpy(buf, ie, len); kfree(ieee->wpa_ie); ieee->wpa_ie = buf; ieee->wpa_ie_len = len; diff --git a/drivers/staging/rtl8192su/ieee80211/rtl819x_Qos.h b/drivers/staging/rtl8192su/ieee80211/rtl819x_Qos.h index 7aa9a7790b63..d4565ecc7ab4 100644 --- a/drivers/staging/rtl8192su/ieee80211/rtl819x_Qos.h +++ b/drivers/staging/rtl8192su/ieee80211/rtl819x_Qos.h @@ -1,7 +1,6 @@ #ifndef __INC_QOS_TYPE_H #define __INC_QOS_TYPE_H -//#include "EndianFree.h" #define BIT0 0x00000001 #define BIT1 0x00000002 #define BIT2 0x00000004 diff --git a/drivers/staging/rtl8192su/ieee80211/rtl819x_TSProc.c b/drivers/staging/rtl8192su/ieee80211/rtl819x_TSProc.c index 38468c539675..de143ecae5fa 100644 --- a/drivers/staging/rtl8192su/ieee80211/rtl819x_TSProc.c +++ b/drivers/staging/rtl8192su/ieee80211/rtl819x_TSProc.c @@ -22,7 +22,6 @@ void TsInactTimeout(unsigned long data) * return: NULL * notice: ********************************************************************************************************************/ -#if 1 void RxPktPendingTimeout(unsigned long data) { PRX_TS_RECORD pRxTs = (PRX_TS_RECORD)data; @@ -83,8 +82,6 @@ void RxPktPendingTimeout(unsigned long data) return; } ieee80211_indicate_packets(ieee, stats_IndicateArray, index); - bPktInBuf = false; - } if(bPktInBuf && (pRxTs->RxTimeoutIndicateSeq==0xffff)) @@ -95,7 +92,6 @@ void RxPktPendingTimeout(unsigned long data) spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags); //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK); } -#endif /******************************************************************************************************************** *function: Add BA timer function @@ -534,8 +530,8 @@ void RemoveTsEntry( void RemovePeerTS(struct ieee80211_device* ieee, u8* Addr) { PTS_COMMON_INFO pTS, pTmpTS; + printk("===========>RemovePeerTS,%pM\n", Addr); -#if 1 list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Pending_List, List) { if (memcmp(pTS->Addr, Addr, 6) == 0) @@ -576,13 +572,12 @@ void RemovePeerTS(struct ieee80211_device* ieee, u8* Addr) list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List); } } -#endif } void RemoveAllTS(struct ieee80211_device* ieee) { PTS_COMMON_INFO pTS, pTmpTS; -#if 1 + list_for_each_entry_safe(pTS, pTmpTS, &ieee->Tx_TS_Pending_List, List) { RemoveTsEntry(ieee, pTS, TX_DIR); @@ -610,7 +605,6 @@ void RemoveAllTS(struct ieee80211_device* ieee) list_del_init(&pTS->List); list_add_tail(&pTS->List, &ieee->Rx_TS_Unused_List); } -#endif } void TsStartAddBaProcess(struct ieee80211_device* ieee, PTX_TS_RECORD pTxTS) @@ -618,7 +612,6 @@ void TsStartAddBaProcess(struct ieee80211_device* ieee, PTX_TS_RECORD pTxTS) if(pTxTS->bAddBaReqInProgress == false) { pTxTS->bAddBaReqInProgress = true; -#if 1 if(pTxTS->bAddBaReqDelayed) { IEEE80211_DEBUG(IEEE80211_DL_BA, "TsStartAddBaProcess(): Delayed Start ADDBA after 60 sec!!\n"); @@ -629,7 +622,6 @@ void TsStartAddBaProcess(struct ieee80211_device* ieee, PTX_TS_RECORD pTxTS) IEEE80211_DEBUG(IEEE80211_DL_BA,"TsStartAddBaProcess(): Immediately Start ADDBA now!!\n"); mod_timer(&pTxTS->TsAddBaTimer, jiffies+10); //set 10 ticks } -#endif } else IEEE80211_DEBUG(IEEE80211_DL_ERR, "%s()==>BA timer is already added\n", __FUNCTION__); diff --git a/drivers/staging/rtl8192su/r8180_93cx6.c b/drivers/staging/rtl8192su/r8180_93cx6.c deleted file mode 100644 index 8878cfeb0fbb..000000000000 --- a/drivers/staging/rtl8192su/r8180_93cx6.c +++ /dev/null @@ -1,146 +0,0 @@ -/* - This files contains card eeprom (93c46 or 93c56) programming routines, - memory is addressed by 16 bits words. - - This is part of rtl8180 OpenSource driver. - Copyright (C) Andrea Merello 2004 <andreamrl@tiscali.it> - Released under the terms of GPL (General Public Licence) - - Parts of this driver are based on the GPL part of the - official realtek driver. - - Parts of this driver are based on the rtl8180 driver skeleton - from Patric Schenke & Andres Salomon. - - Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver. - - We want to tanks the Authors of those projects and the Ndiswrapper - project Authors. -*/ - -#include "r8180_93cx6.h" - -void eprom_cs(struct net_device *dev, short bit) -{ - if(bit) - write_nic_byte_E(dev, EPROM_CMD, - (1<<EPROM_CS_SHIFT) | \ - read_nic_byte_E(dev, EPROM_CMD)); //enable EPROM - else - write_nic_byte_E(dev, EPROM_CMD, read_nic_byte_E(dev, EPROM_CMD)\ - &~(1<<EPROM_CS_SHIFT)); //disable EPROM - - force_pci_posting(dev); - udelay(EPROM_DELAY); -} - - -void eprom_ck_cycle(struct net_device *dev) -{ - write_nic_byte_E(dev, EPROM_CMD, - (1<<EPROM_CK_SHIFT) | read_nic_byte_E(dev,EPROM_CMD)); - force_pci_posting(dev); - udelay(EPROM_DELAY); - write_nic_byte_E(dev, EPROM_CMD, - read_nic_byte_E(dev, EPROM_CMD) &~ (1<<EPROM_CK_SHIFT)); - force_pci_posting(dev); - udelay(EPROM_DELAY); -} - - -void eprom_w(struct net_device *dev,short bit) -{ - if(bit) - write_nic_byte_E(dev, EPROM_CMD, (1<<EPROM_W_SHIFT) | \ - read_nic_byte_E(dev,EPROM_CMD)); - else - write_nic_byte_E(dev, EPROM_CMD, read_nic_byte_E(dev,EPROM_CMD)\ - &~(1<<EPROM_W_SHIFT)); - - force_pci_posting(dev); - udelay(EPROM_DELAY); -} - - -short eprom_r(struct net_device *dev) -{ - short bit; - - bit=(read_nic_byte_E(dev, EPROM_CMD) & (1<<EPROM_R_SHIFT) ); - udelay(EPROM_DELAY); - - if(bit) return 1; - return 0; -} - - -void eprom_send_bits_string(struct net_device *dev, short b[], int len) -{ - int i; - - for(i=0; i<len; i++){ - eprom_w(dev, b[i]); - eprom_ck_cycle(dev); - } -} - - -u32 eprom_read(struct net_device *dev, u32 addr) -{ - struct r8192_priv *priv = ieee80211_priv(dev); - short read_cmd[]={1,1,0}; - short addr_str[8]; - int i; - int addr_len; - u32 ret; - - ret=0; - //enable EPROM programming - write_nic_byte_E(dev, EPROM_CMD, - (EPROM_CMD_PROGRAM<<EPROM_CMD_OPERATING_MODE_SHIFT)); - force_pci_posting(dev); - udelay(EPROM_DELAY); - - if (priv->epromtype==EPROM_93c56){ - addr_str[7]=addr & 1; - addr_str[6]=addr & (1<<1); - addr_str[5]=addr & (1<<2); - addr_str[4]=addr & (1<<3); - addr_str[3]=addr & (1<<4); - addr_str[2]=addr & (1<<5); - addr_str[1]=addr & (1<<6); - addr_str[0]=addr & (1<<7); - addr_len=8; - }else{ - addr_str[5]=addr & 1; - addr_str[4]=addr & (1<<1); - addr_str[3]=addr & (1<<2); - addr_str[2]=addr & (1<<3); - addr_str[1]=addr & (1<<4); - addr_str[0]=addr & (1<<5); - addr_len=6; - } - eprom_cs(dev, 1); - eprom_ck_cycle(dev); - eprom_send_bits_string(dev, read_cmd, 3); - eprom_send_bits_string(dev, addr_str, addr_len); - - //keep chip pin D to low state while reading. - //I'm unsure if it is necessary, but anyway shouldn't hurt - eprom_w(dev, 0); - - for(i=0;i<16;i++){ - //eeprom needs a clk cycle between writing opcode&adr - //and reading data. (eeprom outs a dummy 0) - eprom_ck_cycle(dev); - ret |= (eprom_r(dev)<<(15-i)); - } - - eprom_cs(dev, 0); - eprom_ck_cycle(dev); - - //disable EPROM programming - write_nic_byte_E(dev, EPROM_CMD, - (EPROM_CMD_NORMAL<<EPROM_CMD_OPERATING_MODE_SHIFT)); - return ret; -} diff --git a/drivers/staging/rtl8192su/r8180_93cx6.h b/drivers/staging/rtl8192su/r8180_93cx6.h deleted file mode 100644 index 0309800255cf..000000000000 --- a/drivers/staging/rtl8192su/r8180_93cx6.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - This is part of rtl8187 OpenSource driver - Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it> - Released under the terms of GPL (General Public Licence) - - Parts of this driver are based on the GPL part of the official realtek driver - Parts of this driver are based on the rtl8180 driver skeleton from Patric Schenke & Andres Salomon - Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver - - We want to tanks the Authors of such projects and the Ndiswrapper project Authors. -*/ - -/*This files contains card eeprom (93c46 or 93c56) programming routines*/ -/*memory is addressed by WORDS*/ - -#include "r8192U.h" -#include "r8192S_hw.h" - -#define EPROM_DELAY 10 - -#define EPROM_ANAPARAM_ADDRLWORD 0xd -#define EPROM_ANAPARAM_ADDRHWORD 0xe - -#define EPROM_RFCHIPID 0x6 -#define EPROM_TXPW_BASE 0x05 -#define EPROM_RFCHIPID_RTL8225U 5 -#define EPROM_RF_PARAM 0x4 -#define EPROM_CONFIG2 0xc - -#define EPROM_VERSION 0x1E -#define MAC_ADR 0x7 - -#define CIS 0x18 - -#define EPROM_TXPW0 0x16 -#define EPROM_TXPW2 0x1b -#define EPROM_TXPW1 0x3d - - -u32 eprom_read(struct net_device *dev,u32 addr); //reads a 16 bits word diff --git a/drivers/staging/rtl8192su/r8192SU_led.c b/drivers/staging/rtl8192su/r8192SU_led.c new file mode 100644 index 000000000000..609dba67eb4e --- /dev/null +++ b/drivers/staging/rtl8192su/r8192SU_led.c @@ -0,0 +1,2347 @@ +/* + * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA + * + * The full GNU General Public License is included in this distribution in the + * file called LICENSE. + * + * Contact Information: + * wlanfae <wlanfae@realtek.com> + */ + +#include "r8192U.h" +#include "r8192S_hw.h" +#include "r8192SU_led.h" + +#define LED_BLINK_NORMAL_INTERVAL 100 +#define LED_BLINK_SLOWLY_INTERVAL 200 +#define LED_BLINK_LONG_INTERVAL 400 + +#define LED_BLINK_NO_LINK_INTERVAL_ALPHA 1000 +#define LED_BLINK_LINK_INTERVAL_ALPHA 500 +#define LED_BLINK_SCAN_INTERVAL_ALPHA 180 +#define LED_BLINK_FASTER_INTERVAL_ALPHA 50 +#define LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA 5000 + + + +static void BlinkTimerCallback (unsigned long data); + +static void BlinkWorkItemCallback (struct work_struct *work); + +void InitLed819xUsb (struct net_device *dev, PLED_819xUsb pLed, + LED_PIN_819xUsb LedPin) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + + pLed->dev = dev; + pLed->LedPin = LedPin; + pLed->CurrLedState = LED_OFF; + pLed->bLedOn = FALSE; + + pLed->bLedBlinkInProgress = FALSE; + pLed->BlinkTimes = 0; + pLed->BlinkingLedState = LED_OFF; + + init_timer(&pLed->BlinkTimer); + pLed->BlinkTimer.data = (unsigned long)dev; + pLed->BlinkTimer.function = BlinkTimerCallback; + + INIT_WORK(&priv->BlinkWorkItem, (void*)BlinkWorkItemCallback); + priv->pLed = pLed; +} + + +void DeInitLed819xUsb (PLED_819xUsb pLed) +{ + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; +} + +void SwLedOn (struct net_device *dev, PLED_819xUsb pLed) +{ + u8 LedCfg; + + LedCfg = read_nic_byte(dev, LEDCFG); + switch (pLed->LedPin) { + case LED_PIN_GPIO0: + break; + case LED_PIN_LED0: + write_nic_byte(dev, LEDCFG, LedCfg&0xf0); + break; + case LED_PIN_LED1: + write_nic_byte(dev, LEDCFG, LedCfg&0x0f); + break; + default: + break; + } + pLed->bLedOn = TRUE; +} + +void SwLedOff (struct net_device *dev, PLED_819xUsb pLed) +{ + u8 LedCfg; + + LedCfg = read_nic_byte(dev, LEDCFG); + switch (pLed->LedPin) { + case LED_PIN_GPIO0: + break; + case LED_PIN_LED0: + LedCfg &= 0xf0; + write_nic_byte(dev, LEDCFG, (LedCfg|BIT3)); + break; + case LED_PIN_LED1: + LedCfg &= 0x0f; + write_nic_byte(dev, LEDCFG, (LedCfg|BIT7)); + break; + default: + break; + } + pLed->bLedOn = FALSE; +} + + +void +InitSwLeds( + struct net_device *dev + ) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + + InitLed819xUsb(dev, &(priv->SwLed0), LED_PIN_LED0); + + InitLed819xUsb(dev,&(priv->SwLed1), LED_PIN_LED1); +} + + +void +DeInitSwLeds( + struct net_device *dev + ) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + + DeInitLed819xUsb( &(priv->SwLed0) ); + DeInitLed819xUsb( &(priv->SwLed1) ); +} + + +void +SwLedBlink( + PLED_819xUsb pLed + ) +{ + struct net_device *dev = (struct net_device *)(pLed->dev); + struct r8192_priv *priv = ieee80211_priv(dev); + bool bStopBlinking = FALSE; + + if( pLed->BlinkingLedState == LED_ON ) + { + SwLedOn(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn on\n", pLed->BlinkTimes); + } + else + { + SwLedOff(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn off\n", pLed->BlinkTimes); + } + + pLed->BlinkTimes--; + switch(pLed->CurrLedState) + { + + case LED_BLINK_NORMAL: + if(pLed->BlinkTimes == 0) + { + bStopBlinking = TRUE; + } + break; + + case LED_BLINK_StartToBlink: + if( (priv->ieee80211->state == IEEE80211_LINKED) && (priv->ieee80211->iw_mode == IW_MODE_INFRA)) + { + bStopBlinking = TRUE; + } + else if((priv->ieee80211->state == IEEE80211_LINKED) && (priv->ieee80211->iw_mode == IW_MODE_ADHOC)) + { + bStopBlinking = TRUE; + } + else if(pLed->BlinkTimes == 0) + { + bStopBlinking = TRUE; + } + break; + + case LED_BLINK_WPS: + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + break; + + + default: + bStopBlinking = TRUE; + break; + + } + + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else if( (priv->ieee80211->state == IEEE80211_LINKED) && (pLed->bLedOn == false)) + { + SwLedOn(dev, pLed); + } + else if( (priv->ieee80211->state != IEEE80211_LINKED) && pLed->bLedOn == true) + { + SwLedOff(dev, pLed); + } + + pLed->BlinkTimes = 0; + pLed->bLedBlinkInProgress = FALSE; + } + else + { + if( pLed->BlinkingLedState == LED_ON ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + + switch( pLed->CurrLedState ) + { + case LED_BLINK_NORMAL: + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + break; + + case LED_BLINK_SLOWLY: + case LED_BLINK_StartToBlink: + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL)); + break; + + case LED_BLINK_WPS: + { + if( pLed->BlinkingLedState == LED_ON ) + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LONG_INTERVAL)); + else + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LONG_INTERVAL)); + } + break; + + default: + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL)); + break; + } + } +} + + +void +SwLedBlink1( + PLED_819xUsb pLed + ) +{ + struct net_device *dev = (struct net_device *)(pLed->dev); + struct r8192_priv *priv = ieee80211_priv(dev); + PLED_819xUsb pLed1 = &(priv->SwLed1); + bool bStopBlinking = FALSE; + + if(priv->CustomerID == RT_CID_819x_CAMEO) + pLed = &(priv->SwLed1); + + if( pLed->BlinkingLedState == LED_ON ) + { + SwLedOn(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn on\n", pLed->BlinkTimes); + } + else + { + SwLedOff(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn off\n", pLed->BlinkTimes); + } + + + if(priv->CustomerID == RT_CID_DEFAULT) + { + if(priv->ieee80211->state == IEEE80211_LINKED) + { + if(!pLed1->bSWLedCtrl) + { + SwLedOn(dev, pLed1); + pLed1->bSWLedCtrl = TRUE; + } + else if(!pLed1->bLedOn) + SwLedOn(dev, pLed1); + RT_TRACE(COMP_LED, "Blinktimes (): turn on pLed1\n"); + } + else + { + if(!pLed1->bSWLedCtrl) + { + SwLedOff(dev, pLed1); + pLed1->bSWLedCtrl = TRUE; + } + else if(pLed1->bLedOn) + SwLedOff(dev, pLed1); + RT_TRACE(COMP_LED, "Blinktimes (): turn off pLed1\n"); + } + } + + switch(pLed->CurrLedState) + { + case LED_BLINK_SLOWLY: + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + break; + + case LED_BLINK_NORMAL: + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LINK_INTERVAL_ALPHA)); + break; + + case LED_SCAN_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else if(priv->ieee80211->state == IEEE80211_LINKED) + { + pLed->bLedLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_NORMAL; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LINK_INTERVAL_ALPHA)); + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + + } + else if(priv->ieee80211->state != IEEE80211_LINKED) + { + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + pLed->bLedScanBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + } + } + break; + + case LED_TXRX_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else if(priv->ieee80211->state == IEEE80211_LINKED) + { + pLed->bLedLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_NORMAL; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LINK_INTERVAL_ALPHA)); + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + else if(priv->ieee80211->state != IEEE80211_LINKED) + { + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + pLed->BlinkTimes = 0; + pLed->bLedBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + } + break; + + case LED_BLINK_WPS: + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + break; + + case LED_BLINK_WPS_STOP: + if(pLed->BlinkingLedState == LED_ON) + { + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA)); + bStopBlinking = FALSE; + } + else + { + bStopBlinking = TRUE; + } + + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + pLed->bLedLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_NORMAL; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LINK_INTERVAL_ALPHA)); + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + pLed->bLedWPSBlinkInProgress = FALSE; + } + break; + + default: + break; + } + +} + +void +SwLedBlink2( + PLED_819xUsb pLed + ) +{ + struct net_device *dev = (struct net_device *)(pLed->dev); + struct r8192_priv *priv = ieee80211_priv(dev); + bool bStopBlinking = FALSE; + + if( pLed->BlinkingLedState == LED_ON) + { + SwLedOn(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn on\n", pLed->BlinkTimes); + } + else + { + SwLedOff(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn off\n", pLed->BlinkTimes); + } + + switch(pLed->CurrLedState) + { + case LED_SCAN_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + RT_TRACE(COMP_LED, "eRFPowerState %d\n", priv->ieee80211->eRFPowerState); + } + else if(priv->ieee80211->state == IEEE80211_LINKED) + { + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + SwLedOn(dev, pLed); + RT_TRACE(COMP_LED, "stop scan blink CurrLedState %d\n", pLed->CurrLedState); + + } + else if(priv->ieee80211->state != IEEE80211_LINKED) + { + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + SwLedOff(dev, pLed); + RT_TRACE(COMP_LED, "stop scan blink CurrLedState %d\n", pLed->CurrLedState); + } + pLed->bLedScanBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + } + } + break; + + case LED_TXRX_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else if(priv->ieee80211->state == IEEE80211_LINKED) + { + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + SwLedOn(dev, pLed); + RT_TRACE(COMP_LED, "stop CurrLedState %d\n", pLed->CurrLedState); + + } + else if(priv->ieee80211->state != IEEE80211_LINKED) + { + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + SwLedOff(dev, pLed); + RT_TRACE(COMP_LED, "stop CurrLedState %d\n", pLed->CurrLedState); + } + pLed->bLedBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + } + break; + + default: + break; + } + +} + +void +SwLedBlink3( + PLED_819xUsb pLed + ) +{ + struct net_device *dev = (struct net_device *)(pLed->dev); + struct r8192_priv *priv = ieee80211_priv(dev); + bool bStopBlinking = FALSE; + + if( pLed->BlinkingLedState == LED_ON ) + { + SwLedOn(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn on\n", pLed->BlinkTimes); + } + else + { + if(pLed->CurrLedState != LED_BLINK_WPS_STOP) + SwLedOff(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn off\n", pLed->BlinkTimes); + } + + switch(pLed->CurrLedState) + { + case LED_SCAN_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else if(priv->ieee80211->state == IEEE80211_LINKED) + { + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + if( !pLed->bLedOn ) + SwLedOn(dev, pLed); + + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + else if(priv->ieee80211->state != IEEE80211_LINKED) + { + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + if( pLed->bLedOn ) + SwLedOff(dev, pLed); + + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + pLed->bLedScanBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + } + } + break; + + case LED_TXRX_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else if(priv->ieee80211->state == IEEE80211_LINKED) + { + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + + if( !pLed->bLedOn ) + SwLedOn(dev, pLed); + + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + else if(priv->ieee80211->state != IEEE80211_LINKED) + { + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + + if( pLed->bLedOn ) + SwLedOff(dev, pLed); + + + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + pLed->bLedBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + } + break; + + case LED_BLINK_WPS: + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + break; + + case LED_BLINK_WPS_STOP: + if(pLed->BlinkingLedState == LED_ON) + { + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA)); + bStopBlinking = FALSE; + } + else + { + bStopBlinking = TRUE; + } + + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + SwLedOn(dev, pLed); + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + pLed->bLedWPSBlinkInProgress = FALSE; + } + break; + + + default: + break; + } + +} + + +void +SwLedBlink4( + PLED_819xUsb pLed + ) +{ + struct net_device *dev = (struct net_device *)(pLed->dev); + struct r8192_priv *priv = ieee80211_priv(dev); + PLED_819xUsb pLed1 = &(priv->SwLed1); + bool bStopBlinking = FALSE; + + if( pLed->BlinkingLedState == LED_ON ) + { + SwLedOn(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn on\n", pLed->BlinkTimes); + } + else + { + SwLedOff(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn off\n", pLed->BlinkTimes); + } + + if(!pLed1->bLedWPSBlinkInProgress && pLed1->BlinkingLedState == LED_UNKNOWN) + { + pLed1->BlinkingLedState = LED_OFF; + pLed1->CurrLedState = LED_OFF; + SwLedOff(dev, pLed1); + } + + switch(pLed->CurrLedState) + { + case LED_BLINK_SLOWLY: + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + break; + + case LED_BLINK_StartToBlink: + if( pLed->bLedOn ) + { + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL)); + } + else + { + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + } + break; + + case LED_SCAN_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn && priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS) + { + SwLedOff(dev, pLed); + } + else + { + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + } + pLed->bLedScanBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn && priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + } + } + break; + + case LED_TXRX_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn && priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS) + { + SwLedOff(dev, pLed); + } + else + { + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + } + pLed->bLedBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn && priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + } + break; + + case LED_BLINK_WPS: + if( pLed->bLedOn ) + { + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL)); + } + else + { + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + } + break; + + case LED_BLINK_WPS_STOP: + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + break; + + case LED_BLINK_WPS_STOP_OVERLAP: + pLed->BlinkTimes--; + if(pLed->BlinkTimes == 0) + { + if(pLed->bLedOn) + { + pLed->BlinkTimes = 1; + } + else + { + bStopBlinking = TRUE; + } + } + + if(bStopBlinking) + { + pLed->BlinkTimes = 10; + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LINK_INTERVAL_ALPHA)); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + } + break; + + + default: + break; + } + + RT_TRACE(COMP_LED, "SwLedBlink4 CurrLedState %d\n", pLed->CurrLedState); + + +} + +void +SwLedBlink5( + PLED_819xUsb pLed + ) +{ + struct net_device *dev = (struct net_device *)(pLed->dev); + struct r8192_priv *priv = ieee80211_priv(dev); + bool bStopBlinking = FALSE; + + if( pLed->BlinkingLedState == LED_ON ) + { + SwLedOn(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn on\n", pLed->BlinkTimes); + } + else + { + SwLedOff(dev, pLed); + RT_TRACE(COMP_LED, "Blinktimes (%d): turn off\n", pLed->BlinkTimes); + } + + switch(pLed->CurrLedState) + { + case LED_SCAN_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn && priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS) + { + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + if(pLed->bLedOn) + SwLedOff(dev, pLed); + } + else + { pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + if(!pLed->bLedOn) + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + + pLed->bLedScanBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn && priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + } + } + break; + + + case LED_TXRX_BLINK: + pLed->BlinkTimes--; + if( pLed->BlinkTimes == 0 ) + { + bStopBlinking = TRUE; + } + + if(bStopBlinking) + { + if( priv->ieee80211->eRFPowerState != eRfOn && priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS) + { + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + if(pLed->bLedOn) + SwLedOff(dev, pLed); + } + else + { + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + if(!pLed->bLedOn) + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + + pLed->bLedBlinkInProgress = FALSE; + } + else + { + if( priv->ieee80211->eRFPowerState != eRfOn && priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS) + { + SwLedOff(dev, pLed); + } + else + { + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + } + break; + + default: + break; + } + + RT_TRACE(COMP_LED, "SwLedBlink5 CurrLedState %d\n", pLed->CurrLedState); + + +} + + +void +BlinkTimerCallback( + unsigned long data + ) +{ + struct net_device *dev = (struct net_device *)data; + struct r8192_priv *priv = ieee80211_priv(dev); + +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0) + schedule_work(&(priv->BlinkWorkItem)); +#endif +} + + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) +void BlinkWorkItemCallback(struct work_struct *work) +{ + struct r8192_priv *priv = container_of(work, struct r8192_priv, BlinkWorkItem); +#else +void BlinkWorkItemCallback(void * Context) +{ + struct net_device *dev = (struct net_device *)Context; + struct r8192_priv *priv = ieee80211_priv(dev); +#endif + + PLED_819xUsb pLed = priv->pLed; + + switch(priv->LedStrategy) + { + case SW_LED_MODE0: + SwLedBlink(pLed); + break; + + case SW_LED_MODE1: + SwLedBlink1(pLed); + break; + + case SW_LED_MODE2: + SwLedBlink2(pLed); + break; + + case SW_LED_MODE3: + SwLedBlink3(pLed); + break; + + case SW_LED_MODE4: + SwLedBlink4(pLed); + break; + + case SW_LED_MODE5: + SwLedBlink5(pLed); + break; + + default: + SwLedBlink(pLed); + break; + } +} + + + + +void +SwLedControlMode0( + struct net_device *dev, + LED_CTL_MODE LedAction +) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + PLED_819xUsb pLed = &(priv->SwLed1); + + switch(LedAction) + { + case LED_CTL_TX: + case LED_CTL_RX: + if( pLed->bLedBlinkInProgress == FALSE ) + { + pLed->bLedBlinkInProgress = TRUE; + + pLed->CurrLedState = LED_BLINK_NORMAL; + pLed->BlinkTimes = 2; + + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + } + break; + + case LED_CTL_START_TO_LINK: + if( pLed->bLedBlinkInProgress == FALSE ) + { + pLed->bLedBlinkInProgress = TRUE; + + pLed->CurrLedState = LED_BLINK_StartToBlink; + pLed->BlinkTimes = 24; + + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL)); + } + else + { + pLed->CurrLedState = LED_BLINK_StartToBlink; + } + break; + + case LED_CTL_LINK: + pLed->CurrLedState = LED_ON; + if( pLed->bLedBlinkInProgress == FALSE ) + { + SwLedOn(dev, pLed); + } + break; + + case LED_CTL_NO_LINK: + pLed->CurrLedState = LED_OFF; + if( pLed->bLedBlinkInProgress == FALSE ) + { + SwLedOff(dev, pLed); + } + break; + + case LED_CTL_POWER_OFF: + pLed->CurrLedState = LED_OFF; + if(pLed->bLedBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + SwLedOff(dev, pLed); + break; + + case LED_CTL_START_WPS: + if( pLed->bLedBlinkInProgress == FALSE || pLed->CurrLedState == LED_ON) + { + pLed->bLedBlinkInProgress = TRUE; + + pLed->CurrLedState = LED_BLINK_WPS; + pLed->BlinkTimes = 20; + + if( pLed->bLedOn ) + { + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LONG_INTERVAL)); + } + else + { + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LONG_INTERVAL)); + } + } + break; + + case LED_CTL_STOP_WPS: + if(pLed->bLedBlinkInProgress) + { + pLed->CurrLedState = LED_OFF; + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + break; + + + default: + break; + } + + RT_TRACE(COMP_LED, "Led %d\n", pLed->CurrLedState); + +} + +void +SwLedControlMode1( + struct net_device *dev, + LED_CTL_MODE LedAction +) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + PLED_819xUsb pLed = &(priv->SwLed0); + + if(priv->CustomerID == RT_CID_819x_CAMEO) + pLed = &(priv->SwLed1); + + switch(LedAction) + { + case LED_CTL_START_TO_LINK: + case LED_CTL_NO_LINK: + if( pLed->bLedNoLinkBlinkInProgress == FALSE ) + { + if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed)) + { + return; + } + if( pLed->bLedLinkBlinkInProgress == TRUE ) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedLinkBlinkInProgress = FALSE; + } + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + } + break; + + case LED_CTL_LINK: + if( pLed->bLedLinkBlinkInProgress == FALSE ) + { + if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed)) + { + return; + } + if(pLed->bLedNoLinkBlinkInProgress == TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + pLed->bLedLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_NORMAL; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_LINK_INTERVAL_ALPHA)); + } + break; + + case LED_CTL_SITE_SURVEY: + if((priv->ieee80211->LinkDetectInfo.bBusyTraffic) && (priv->ieee80211->state == IEEE80211_LINKED)) + ; + else if(pLed->bLedScanBlinkInProgress ==FALSE) + { + if(IS_LED_WPS_BLINKING(pLed)) + return; + + if(pLed->bLedNoLinkBlinkInProgress == TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + if( pLed->bLedLinkBlinkInProgress == TRUE ) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedLinkBlinkInProgress = FALSE; + } + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + pLed->bLedScanBlinkInProgress = TRUE; + pLed->CurrLedState = LED_SCAN_BLINK; + pLed->BlinkTimes = 24; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + + } + break; + + case LED_CTL_TX: + case LED_CTL_RX: + if(pLed->bLedBlinkInProgress ==FALSE) + { + if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed)) + { + } + if(pLed->bLedNoLinkBlinkInProgress == TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + if( pLed->bLedLinkBlinkInProgress == TRUE ) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedLinkBlinkInProgress = FALSE; + } + pLed->bLedBlinkInProgress = TRUE; + pLed->CurrLedState = LED_TXRX_BLINK; + pLed->BlinkTimes = 2; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + break; + + case LED_CTL_START_WPS: + case LED_CTL_START_WPS_BOTTON: + if(pLed->bLedWPSBlinkInProgress ==FALSE) + { + if(pLed->bLedNoLinkBlinkInProgress == TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + if( pLed->bLedLinkBlinkInProgress == TRUE ) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedLinkBlinkInProgress = FALSE; + } + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if(pLed->bLedScanBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + pLed->bLedWPSBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_WPS; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + + } + break; + + + case LED_CTL_STOP_WPS: + if(pLed->bLedNoLinkBlinkInProgress == TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + if( pLed->bLedLinkBlinkInProgress == TRUE ) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedLinkBlinkInProgress = FALSE; + } + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if(pLed->bLedScanBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + if(pLed->bLedWPSBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + } + else + { + pLed->bLedWPSBlinkInProgress = TRUE; + } + + pLed->CurrLedState = LED_BLINK_WPS_STOP; + if(pLed->bLedOn) + { + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA)); + } + else + { + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), 0); + } + break; + + case LED_CTL_STOP_WPS_FAIL: + if(pLed->bLedWPSBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + break; + + case LED_CTL_POWER_OFF: + pLed->CurrLedState = LED_OFF; + if( pLed->bLedNoLinkBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + if( pLed->bLedLinkBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedLinkBlinkInProgress = FALSE; + } + if( pLed->bLedBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if( pLed->bLedWPSBlinkInProgress ) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + if( pLed->bLedScanBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + + SwLedOff(dev, pLed); + break; + + default: + break; + + } + + RT_TRACE(COMP_LED, "Led %d\n", pLed->CurrLedState); +} + +void +SwLedControlMode2( + struct net_device *dev, + LED_CTL_MODE LedAction +) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + PLED_819xUsb pLed = &(priv->SwLed0); + + switch(LedAction) + { + case LED_CTL_SITE_SURVEY: + if(priv->ieee80211->LinkDetectInfo.bBusyTraffic) + ; + else if(pLed->bLedScanBlinkInProgress ==FALSE) + { + if(IS_LED_WPS_BLINKING(pLed)) + return; + + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + pLed->bLedScanBlinkInProgress = TRUE; + pLed->CurrLedState = LED_SCAN_BLINK; + pLed->BlinkTimes = 24; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + + } + break; + + case LED_CTL_TX: + case LED_CTL_RX: + if((pLed->bLedBlinkInProgress ==FALSE) && (priv->ieee80211->state == IEEE80211_LINKED)) + { + if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed)) + { + return; + } + + pLed->bLedBlinkInProgress = TRUE; + pLed->CurrLedState = LED_TXRX_BLINK; + pLed->BlinkTimes = 2; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + break; + + case LED_CTL_LINK: + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + if( pLed->bLedBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if( pLed->bLedScanBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + + mod_timer(&(pLed->BlinkTimer), 0); + break; + + case LED_CTL_START_WPS: + case LED_CTL_START_WPS_BOTTON: + if(pLed->bLedWPSBlinkInProgress ==FALSE) + { + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if(pLed->bLedScanBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + pLed->bLedWPSBlinkInProgress = TRUE; + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), 0); + } + break; + + case LED_CTL_STOP_WPS: + pLed->bLedWPSBlinkInProgress = FALSE; + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), 0); + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + break; + + case LED_CTL_STOP_WPS_FAIL: + pLed->bLedWPSBlinkInProgress = FALSE; + if( priv->ieee80211->eRFPowerState != eRfOn ) + { + SwLedOff(dev, pLed); + } + else + { + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), 0); + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); + } + break; + + case LED_CTL_START_TO_LINK: + case LED_CTL_NO_LINK: + if(!IS_LED_BLINKING(pLed)) + { + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), 0); + } + break; + + case LED_CTL_POWER_OFF: + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + if( pLed->bLedBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if( pLed->bLedScanBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + if( pLed->bLedWPSBlinkInProgress ) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + + mod_timer(&(pLed->BlinkTimer), 0); + break; + + default: + break; + + } + + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); +} + + void + SwLedControlMode3( + struct net_device *dev, + LED_CTL_MODE LedAction +) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + PLED_819xUsb pLed = &(priv->SwLed0); + + switch(LedAction) + { + case LED_CTL_SITE_SURVEY: + if(priv->ieee80211->LinkDetectInfo.bBusyTraffic) + ; + else if(pLed->bLedScanBlinkInProgress ==FALSE) + { + if(IS_LED_WPS_BLINKING(pLed)) + return; + + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + pLed->bLedScanBlinkInProgress = TRUE; + pLed->CurrLedState = LED_SCAN_BLINK; + pLed->BlinkTimes = 24; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + + } + break; + + case LED_CTL_TX: + case LED_CTL_RX: + if((pLed->bLedBlinkInProgress ==FALSE) && (priv->ieee80211->state == IEEE80211_LINKED)) + { + if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed)) + { + return; + } + + pLed->bLedBlinkInProgress = TRUE; + pLed->CurrLedState = LED_TXRX_BLINK; + pLed->BlinkTimes = 2; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + break; + + case LED_CTL_LINK: + if(IS_LED_WPS_BLINKING(pLed)) + return; + + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + if( pLed->bLedBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if( pLed->bLedScanBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + + mod_timer(&(pLed->BlinkTimer), 0); + break; + + case LED_CTL_START_WPS: + case LED_CTL_START_WPS_BOTTON: + if(pLed->bLedWPSBlinkInProgress ==FALSE) + { + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if(pLed->bLedScanBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + pLed->bLedWPSBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_WPS; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + + } + break; + + case LED_CTL_STOP_WPS: + if(pLed->bLedWPSBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + else + { + pLed->bLedWPSBlinkInProgress = TRUE; + } + + pLed->CurrLedState = LED_BLINK_WPS_STOP; + if(pLed->bLedOn) + { + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA)); + } + else + { + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), 0); + } + + break; + + + case LED_CTL_STOP_WPS_FAIL: + if(pLed->bLedWPSBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), 0); + break; + + case LED_CTL_START_TO_LINK: + case LED_CTL_NO_LINK: + if(!IS_LED_BLINKING(pLed)) + { + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), 0); + } + break; + + case LED_CTL_POWER_OFF: + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + if( pLed->bLedBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if( pLed->bLedScanBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + if( pLed->bLedWPSBlinkInProgress ) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + + mod_timer(&(pLed->BlinkTimer), 0); + break; + + default: + break; + + } + + RT_TRACE(COMP_LED, "CurrLedState %d\n", pLed->CurrLedState); +} + + +void +SwLedControlMode4( + struct net_device *dev, + LED_CTL_MODE LedAction +) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + PLED_819xUsb pLed = &(priv->SwLed0); + PLED_819xUsb pLed1 = &(priv->SwLed1); + + switch(LedAction) + { + case LED_CTL_START_TO_LINK: + if(pLed1->bLedWPSBlinkInProgress) + { + pLed1->bLedWPSBlinkInProgress = FALSE; + del_timer_sync(&(pLed1->BlinkTimer)); + + pLed1->BlinkingLedState = LED_OFF; + pLed1->CurrLedState = LED_OFF; + + if(pLed1->bLedOn) + mod_timer(&(pLed1->BlinkTimer), 0); + } + + if( pLed->bLedStartToLinkBlinkInProgress == FALSE ) + { + if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed)) + { + return; + } + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if(pLed->bLedNoLinkBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + + pLed->bLedStartToLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_StartToBlink; + if( pLed->bLedOn ) + { + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL)); + } + else + { + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + } + } + break; + + case LED_CTL_LINK: + case LED_CTL_NO_LINK: + if(LedAction == LED_CTL_LINK) + { + if(pLed1->bLedWPSBlinkInProgress) + { + pLed1->bLedWPSBlinkInProgress = FALSE; + del_timer_sync(&(pLed1->BlinkTimer)); + + pLed1->BlinkingLedState = LED_OFF; + pLed1->CurrLedState = LED_OFF; + + if(pLed1->bLedOn) + mod_timer(&(pLed1->BlinkTimer), 0); + } + } + + if( pLed->bLedNoLinkBlinkInProgress == FALSE ) + { + if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed)) + { + return; + } + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + } + + break; + + case LED_CTL_SITE_SURVEY: + if((priv->ieee80211->LinkDetectInfo.bBusyTraffic) && (priv->ieee80211->state == IEEE80211_LINKED)) + ; + else if(pLed->bLedScanBlinkInProgress ==FALSE) + { + if(IS_LED_WPS_BLINKING(pLed)) + return; + + if(pLed->bLedNoLinkBlinkInProgress == TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + pLed->bLedScanBlinkInProgress = TRUE; + pLed->CurrLedState = LED_SCAN_BLINK; + pLed->BlinkTimes = 24; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + + } + break; + + case LED_CTL_TX: + case LED_CTL_RX: + if(pLed->bLedBlinkInProgress ==FALSE) + { + if(pLed->CurrLedState == LED_SCAN_BLINK || IS_LED_WPS_BLINKING(pLed)) + { + return; + } + if(pLed->bLedNoLinkBlinkInProgress == TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + pLed->bLedBlinkInProgress = TRUE; + pLed->CurrLedState = LED_TXRX_BLINK; + pLed->BlinkTimes = 2; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + break; + + case LED_CTL_START_WPS: + case LED_CTL_START_WPS_BOTTON: + if(pLed1->bLedWPSBlinkInProgress) + { + pLed1->bLedWPSBlinkInProgress = FALSE; + del_timer_sync(&(pLed1->BlinkTimer)); + + pLed1->BlinkingLedState = LED_OFF; + pLed1->CurrLedState = LED_OFF; + + if(pLed1->bLedOn) + mod_timer(&(pLed1->BlinkTimer), 0); + } + + if(pLed->bLedWPSBlinkInProgress ==FALSE) + { + if(pLed->bLedNoLinkBlinkInProgress == TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if(pLed->bLedScanBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + pLed->bLedWPSBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_WPS; + if( pLed->bLedOn ) + { + pLed->BlinkingLedState = LED_OFF; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SLOWLY_INTERVAL)); + } + else + { + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + } + + } + break; + + case LED_CTL_STOP_WPS: + if(pLed->bLedWPSBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + + break; + + case LED_CTL_STOP_WPS_FAIL: + if(pLed->bLedWPSBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + + if(pLed1->bLedWPSBlinkInProgress) + del_timer_sync(&(pLed1->BlinkTimer)); + else + pLed1->bLedWPSBlinkInProgress = TRUE; + + pLed1->CurrLedState = LED_BLINK_WPS_STOP; + if( pLed1->bLedOn ) + pLed1->BlinkingLedState = LED_OFF; + else + pLed1->BlinkingLedState = LED_ON; + mod_timer(&(pLed1->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + + break; + + case LED_CTL_STOP_WPS_FAIL_OVERLAP: + if(pLed->bLedWPSBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + + pLed->bLedNoLinkBlinkInProgress = TRUE; + pLed->CurrLedState = LED_BLINK_SLOWLY; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_NO_LINK_INTERVAL_ALPHA)); + + if(pLed1->bLedWPSBlinkInProgress) + del_timer_sync(&(pLed1->BlinkTimer)); + else + pLed1->bLedWPSBlinkInProgress = TRUE; + + pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP; + pLed1->BlinkTimes = 10; + if( pLed1->bLedOn ) + pLed1->BlinkingLedState = LED_OFF; + else + pLed1->BlinkingLedState = LED_ON; + mod_timer(&(pLed1->BlinkTimer), jiffies + MSECS(LED_BLINK_NORMAL_INTERVAL)); + + break; + + case LED_CTL_POWER_OFF: + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + + if( pLed->bLedNoLinkBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedNoLinkBlinkInProgress = FALSE; + } + if( pLed->bLedLinkBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedLinkBlinkInProgress = FALSE; + } + if( pLed->bLedBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + if( pLed->bLedWPSBlinkInProgress ) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedWPSBlinkInProgress = FALSE; + } + if( pLed->bLedScanBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedScanBlinkInProgress = FALSE; + } + if( pLed->bLedStartToLinkBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedStartToLinkBlinkInProgress = FALSE; + } + + if( pLed1->bLedWPSBlinkInProgress ) + { + del_timer_sync(&(pLed1->BlinkTimer)); + pLed1->bLedWPSBlinkInProgress = FALSE; + } + + + pLed1->BlinkingLedState = LED_UNKNOWN; + SwLedOff(dev, pLed); + SwLedOff(dev, pLed1); + break; + + default: + break; + + } + + RT_TRACE(COMP_LED, "Led %d\n", pLed->CurrLedState); +} + + + +void +SwLedControlMode5( + struct net_device *dev, + LED_CTL_MODE LedAction +) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + PLED_819xUsb pLed = &(priv->SwLed0); + + if(priv->CustomerID == RT_CID_819x_CAMEO) + pLed = &(priv->SwLed1); + + switch(LedAction) + { + case LED_CTL_POWER_ON: + case LED_CTL_NO_LINK: + case LED_CTL_LINK: + if(pLed->CurrLedState == LED_SCAN_BLINK) + { + return; + } + pLed->CurrLedState = LED_ON; + pLed->BlinkingLedState = LED_ON; + pLed->bLedBlinkInProgress = FALSE; + mod_timer(&(pLed->BlinkTimer), 0); + break; + + case LED_CTL_SITE_SURVEY: + if((priv->ieee80211->LinkDetectInfo.bBusyTraffic) && (priv->ieee80211->state == IEEE80211_LINKED)) + ; + else if(pLed->bLedScanBlinkInProgress ==FALSE) + { + if(pLed->bLedBlinkInProgress ==TRUE) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + pLed->bLedScanBlinkInProgress = TRUE; + pLed->CurrLedState = LED_SCAN_BLINK; + pLed->BlinkTimes = 24; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_SCAN_INTERVAL_ALPHA)); + + } + break; + + case LED_CTL_TX: + case LED_CTL_RX: + if(pLed->bLedBlinkInProgress ==FALSE) + { + if(pLed->CurrLedState == LED_SCAN_BLINK) + { + return; + } + pLed->bLedBlinkInProgress = TRUE; + pLed->CurrLedState = LED_TXRX_BLINK; + pLed->BlinkTimes = 2; + if( pLed->bLedOn ) + pLed->BlinkingLedState = LED_OFF; + else + pLed->BlinkingLedState = LED_ON; + mod_timer(&(pLed->BlinkTimer), jiffies + MSECS(LED_BLINK_FASTER_INTERVAL_ALPHA)); + } + break; + + case LED_CTL_POWER_OFF: + pLed->CurrLedState = LED_OFF; + pLed->BlinkingLedState = LED_OFF; + + if( pLed->bLedBlinkInProgress) + { + del_timer_sync(&(pLed->BlinkTimer)); + pLed->bLedBlinkInProgress = FALSE; + } + + SwLedOff(dev, pLed); + break; + + default: + break; + + } + + RT_TRACE(COMP_LED, "Led %d\n", pLed->CurrLedState); +} + + +void +LedControl8192SUsb( + struct net_device *dev, + LED_CTL_MODE LedAction + ) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + + if( priv->bRegUseLed == FALSE) + return; + + if (!priv->up) + return; + + if(priv->bInHctTest) + return; + + if( priv->ieee80211->eRFPowerState != eRfOn && + (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX || + LedAction == LED_CTL_SITE_SURVEY || + LedAction == LED_CTL_LINK || + LedAction == LED_CTL_NO_LINK || + LedAction == LED_CTL_POWER_ON) ) + { + return; + } + + switch(priv->LedStrategy) + { + case SW_LED_MODE0: + break; + + case SW_LED_MODE1: + SwLedControlMode1(dev, LedAction); + break; + case SW_LED_MODE2: + SwLedControlMode2(dev, LedAction); + break; + + case SW_LED_MODE3: + SwLedControlMode3(dev, LedAction); + break; + + case SW_LED_MODE4: + SwLedControlMode4(dev, LedAction); + break; + + case SW_LED_MODE5: + SwLedControlMode5(dev, LedAction); + break; + + default: + break; + } + + RT_TRACE(COMP_LED, "LedStrategy:%d, LedAction %d\n", priv->LedStrategy,LedAction); +} + + diff --git a/drivers/staging/rtl8192su/r8192SU_led.h b/drivers/staging/rtl8192su/r8192SU_led.h new file mode 100644 index 000000000000..acedae4a59ca --- /dev/null +++ b/drivers/staging/rtl8192su/r8192SU_led.h @@ -0,0 +1,93 @@ +/****************************************************************************** + * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA + * + * The full GNU General Public License is included in this distribution in the + * file called LICENSE. + * + * Contact Information: + * wlanfae <wlanfae@realtek.com> +******************************************************************************/ +#ifndef __INC_HAL8192USBLED_H +#define __INC_HAL8192USBLED_H + +#include <linux/types.h> +#include <linux/timer.h> + +typedef enum _LED_STATE_819xUsb{ + LED_UNKNOWN = 0, + LED_ON = 1, + LED_OFF = 2, + LED_BLINK_NORMAL = 3, + LED_BLINK_SLOWLY = 4, + LED_POWER_ON_BLINK = 5, + LED_SCAN_BLINK = 6, + LED_NO_LINK_BLINK = 7, + LED_BLINK_StartToBlink = 8, + LED_BLINK_WPS = 9, + LED_TXRX_BLINK = 10, + LED_BLINK_WPS_STOP = 11, + LED_BLINK_WPS_STOP_OVERLAP = 12, + +}LED_STATE_819xUsb; + +#define IS_LED_WPS_BLINKING(_LED_819xUsb) (((PLED_819xUsb)_LED_819xUsb)->CurrLedState==LED_BLINK_WPS \ + || ((PLED_819xUsb)_LED_819xUsb)->CurrLedState==LED_BLINK_WPS_STOP \ + || ((PLED_819xUsb)_LED_819xUsb)->bLedWPSBlinkInProgress) + +#define IS_LED_BLINKING(_LED_819xUsb) (((PLED_819xUsb)_LED_819xUsb)->bLedWPSBlinkInProgress \ + ||((PLED_819xUsb)_LED_819xUsb)->bLedScanBlinkInProgress) + +typedef enum _LED_PIN_819xUsb{ + LED_PIN_GPIO0, + LED_PIN_LED0, + LED_PIN_LED1 +}LED_PIN_819xUsb; + +typedef enum _LED_STRATEGY_819xUsb{ + SW_LED_MODE0, /* SW control 1 LED via GPIO0. It is default option. */ + SW_LED_MODE1, /* SW control for PCI Express */ + SW_LED_MODE2, /* SW control for Cameo. */ + SW_LED_MODE3, /* SW contorl for RunTop. */ + SW_LED_MODE4, /* SW control for Netcore */ + SW_LED_MODE5, + HW_LED, /* HW control 2 LEDs, LED0 and LED1 (there are 4 different control modes) */ +}LED_STRATEGY_819xUsb, *PLED_STRATEGY_819xUsb; + +typedef struct _LED_819xUsb{ + struct net_device *dev; + + LED_PIN_819xUsb LedPin; + + LED_STATE_819xUsb CurrLedState; + bool bLedOn; + + bool bSWLedCtrl; + + bool bLedBlinkInProgress; + bool bLedNoLinkBlinkInProgress; + bool bLedLinkBlinkInProgress; + bool bLedStartToLinkBlinkInProgress; + bool bLedScanBlinkInProgress; + bool bLedWPSBlinkInProgress; + + u32 BlinkTimes; + LED_STATE_819xUsb BlinkingLedState; + + struct timer_list BlinkTimer; +} LED_819xUsb, *PLED_819xUsb; + +void InitSwLeds(struct net_device *dev); +void DeInitSwLeds(struct net_device *dev); +void LedControl8192SUsb(struct net_device *dev,LED_CTL_MODE LedAction); + +#endif + diff --git a/drivers/staging/rtl8192su/r8192S_firmware.c b/drivers/staging/rtl8192su/r8192S_firmware.c index 752a3f1fb3f5..5036d547d5d3 100644 --- a/drivers/staging/rtl8192su/r8192S_firmware.c +++ b/drivers/staging/rtl8192su/r8192S_firmware.c @@ -31,44 +31,46 @@ // Code size // Created by Roger, 2008.04.10. // -bool FirmwareDownloadCode(struct net_device *dev, u8 * code_virtual_address,u32 buffer_len) +bool FirmwareDownloadCode(struct net_device *dev, + u8 *code_virtual_address, + u32 buffer_len) { - struct r8192_priv *priv = ieee80211_priv(dev); - bool rt_status = true; - u16 frag_threshold = MAX_FIRMWARE_CODE_SIZE; //Fragmentation might be required in 90/92 but not in 92S - u16 frag_length, frag_offset = 0; - struct sk_buff *skb; - unsigned char *seg_ptr; - cb_desc *tcb_desc; - u8 bLastIniPkt = 0; - u16 ExtraDescOffset = 0; - - - RT_TRACE(COMP_FIRMWARE, "--->FirmwareDownloadCode()\n" ); - - //MAX_TRANSMIT_BUFFER_SIZE - if(buffer_len >= MAX_FIRMWARE_CODE_SIZE-USB_HWDESC_HEADER_LEN) - { - RT_TRACE(COMP_ERR, "Size over MAX_FIRMWARE_CODE_SIZE! \n"); + struct r8192_priv *priv = ieee80211_priv(dev); + bool rt_status = true; + /* Fragmentation might be required in 90/92 but not in 92S */ + u16 frag_threshold = MAX_FIRMWARE_CODE_SIZE; + u16 frag_length, frag_offset = 0; + struct sk_buff *skb; + unsigned char *seg_ptr; + cb_desc *tcb_desc; + u8 bLastIniPkt = 0; + u16 ExtraDescOffset = 0; + + if (buffer_len >= MAX_FIRMWARE_CODE_SIZE - USB_HWDESC_HEADER_LEN) { + RT_TRACE(COMP_ERR, "(%s): Firmware exceeds" + " MAX_FIRMWARE_CODE_SIZE\n", __func__); goto cmdsend_downloadcode_fail; } - ExtraDescOffset = USB_HWDESC_HEADER_LEN; - do { if((buffer_len-frag_offset) > frag_threshold) - { frag_length = frag_threshold + ExtraDescOffset; + else { + frag_length = (u16)(buffer_len - + frag_offset + ExtraDescOffset); + bLastIniPkt = 1; } - else - { - frag_length = (u16)(buffer_len - frag_offset + ExtraDescOffset); - bLastIniPkt = 1; - } - - /* Allocate skb buffer to contain firmware info and tx descriptor info. */ + /* + * Allocate skb buffer to contain firmware info + * and tx descriptor info. + */ skb = dev_alloc_skb(frag_length); - memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev)); + if (skb == NULL) { + RT_TRACE(COMP_ERR, "(%s): unable to alloc skb buffer\n", + __func__); + goto cmdsend_downloadcode_fail; + } + memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev)); tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE); tcb_desc->queue_index = TXCMD_QUEUE; @@ -76,73 +78,60 @@ bool FirmwareDownloadCode(struct net_device *dev, u8 * code_virtual_address,u32 tcb_desc->bLastIniPkt = bLastIniPkt; skb_reserve(skb, ExtraDescOffset); - seg_ptr = (u8 *)skb_put(skb, (u32)(frag_length-ExtraDescOffset)); - memcpy(seg_ptr, code_virtual_address+frag_offset, (u32)(frag_length-ExtraDescOffset)); - tcb_desc->txbuf_size= frag_length; + seg_ptr = (u8 *)skb_put(skb, + (u32)(frag_length - ExtraDescOffset)); + + memcpy(seg_ptr, code_virtual_address + frag_offset, + (u32)(frag_length-ExtraDescOffset)); + + tcb_desc->txbuf_size = frag_length; - if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)|| - (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\ - (priv->ieee80211->queue_stop) ) - { + if (!priv->ieee80211->check_nic_enough_desc(dev, tcb_desc->queue_index) || + (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index])) || + (priv->ieee80211->queue_stop)) { RT_TRACE(COMP_FIRMWARE,"=====================================================> tx full!\n"); skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb); - } - else - { - priv->ieee80211->softmac_hard_start_xmit(skb,dev); - } + } else + priv->ieee80211->softmac_hard_start_xmit(skb, dev); frag_offset += (frag_length - ExtraDescOffset); - }while(frag_offset < buffer_len); - + } while (frag_offset < buffer_len); return rt_status ; - cmdsend_downloadcode_fail: rt_status = false; - RT_TRACE(COMP_ERR, "CmdSendDownloadCode fail !!\n"); + RT_TRACE(COMP_ERR, "(%s): failed\n", __func__); return rt_status; - } -RT_STATUS -FirmwareEnableCPU(struct net_device *dev) +bool FirmwareEnableCPU(struct net_device *dev) { + bool rtStatus = true; + u8 tmpU1b, CPUStatus = 0; + u16 tmpU2b; + u32 iCheckTime = 200; - RT_STATUS rtStatus = RT_STATUS_SUCCESS; - u8 tmpU1b, CPUStatus = 0; - u16 tmpU2b; - u32 iCheckTime = 200; - - RT_TRACE(COMP_FIRMWARE, "-->FirmwareEnableCPU()\n" ); - // Enable CPU. + /* Enable CPU. */ tmpU1b = read_nic_byte(dev, SYS_CLKR); - write_nic_byte(dev, SYS_CLKR, (tmpU1b|SYS_CPU_CLKSEL)); //AFE source - + /* AFE source */ + write_nic_byte(dev, SYS_CLKR, (tmpU1b|SYS_CPU_CLKSEL)); tmpU2b = read_nic_word(dev, SYS_FUNC_EN); write_nic_word(dev, SYS_FUNC_EN, (tmpU2b|FEN_CPUEN)); - - //Polling IMEM Ready after CPU has refilled. - do - { + /* Poll IMEM Ready after CPU has refilled. */ + do { CPUStatus = read_nic_byte(dev, TCR); - if(CPUStatus& IMEM_RDY) - { - RT_TRACE(COMP_FIRMWARE, "IMEM Ready after CPU has refilled.\n"); + if (CPUStatus & IMEM_RDY) + /* success */ break; - } - - //usleep(100); udelay(100); - }while(iCheckTime--); - - if(!(CPUStatus & IMEM_RDY)) - return RT_STATUS_FAILURE; - - RT_TRACE(COMP_FIRMWARE, "<--FirmwareEnableCPU(): rtStatus(%#x)\n", rtStatus); + } while (iCheckTime--); + if (!(CPUStatus & IMEM_RDY)) { + RT_TRACE(COMP_ERR, "%s(): failed to enable CPU", __func__); + rtStatus = false; + } return rtStatus; } @@ -176,106 +165,87 @@ FirmwareGetNextStatus(FIRMWARE_8192S_STATUS FWCurrentStatus) return NextFWStatus; } -bool -FirmwareCheckReady(struct net_device *dev, u8 LoadFWStatus) +bool FirmwareCheckReady(struct net_device *dev, u8 LoadFWStatus) { - struct r8192_priv *priv = ieee80211_priv(dev); - RT_STATUS rtStatus = RT_STATUS_SUCCESS; - rt_firmware *pFirmware = priv->pFirmware; - int PollingCnt = 1000; - //u8 tmpU1b, CPUStatus = 0; - u8 CPUStatus = 0; - u32 tmpU4b; - //bool bOrgIMREnable; - - RT_TRACE(COMP_FIRMWARE, "--->FirmwareCheckReady(): LoadStaus(%d),", LoadFWStatus); + struct r8192_priv *priv = ieee80211_priv(dev); + bool rtStatus = true; + rt_firmware *pFirmware = priv->pFirmware; + int PollingCnt = 1000; + u8 CPUStatus = 0; + u32 tmpU4b; pFirmware->FWStatus = (FIRMWARE_8192S_STATUS)LoadFWStatus; - if( LoadFWStatus == FW_STATUS_LOAD_IMEM) - { - do - {//Polling IMEM code done. + switch (LoadFWStatus) { + case FW_STATUS_LOAD_IMEM: + do { /* Polling IMEM code done. */ CPUStatus = read_nic_byte(dev, TCR); if(CPUStatus& IMEM_CODE_DONE) break; - udelay(5); - }while(PollingCnt--); - if(!(CPUStatus & IMEM_CHK_RPT) || PollingCnt <= 0) - { + } while (PollingCnt--); + if (!(CPUStatus & IMEM_CHK_RPT) || PollingCnt <= 0) { RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_IMEM FAIL CPU, Status=%x\r\n", CPUStatus); - return false; + goto FirmwareCheckReadyFail; } - } - else if( LoadFWStatus == FW_STATUS_LOAD_EMEM) - {//Check Put Code OK and Turn On CPU - do - {//Polling EMEM code done. + break; + case FW_STATUS_LOAD_EMEM: /* Check Put Code OK and Turn On CPU */ + do { /* Polling EMEM code done. */ CPUStatus = read_nic_byte(dev, TCR); if(CPUStatus& EMEM_CODE_DONE) break; - udelay(5); - }while(PollingCnt--); - if(!(CPUStatus & EMEM_CHK_RPT)) - { + } while (PollingCnt--); + if (!(CPUStatus & EMEM_CHK_RPT)) { RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_EMEM FAIL CPU, Status=%x\r\n", CPUStatus); - return false; + goto FirmwareCheckReadyFail; } - - // Turn On CPU - rtStatus = FirmwareEnableCPU(dev); - if(rtStatus != RT_STATUS_SUCCESS) - { - RT_TRACE(COMP_ERR, "Enable CPU fail ! \n" ); - return false; + /* Turn On CPU */ + if (FirmwareEnableCPU(dev) != true) { + RT_TRACE(COMP_ERR, "%s(): failed to enable CPU", + __func__); + goto FirmwareCheckReadyFail; } - } - else if( LoadFWStatus == FW_STATUS_LOAD_DMEM) - { - do - {//Polling DMEM code done + break; + case FW_STATUS_LOAD_DMEM: + do { /* Polling DMEM code done */ CPUStatus = read_nic_byte(dev, TCR); if(CPUStatus& DMEM_CODE_DONE) break; udelay(5); - }while(PollingCnt--); + } while (PollingCnt--); - if(!(CPUStatus & DMEM_CODE_DONE)) - { + if (!(CPUStatus & DMEM_CODE_DONE)) { RT_TRACE(COMP_ERR, "Polling DMEM code done fail ! CPUStatus(%#x)\n", CPUStatus); - return false; + goto FirmwareCheckReadyFail; } - RT_TRACE(COMP_FIRMWARE, "DMEM code download success, CPUStatus(%#x)\n", CPUStatus); + RT_TRACE(COMP_FIRMWARE, "%s(): DMEM code download success, " + "CPUStatus(%#x)", + __func__, CPUStatus); -// PollingCnt = 100; // Set polling cycle to 10ms. - PollingCnt = 10000; // Set polling cycle to 10ms. + PollingCnt = 10000; /* Set polling cycle to 10ms. */ - do - {//Polling Load Firmware ready + do { /* Polling Load Firmware ready */ CPUStatus = read_nic_byte(dev, TCR); if(CPUStatus & FWRDY) break; - udelay(100); - }while(PollingCnt--); + } while (PollingCnt--); - RT_TRACE(COMP_FIRMWARE, "Polling Load Firmware ready, CPUStatus(%x)\n", CPUStatus); + RT_TRACE(COMP_FIRMWARE, "%s(): polling load firmware ready, " + "CPUStatus(%x)", + __func__, CPUStatus); - //if(!(CPUStatus & LOAD_FW_READY)) - //if((CPUStatus & LOAD_FW_READY) != 0xff) - if((CPUStatus & LOAD_FW_READY) != LOAD_FW_READY) - { - RT_TRACE(COMP_ERR, "Polling Load Firmware ready fail ! CPUStatus(%x)\n", CPUStatus); - return false; + if ((CPUStatus & LOAD_FW_READY) != LOAD_FW_READY) { + RT_TRACE(COMP_ERR, "Polling Load Firmware ready failed " + "CPUStatus(%x)\n", CPUStatus); + goto FirmwareCheckReadyFail; } - - // - // <Roger_Notes> USB interface will update reserved followings parameters later!! - // 2008.08.28. - // + /* + * USB interface will update + * reserved followings parameters later + */ // // <Roger_Notes> If right here, we can set TCR/RCR to desired value @@ -288,16 +258,23 @@ FirmwareCheckReady(struct net_device *dev, u8 LoadFWStatus) write_nic_dword(dev, RCR, (tmpU4b|RCR_APPFCS|RCR_APP_ICV|RCR_APP_MIC)); - RT_TRACE(COMP_FIRMWARE, "FirmwareCheckReady(): Current RCR settings(%#x)\n", tmpU4b); - - + RT_TRACE(COMP_FIRMWARE, "%s(): Current RCR settings(%#x)", + __func__, tmpU4b); // Set to normal mode. write_nic_byte(dev, LBKMD_SEL, LBK_NORMAL); - + break; + default: + break; } + RT_TRACE(COMP_FIRMWARE, "%s(): LoadFWStatus(%d), success", + __func__, LoadFWStatus); + return rtStatus; - RT_TRACE(COMP_FIRMWARE, "<---FirmwareCheckReady(): LoadFWStatus(%d), rtStatus(%x)\n", LoadFWStatus, rtStatus); - return (rtStatus == RT_STATUS_SUCCESS) ? true:false; +FirmwareCheckReadyFail: + rtStatus = false; + RT_TRACE(COMP_FIRMWARE, "%s(): LoadFWStatus(%d), failed", + __func__, LoadFWStatus); + return rtStatus; } // @@ -338,143 +315,159 @@ void FirmwareHeaderPriveUpdate(struct net_device *dev, PRT_8192S_FIRMWARE_PRIV pFwPriv->rf_config = FirmwareHeaderMapRfType(dev); } +bool FirmwareRequest92S(struct net_device *dev, rt_firmware *pFirmware) +{ + struct r8192_priv *priv = ieee80211_priv(dev); + bool rtStatus = true; + const char *pFwImageFileName[1] = {"RTL8192SU/rtl8192sfw.bin"}; + u8 *pucMappedFile = NULL; + u32 ulInitStep = 0; + u8 FwHdrSize = RT_8192S_FIRMWARE_HDR_SIZE; + PRT_8192S_FIRMWARE_HDR pFwHdr = NULL; + u32 file_length = 0; + int rc; + const struct firmware *fw_entry; + + rc = request_firmware(&fw_entry, + pFwImageFileName[ulInitStep], + &priv->udev->dev); + if (rc < 0) + goto RequestFirmware_Fail; + + if (fw_entry->size > sizeof(pFirmware->szFwTmpBuffer)) { + RT_TRACE(COMP_ERR, "%s(): image file too large" + "for container buffer", __func__); + release_firmware(fw_entry); + goto RequestFirmware_Fail; + } + memcpy(pFirmware->szFwTmpBuffer, fw_entry->data, fw_entry->size); + pFirmware->szFwTmpBufferLen = fw_entry->size; + release_firmware(fw_entry); + + pucMappedFile = pFirmware->szFwTmpBuffer; + file_length = pFirmware->szFwTmpBufferLen; + + /* Retrieve FW header. */ + pFirmware->pFwHeader = (PRT_8192S_FIRMWARE_HDR) pucMappedFile; + pFwHdr = pFirmware->pFwHeader; + + RT_TRACE(COMP_FIRMWARE, "%s(): signature: %x, version: %x, " + "size: %x, imemsize: %x, sram size: %x", + __func__, pFwHdr->Signature, pFwHdr->Version, + pFwHdr->DMEMSize, pFwHdr->IMG_IMEM_SIZE, + pFwHdr->IMG_SRAM_SIZE); + + pFirmware->FirmwareVersion = byte(pFwHdr->Version , 0); + + if ((pFwHdr->IMG_IMEM_SIZE == 0) || + (pFwHdr->IMG_IMEM_SIZE > sizeof(pFirmware->FwIMEM))) { + RT_TRACE(COMP_ERR, "%s(): memory for data image is less than" + " IMEM requires", __func__); + goto RequestFirmware_Fail; + } else { + pucMappedFile += FwHdrSize; + /* Retrieve IMEM image. */ + memcpy(pFirmware->FwIMEM, pucMappedFile, pFwHdr->IMG_IMEM_SIZE); + pFirmware->FwIMEMLen = pFwHdr->IMG_IMEM_SIZE; + } + + if (pFwHdr->IMG_SRAM_SIZE > sizeof(pFirmware->FwEMEM)) { + RT_TRACE(COMP_ERR, "%s(): memory for data image is less than" + " EMEM requires", __func__); + goto RequestFirmware_Fail; + } else { + pucMappedFile += pFirmware->FwIMEMLen; + /* Retriecve EMEM image */ + memcpy(pFirmware->FwEMEM, pucMappedFile, pFwHdr->IMG_SRAM_SIZE); + pFirmware->FwEMEMLen = pFwHdr->IMG_SRAM_SIZE; + } + return rtStatus; + +RequestFirmware_Fail: + RT_TRACE(COMP_ERR, "%s(): failed with TCR-Status: %x\n", + __func__, read_nic_word(dev, TCR)); + rtStatus = false; + return rtStatus; +} bool FirmwareDownload92S(struct net_device *dev) { - struct r8192_priv *priv = ieee80211_priv(dev); - bool rtStatus = true; - const char *pFwImageFileName[1] = {"RTL8192SU/rtl8192sfw.bin"}; - u8 *pucMappedFile = NULL; - u32 ulFileLength, ulInitStep = 0; - u8 FwHdrSize = RT_8192S_FIRMWARE_HDR_SIZE; - rt_firmware *pFirmware = priv->pFirmware; - u8 FwStatus = FW_STATUS_INIT; - PRT_8192S_FIRMWARE_HDR pFwHdr = NULL; - PRT_8192S_FIRMWARE_PRIV pFwPriv = NULL; - int rc; - const struct firmware *fw_entry; - u32 file_length = 0; + struct r8192_priv *priv = ieee80211_priv(dev); + bool rtStatus = true; + u8 *pucMappedFile = NULL; + u32 ulFileLength; + u8 FwHdrSize = RT_8192S_FIRMWARE_HDR_SIZE; + rt_firmware *pFirmware = priv->pFirmware; + u8 FwStatus = FW_STATUS_INIT; + PRT_8192S_FIRMWARE_HDR pFwHdr = NULL; + PRT_8192S_FIRMWARE_PRIV pFwPriv = NULL; pFirmware->FWStatus = FW_STATUS_INIT; - - RT_TRACE(COMP_FIRMWARE, " --->FirmwareDownload92S()\n"); - -/* -* Load the firmware from RTL8192SU/rtl8192sfw.bin -*/ - if(pFirmware->szFwTmpBufferLen == 0) - { - rc = request_firmware(&fw_entry, pFwImageFileName[ulInitStep],&priv->udev->dev); - if(rc < 0 ) { - RT_TRACE(COMP_ERR, "request firmware fail!\n"); - goto DownloadFirmware_Fail; - } - - if(fw_entry->size > sizeof(pFirmware->szFwTmpBuffer)) { - RT_TRACE(COMP_ERR, "img file size exceed the container buffer fail!\n"); - release_firmware(fw_entry); - goto DownloadFirmware_Fail; - } - - memcpy(pFirmware->szFwTmpBuffer,fw_entry->data,fw_entry->size); - pFirmware->szFwTmpBufferLen = fw_entry->size; - release_firmware(fw_entry); - - pucMappedFile = pFirmware->szFwTmpBuffer; - file_length = pFirmware->szFwTmpBufferLen; - - /* Retrieve FW header. */ - pFirmware->pFwHeader = (PRT_8192S_FIRMWARE_HDR) pucMappedFile; - pFwHdr = pFirmware->pFwHeader; - RT_TRACE(COMP_FIRMWARE,"signature:%x, version:%x, size:%x, imemsize:%x, sram size:%x\n", \ - pFwHdr->Signature, pFwHdr->Version, pFwHdr->DMEMSize, \ - pFwHdr->IMG_IMEM_SIZE, pFwHdr->IMG_SRAM_SIZE); - pFirmware->FirmwareVersion = byte(pFwHdr->Version ,0); - if ((pFwHdr->IMG_IMEM_SIZE==0) || (pFwHdr->IMG_IMEM_SIZE > sizeof(pFirmware->FwIMEM))) { - RT_TRACE(COMP_ERR, "%s: memory for data image is less than IMEM required\n",\ - __FUNCTION__); - goto DownloadFirmware_Fail; - } else { - pucMappedFile+=FwHdrSize; - /* Retrieve IMEM image. */ - memcpy(pFirmware->FwIMEM, pucMappedFile, pFwHdr->IMG_IMEM_SIZE); - pFirmware->FwIMEMLen = pFwHdr->IMG_IMEM_SIZE; - } - - if (pFwHdr->IMG_SRAM_SIZE > sizeof(pFirmware->FwEMEM)) { - RT_TRACE(COMP_ERR, "%s: memory for data image is less than EMEM required\n",\ - __FUNCTION__); - goto DownloadFirmware_Fail; - } else { - pucMappedFile += pFirmware->FwIMEMLen; - /* Retriecve EMEM image */ - memcpy(pFirmware->FwEMEM, pucMappedFile, pFwHdr->IMG_SRAM_SIZE);//===>6 - pFirmware->FwEMEMLen = pFwHdr->IMG_SRAM_SIZE; - } + /* + * Load the firmware from RTL8192SU/rtl8192sfw.bin if necessary + */ + if (pFirmware->szFwTmpBufferLen == 0) { + if (FirmwareRequest92S(dev, pFirmware) != true) + goto DownloadFirmware_Fail; } - FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus); - while(FwStatus!= FW_STATUS_READY) - { - // Image buffer redirection. - switch(FwStatus) - { - case FW_STATUS_LOAD_IMEM: - pucMappedFile = pFirmware->FwIMEM; - ulFileLength = pFirmware->FwIMEMLen; - break; + while (FwStatus != FW_STATUS_READY) { + /* Image buffer redirection. */ + switch (FwStatus) { + case FW_STATUS_LOAD_IMEM: + pucMappedFile = pFirmware->FwIMEM; + ulFileLength = pFirmware->FwIMEMLen; + break; - case FW_STATUS_LOAD_EMEM: - pucMappedFile = pFirmware->FwEMEM; - ulFileLength = pFirmware->FwEMEMLen; - break; + case FW_STATUS_LOAD_EMEM: + pucMappedFile = pFirmware->FwEMEM; + ulFileLength = pFirmware->FwEMEMLen; + break; - case FW_STATUS_LOAD_DMEM: - /* <Roger_Notes> Partial update the content of header private. 2008.12.18 */ - pFwHdr = pFirmware->pFwHeader; - pFwPriv = (PRT_8192S_FIRMWARE_PRIV)&pFwHdr->FWPriv; - FirmwareHeaderPriveUpdate(dev, pFwPriv); - pucMappedFile = (u8*)(pFirmware->pFwHeader)+RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE; - ulFileLength = FwHdrSize-RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE; - break; + case FW_STATUS_LOAD_DMEM: + /* Partial update the content of private header */ + pFwHdr = pFirmware->pFwHeader; + pFwPriv = (PRT_8192S_FIRMWARE_PRIV)&pFwHdr->FWPriv; + FirmwareHeaderPriveUpdate(dev, pFwPriv); + pucMappedFile = (u8 *)(pFirmware->pFwHeader) + + RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE; - default: - RT_TRACE(COMP_ERR, "Unexpected Download step!!\n"); - goto DownloadFirmware_Fail; - break; + ulFileLength = FwHdrSize - + RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE; + break; + + default: + RT_TRACE(COMP_ERR, "Unexpected Download step!!\n"); + goto DownloadFirmware_Fail; + break; } - //3// - //3// <2> Download image file - //3 // - rtStatus = FirmwareDownloadCode(dev, pucMappedFile, ulFileLength); + /* <2> Download image file */ + + rtStatus = FirmwareDownloadCode(dev, + pucMappedFile, + ulFileLength); if(rtStatus != true) - { - RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n" ); goto DownloadFirmware_Fail; - } - //3// - //3// <3> Check whether load FW process is ready - //3 // + /* <3> Check whether load FW process is ready */ + rtStatus = FirmwareCheckReady(dev, FwStatus); if(rtStatus != true) - { - RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n"); goto DownloadFirmware_Fail; - } FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus); } - RT_TRACE(COMP_FIRMWARE, "Firmware Download Success!!\n"); + RT_TRACE(COMP_FIRMWARE, "%s(): Firmware Download Success", __func__); return rtStatus; - DownloadFirmware_Fail: - RT_TRACE(COMP_ERR, "Firmware Download Fail!!%x\n",read_nic_word(dev, TCR)); +DownloadFirmware_Fail: + RT_TRACE(COMP_ERR, "%s(): failed with TCR-Status: %x\n", + __func__, read_nic_word(dev, TCR)); rtStatus = false; return rtStatus; } diff --git a/drivers/staging/rtl8192su/r8192S_phy.c b/drivers/staging/rtl8192su/r8192S_phy.c index 63d4e5fd7b18..b6c0f1990742 100644 --- a/drivers/staging/rtl8192su/r8192S_phy.c +++ b/drivers/staging/rtl8192su/r8192S_phy.c @@ -882,7 +882,7 @@ phy_BB8192S_Config_ParaFile(struct net_device* dev) // // 1. Read PHY_REG.TXT BB INIT!! - // We will seperate as 1T1R/1T2R/1T2R_GREEN/2T2R + // We will separate as 1T1R/1T2R/1T2R_GREEN/2T2R // if (priv->rf_type == RF_1T2R || priv->rf_type == RF_2T2R || priv->rf_type == RF_1T1R ||priv->rf_type == RF_2T2R_GREEN) @@ -1873,10 +1873,9 @@ PHY_GetTxPowerLevel8192S( if(priv->bTXPowerDataReadFromEEPORM == FALSE) return; - // - // Read predefined TX power index in EEPROM - // -// if(priv->epromtype == EPROM_93c46) + /* + * Read predefined TX power index in EEPROM + */ { // // Mainly we use RF-A Tx Power to write the Tx Power registers, but the RF-B Tx @@ -3607,128 +3606,103 @@ void SetBWModeCallback8192SUsb(struct net_device *dev) RT_TRACE(COMP_SCAN, "<==SetBWMode8190Pci()" ); } -// -// Callback routine of the work item for set bandwidth mode. -// -// use in phy only (in win it's work) +/* + * Callback routine of the work item for set bandwidth mode. + * + * use in phy only (in win it's work) + */ void SetBWModeCallback8192SUsbWorkItem(struct net_device *dev) { - struct r8192_priv *priv = ieee80211_priv(dev); - u8 regBwOpMode; - - // Added it for 20/40 mhz switch time evaluation by guangan 070531 - //u32 NowL, NowH; - //u8Byte BeginTime, EndTime; - u8 regRRSR_RSC; + struct r8192_priv *priv = ieee80211_priv(dev); + u8 regBwOpMode; + u8 regRRSR_RSC; - RT_TRACE(COMP_SCAN, "==>SetBWModeCallback8192SUsbWorkItem() Switch to %s bandwidth\n", \ - priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20?"20MHz":"40MHz"); + RT_TRACE(COMP_SCAN, "%s(): Switch to %s bandwidth", __func__, + priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 ? "20MHz" : "40MHz"); - if(priv->rf_chip == RF_PSEUDO_11N) - { + if (priv->rf_chip == RF_PSEUDO_11N) { priv->SetBWModeInProgress= FALSE; return; } - if(!priv->up) return; - - // Added it for 20/40 mhz switch time evaluation by guangan 070531 - //NowL = read_nic_dword(dev, TSFR); - //NowH = read_nic_dword(dev, TSFR+4); - //BeginTime = ((u8Byte)NowH << 32) + NowL; - - //3<1>Set MAC register + /* Set MAC register */ regBwOpMode = read_nic_byte(dev, BW_OPMODE); regRRSR_RSC = read_nic_byte(dev, RRSR+2); - - switch(priv->CurrentChannelBW) - { - case HT_CHANNEL_WIDTH_20: - regBwOpMode |= BW_OPMODE_20MHZ; - // 2007/02/07 Mark by Emily becasue we have not verify whether this register works - write_nic_byte(dev, BW_OPMODE, regBwOpMode); - break; - - case HT_CHANNEL_WIDTH_20_40: - regBwOpMode &= ~BW_OPMODE_20MHZ; - // 2007/02/07 Mark by Emily becasue we have not verify whether this register works - write_nic_byte(dev, BW_OPMODE, regBwOpMode); - regRRSR_RSC = (regRRSR_RSC&0x90) |(priv->nCur40MhzPrimeSC<<5); - write_nic_byte(dev, RRSR+2, regRRSR_RSC); - - break; - - default: - RT_TRACE(COMP_DBG, "SetBWModeCallback8192SUsbWorkItem(): unknown Bandwidth: %#X\n", - priv->CurrentChannelBW); - break; + switch (priv->CurrentChannelBW) { + case HT_CHANNEL_WIDTH_20: + regBwOpMode |= BW_OPMODE_20MHZ; + /* we have not verified whether this register works */ + write_nic_byte(dev, BW_OPMODE, regBwOpMode); + break; + case HT_CHANNEL_WIDTH_20_40: + regBwOpMode &= ~BW_OPMODE_20MHZ; + /* we have not verified whether this register works */ + write_nic_byte(dev, BW_OPMODE, regBwOpMode); + regRRSR_RSC = (regRRSR_RSC&0x90) | (priv->nCur40MhzPrimeSC<<5); + write_nic_byte(dev, RRSR+2, regRRSR_RSC); + break; + default: + RT_TRACE(COMP_DBG, "%s(): unknown Bandwidth: %#X", __func__, + priv->CurrentChannelBW); + break; } - - //3 <2>Set PHY related register - switch(priv->CurrentChannelBW) - { - case HT_CHANNEL_WIDTH_20: - rtl8192_setBBreg(dev, rFPGA0_RFMOD, bRFMOD, 0x0); - rtl8192_setBBreg(dev, rFPGA1_RFMOD, bRFMOD, 0x0); - - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter2, 0xff, 0x58); - - break; - case HT_CHANNEL_WIDTH_20_40: - rtl8192_setBBreg(dev, rFPGA0_RFMOD, bRFMOD, 0x1); - rtl8192_setBBreg(dev, rFPGA1_RFMOD, bRFMOD, 0x1); - - // Set Control channel to upper or lower. These settings are required only for 40MHz - rtl8192_setBBreg(dev, rCCK0_System, bCCKSideBand, (priv->nCur40MhzPrimeSC>>1)); - rtl8192_setBBreg(dev, rOFDM1_LSTF, 0xC00, priv->nCur40MhzPrimeSC); - - rtl8192_setBBreg(dev, rFPGA0_AnalogParameter2, 0xff, 0x18); - - break; - - - default: - RT_TRACE(COMP_DBG, "SetBWModeCallback8192SUsbWorkItem(): unknown Bandwidth: %#X\n"\ - ,priv->CurrentChannelBW); - break; + /* Set PHY related register */ + switch (priv->CurrentChannelBW) { + case HT_CHANNEL_WIDTH_20: + rtl8192_setBBreg(dev, rFPGA0_RFMOD, bRFMOD, 0x0); + rtl8192_setBBreg(dev, rFPGA1_RFMOD, bRFMOD, 0x0); + rtl8192_setBBreg(dev, rFPGA0_AnalogParameter2, 0xff, 0x58); + break; + case HT_CHANNEL_WIDTH_20_40: + rtl8192_setBBreg(dev, rFPGA0_RFMOD, bRFMOD, 0x1); + rtl8192_setBBreg(dev, rFPGA1_RFMOD, bRFMOD, 0x1); + /* + * Set Control channel to upper or lower. + * These settings are required only for 40MHz + */ + rtl8192_setBBreg(dev, rCCK0_System, bCCKSideBand, + (priv->nCur40MhzPrimeSC>>1)); + rtl8192_setBBreg(dev, rOFDM1_LSTF, 0xC00, + priv->nCur40MhzPrimeSC); + rtl8192_setBBreg(dev, rFPGA0_AnalogParameter2, 0xff, 0x18); + break; + default: + RT_TRACE(COMP_DBG, "%s(): unknown Bandwidth: %#X", __func__, + priv->CurrentChannelBW); + break; } - //Skip over setting of J-mode in BB register here. Default value is "None J mode". Emily 20070315 - - //3<3>Set RF related register - switch( priv->rf_chip ) - { - case RF_8225: - PHY_SetRF8225Bandwidth(dev, priv->CurrentChannelBW); - break; - - case RF_8256: - // Please implement this function in Hal8190PciPhy8256.c - //PHY_SetRF8256Bandwidth(dev, priv->CurrentChannelBW); - break; - - case RF_6052: - PHY_RF6052SetBandwidth(dev, priv->CurrentChannelBW); - break; - - case RF_8258: - // Please implement this function in Hal8190PciPhy8258.c - // PHY_SetRF8258Bandwidth(); - break; - - case RF_PSEUDO_11N: - // Do Nothing - break; + /* + * Skip over setting of J-mode in BB register here. + * Default value is "None J mode". + */ - default: - //RT_ASSERT(FALSE, ("Unknown rf_chip: %d\n", priv->rf_chip)); - break; + /* Set RF related register */ + switch (priv->rf_chip) { + case RF_8225: + PHY_SetRF8225Bandwidth(dev, priv->CurrentChannelBW); + break; + case RF_8256: + /* Please implement this function in Hal8190PciPhy8256.c */ + /* PHY_SetRF8256Bandwidth(dev, priv->CurrentChannelBW); */ + break; + case RF_6052: + PHY_RF6052SetBandwidth(dev, priv->CurrentChannelBW); + break; + case RF_8258: + /* Please implement this function in Hal8190PciPhy8258.c */ + /* PHY_SetRF8258Bandwidth(); */ + break; + case RF_PSEUDO_11N: + /* Do Nothing */ + break; + default: + RT_TRACE(COMP_DBG, "%s(): unknown rf_chip: %d", __func__, + priv->rf_chip); + break; } - priv->SetBWModeInProgress= FALSE; - - RT_TRACE(COMP_SCAN, "<==SetBWModeCallback8192SUsbWorkItem()" ); } //--------------------------Move to oter DIR later-------------------------------*/ diff --git a/drivers/staging/rtl8192su/r8192U.h b/drivers/staging/rtl8192su/r8192U.h index ba87623f32ee..eccf4478fba8 100644 --- a/drivers/staging/rtl8192su/r8192U.h +++ b/drivers/staging/rtl8192su/r8192U.h @@ -43,6 +43,13 @@ #include "ieee80211/ieee80211.h" #include "r8192S_firmware.h" +#include "r8192SU_led.h" + +/* EEPROM defs for use with linux/eeprom_93cx6.h */ +#define RTL819X_EEPROM_CMD_READ (1 << 0) +#define RTL819X_EEPROM_CMD_WRITE (1 << 1) +#define RTL819X_EEPROM_CMD_CK (1 << 2) +#define RTL819X_EEPROM_CMD_CS (1 << 3) //#define RTL8192U #define RTL819xU_MODULE_NAME "rtl819xU" @@ -735,11 +742,6 @@ typedef enum _RTL8192SUSB_LOOPBACK{ #define RSVD_FW_QUEUE_PAGE_CMD_SHIFT 0x08 #define RSVD_FW_QUEUE_PAGE_BCN_SHIFT 0x00 #define RSVD_FW_QUEUE_PAGE_PUB_SHIFT 0x08 -//================================================================= -//================================================================= - -#define EPROM_93c46 0 -#define EPROM_93c56 1 #define DEFAULT_FRAG_THRESHOLD 2342U #define MIN_FRAG_THRESHOLD 256U @@ -1066,19 +1068,6 @@ typedef enum _RT_CUSTOMER_ID RT_CID_PRONET = 13, }RT_CUSTOMER_ID, *PRT_CUSTOMER_ID; -//================================================================================ -// LED customization. -//================================================================================ - -typedef enum _LED_STRATEGY_8190{ - SW_LED_MODE0, // SW control 1 LED via GPIO0. It is default option. - SW_LED_MODE1, // SW control for PCI Express - SW_LED_MODE2, // SW control for Cameo. - SW_LED_MODE3, // SW contorl for RunTop. - SW_LED_MODE4, // SW control for Netcore - HW_LED, // HW control 2 LEDs, LED0 and LED1 (there are 4 different control modes) -}LED_STRATEGY_8190, *PLED_STRATEGY_8190; - typedef enum _RESET_TYPE { RESET_TYPE_NORESET = 0x00, RESET_TYPE_NORMAL = 0x01, @@ -1123,15 +1112,14 @@ typedef struct r8192_priv { struct rtl819x_ops* ops; struct usb_device *udev; - //added for maintain info from eeprom - short epromtype; + /* added for maintain info from eeprom */ u16 eeprom_vid; u16 eeprom_pid; u8 eeprom_CustomerID; u8 eeprom_SubCustomerID; u8 eeprom_ChannelPlan; RT_CUSTOMER_ID CustomerID; - LED_STRATEGY_8190 LedStrategy; + LED_STRATEGY_819xUsb LedStrategy; u8 txqueue_to_outpipemap[9]; u8 RtOutPipes[16]; u8 RtInPipes[16]; @@ -1501,8 +1489,17 @@ typedef struct r8192_priv u8 MinSpaceCfg; u16 rf_pathmap; -//#endif + /* added for led control */ + PLED_819xUsb pLed; + LED_819xUsb SwLed0; + LED_819xUsb SwLed1; + u8 bRegUseLed; + struct work_struct BlinkWorkItem; + /* added for led control */ + u16 FwCmdIOMap; + u32 FwCmdIOParam; + u8 DMFlag; diff --git a/drivers/staging/rtl8192su/r8192U_core.c b/drivers/staging/rtl8192su/r8192U_core.c index 04d9b85f3d4c..447d6474a70c 100644 --- a/drivers/staging/rtl8192su/r8192U_core.c +++ b/drivers/staging/rtl8192su/r8192U_core.c @@ -26,6 +26,7 @@ #include <linux/vmalloc.h> #include <linux/slab.h> +#include <linux/eeprom_93cx6.h> #undef LOOP_TEST #undef DUMP_RX @@ -54,7 +55,6 @@ #include <asm/uaccess.h> #include "r8192U.h" -#include "r8180_93cx6.h" /* Card EEPROM */ #include "r8192U_wx.h" #include "r8192S_rtl8225.h" @@ -217,6 +217,36 @@ static CHANNEL_LIST ChannelPlan[] = { {{1,2,3,4,5,6,7,8,9,10,11,12,13,14},14} //For Global Domain. 1-11:active scan, 12-14 passive scan. //+YJ, 080626 }; +static void rtl819x_eeprom_register_read(struct eeprom_93cx6 *eeprom) +{ + struct net_device *dev = eeprom->data; + u8 reg = read_nic_byte(dev, EPROM_CMD); + + eeprom->reg_data_in = reg & RTL819X_EEPROM_CMD_WRITE; + eeprom->reg_data_out = reg & RTL819X_EEPROM_CMD_READ; + eeprom->reg_data_clock = reg & RTL819X_EEPROM_CMD_CK; + eeprom->reg_chip_select = reg & RTL819X_EEPROM_CMD_CS; +} + +static void rtl819x_eeprom_register_write(struct eeprom_93cx6 *eeprom) +{ + struct net_device *dev = eeprom->data; + u8 reg = 2 << 6; + + if (eeprom->reg_data_in) + reg |= RTL819X_EEPROM_CMD_WRITE; + if (eeprom->reg_data_out) + reg |= RTL819X_EEPROM_CMD_READ; + if (eeprom->reg_data_clock) + reg |= RTL819X_EEPROM_CMD_CK; + if (eeprom->reg_chip_select) + reg |= RTL819X_EEPROM_CMD_CS; + + write_nic_byte(dev, EPROM_CMD, reg); + read_nic_byte(dev, EPROM_CMD); + udelay(10); +} + static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv) { int i, max_chan=-1, min_chan=-1; @@ -1155,15 +1185,6 @@ void tx_timeout(struct net_device *dev) //DMESG("TXTIMEOUT"); } - -/* this is only for debug */ -void dump_eprom(struct net_device *dev) -{ - int i; - for(i=0; i<63; i++) - RT_TRACE(COMP_EPROM, "EEPROM addr %x : %x", i, eprom_read(dev,i)); -} - /* this is only for debug */ void rtl8192_dump_reg(struct net_device *dev) { @@ -1201,6 +1222,7 @@ void rtl8192_set_mode(struct net_device *dev,int mode) void rtl8192_update_msr(struct net_device *dev) { struct r8192_priv *priv = ieee80211_priv(dev); + LED_CTL_MODE LedAction = LED_CTL_NO_LINK; u8 msr; msr = read_nic_byte(dev, MSR); @@ -1211,19 +1233,23 @@ void rtl8192_update_msr(struct net_device *dev) * this is intentional and make sense for ad-hoc and * master (see the create BSS/IBSS func) */ - if (priv->ieee80211->state == IEEE80211_LINKED){ + if (priv->ieee80211->state == IEEE80211_LINKED) { - if (priv->ieee80211->iw_mode == IW_MODE_INFRA) + if (priv->ieee80211->iw_mode == IW_MODE_INFRA) { msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT); - else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC) + LedAction = LED_CTL_LINK; + } else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC) msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT); else if (priv->ieee80211->iw_mode == IW_MODE_MASTER) msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT); - }else + } else msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT); write_nic_byte(dev, MSR, msr); + + if(priv->ieee80211->LedControlHandler != NULL) + priv->ieee80211->LedControlHandler(dev, LedAction); } void rtl8192_set_chan(struct net_device *dev,short ch) @@ -1278,7 +1304,6 @@ static int rtl8192_rx_initiate(struct net_device*dev) kfree_skb(skb); break; } -// printk("nomal packet IN request!\n"); usb_fill_bulk_urb(entry, priv->udev, usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb), RX_URB_SIZE, rtl8192_rx_isr, skb); @@ -1292,7 +1317,6 @@ static int rtl8192_rx_initiate(struct net_device*dev) /* command packet rx procedure */ while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) { -// printk("command packet IN request!\n"); skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL); if (!skb) break; @@ -2138,15 +2162,13 @@ short rtl8192SU_tx(struct net_device *dev, struct sk_buff* skb) struct r8192_priv *priv = ieee80211_priv(dev); cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE); tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data; - //tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);//92su del struct usb_device *udev = priv->udev; int pend; int status; struct urb *tx_urb = NULL, *tx_urb_zero = NULL; - //int urb_len; unsigned int idx_pipe; - u16 MPDUOverhead = 0; - //RT_DEBUG_DATA(COMP_SEND, tcb_desc, sizeof(cb_desc)); + u16 MPDUOverhead = 0; + u16 type = 0; pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]); /* we are locked here so the two atomic_read and inc are executed @@ -2343,6 +2365,11 @@ short rtl8192SU_tx(struct net_device *dev, struct sk_buff* skb) skb->data, skb->len, rtl8192_tx_isr, skb); + if (type == IEEE80211_FTYPE_DATA) { + if (priv->ieee80211->LedControlHandler != NULL) + priv->ieee80211->LedControlHandler(dev, LED_CTL_TX); + } + status = usb_submit_urb(tx_urb, GFP_ATOMIC); if (!status) { /* @@ -2577,30 +2604,20 @@ void rtl8192SU_update_ratr_table(struct net_device* dev) void rtl8192SU_link_change(struct net_device *dev) { struct r8192_priv *priv = ieee80211_priv(dev); - struct ieee80211_device* ieee = priv->ieee80211; - //unsigned long flags; + struct ieee80211_device *ieee = priv->ieee80211; u32 reg = 0; - printk("=====>%s 1\n", __func__); reg = read_nic_dword(dev, RCR); - - if (ieee->state == IEEE80211_LINKED) - { - + if (ieee->state == IEEE80211_LINKED) { rtl8192SU_net_update(dev); rtl8192SU_update_ratr_table(dev); ieee->SetFwCmdHandler(dev, FW_CMD_HIGH_PWR_ENABLE); priv->ReceiveConfig = reg |= RCR_CBSSID; - }else{ + } else priv->ReceiveConfig = reg &= ~RCR_CBSSID; - - } - write_nic_dword(dev, RCR, reg); rtl8192_update_msr(dev); - - printk("<=====%s 2\n", __func__); } static struct ieee80211_qos_parameters def_qos_parameters = { @@ -3303,18 +3320,6 @@ static void rtl8192_init_priv_task(struct net_device* dev) (unsigned long)priv); } -static void rtl8192_get_eeprom_size(struct net_device* dev) -{ - u16 curCR = 0; - struct r8192_priv *priv = ieee80211_priv(dev); - RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__); - curCR = read_nic_word_E(dev,EPROM_CMD); - RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR); - //whether need I consider BIT5? - priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46; - RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype); -} - //used to swap endian. as ntohl & htonl are not neccessary to swap endian, so use this instead. static inline u16 endian_swap(u16* data) { @@ -3409,34 +3414,28 @@ void update_hal_variables(struct r8192_priv *priv) } } -// -// Description: -// Config HW adapter information into initial value. -// -// Assumption: -// 1. After Auto load fail(i.e, check CR9346 fail) -// -// Created by Roger, 2008.10.21. -// -void -rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device* dev) +/* + * Description: + * Config HW adapter information into initial value. + * + * Assumption: + * 1. After Auto load fail(i.e, check CR9346 fail) + * + */ +void rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device *dev) { - struct r8192_priv *priv = ieee80211_priv(dev); - //u16 i,usValue; - //u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x92, 0x00}; - u8 rf_path; // For EEPROM/EFUSE After V0.6_1117 - int i; + struct r8192_priv *priv = ieee80211_priv(dev); + u8 rf_path; /* For EEPROM/EFUSE After V0.6_1117 */ + int i; RT_TRACE(COMP_INIT, "====> ConfigAdapterInfo8192SForAutoLoadFail\n"); - write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader - //PlatformStallExecution(10000); + /* Isolation signals from Loader */ + write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); mdelay(10); - write_nic_byte(dev, PMC_FSM, 0x02); // Enable Loader Data Keep - - //RT_ASSERT(priv->AutoloadFailFlag==TRUE, ("ReadAdapterInfo8192SEEPROM(): AutoloadFailFlag !=TRUE\n")); + write_nic_byte(dev, PMC_FSM, 0x02); /* Enable Loader Data Keep */ - // Initialize IC Version && Channel Plan + /* Initialize IC Version && Channel Plan */ priv->eeprom_vid = 0; priv->eeprom_pid = 0; priv->card_8192_version = 0; @@ -3447,12 +3446,14 @@ rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device* dev) RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid); RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid); - RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID); - RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n", priv->eeprom_SubCustomerID); - RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", priv->eeprom_ChannelPlan); - RT_TRACE(COMP_INIT, "IgnoreDiffRateTxPowerOffset = %d\n", priv->bIgnoreDiffRateTxPowerOffset); - - + RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", + priv->eeprom_CustomerID); + RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n", + priv->eeprom_SubCustomerID); + RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", + priv->eeprom_ChannelPlan); + RT_TRACE(COMP_INIT, "IgnoreDiffRateTxPowerOffset = %d\n", + priv->bIgnoreDiffRateTxPowerOffset); priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC; RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption); @@ -3460,19 +3461,15 @@ rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device* dev) for(i=0; i<5; i++) priv->EEPROMUsbPhyParam[i] = EEPROM_USB_Default_PHY_PARAM; - //RT_PRINT_DATA(COMP_INIT|COMP_EFUSE, DBG_LOUD, ("EFUSE USB PHY Param: \n"), priv->EEPROMUsbPhyParam, 5); - { - //<Roger_Notes> In this case, we random assigh MAC address here. 2008.10.15. + /* + * In this case, we randomly assign a MAC address here. + */ static u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x92, 0x00}; - u8 i; - - //sMacAddr[5] = (u8)GetRandomNumber(1, 254); - for(i = 0; i < 6; i++) dev->dev_addr[i] = sMacAddr[i]; } - //NicIFSetMacAddress(Adapter, Adapter->PermanentAddress); + /* NicIFSetMacAddress(Adapter, Adapter->PermanentAddress); */ write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]); write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]); @@ -3481,7 +3478,7 @@ rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device* dev) dev->dev_addr); priv->EEPROMBoardType = EEPROM_Default_BoardType; - priv->rf_type = RF_1T2R; //RF_2T2R + priv->rf_type = RF_1T2R; /* RF_2T2R */ priv->EEPROMTxPowerDiff = EEPROM_Default_PwDiff; priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter; priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap; @@ -3490,13 +3487,11 @@ rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device* dev) priv->EEPROMTSSI_B = EEPROM_Default_TSSI; priv->EEPROMTxPwrTkMode = EEPROM_Default_TxPwrTkMode; - - for (rf_path = 0; rf_path < 2; rf_path++) { for (i = 0; i < 3; i++) { - // Read CCK RF A & B Tx power + /* Read CCK RF A & B Tx power */ priv->RfCckChnlAreaTxPwr[rf_path][i] = priv->RfOfdmChnlAreaTxPwr1T[rf_path][i] = priv->RfOfdmChnlAreaTxPwr2T[rf_path][i] = @@ -3506,175 +3501,133 @@ rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device* dev) update_hal_variables(priv); - // - // Update remained HAL variables. - // + /* + * Update remaining HAL variables. + */ priv->TSSI_13dBm = priv->EEPROMThermalMeter *100; - priv->LegacyHTTxPowerDiff = priv->EEPROMTxPowerDiff;//new + priv->LegacyHTTxPowerDiff = priv->EEPROMTxPowerDiff; /* new */ priv->TxPowerDiff = priv->EEPROMTxPowerDiff; - //priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);// Antenna B gain offset to antenna A, bit0~3 - //priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);// Antenna C gain offset to antenna A, bit4~7 - priv->CrystalCap = priv->EEPROMCrystalCap; // CrystalCap, bit12~15 - priv->ThermalMeter[0] = priv->EEPROMThermalMeter;// ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2 + /* Antenna B gain offset to antenna A, bit0~3 */ + /* priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf); */ + /* Antenna C gain offset to antenna A, bit4~7 */ + /* priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4); */ + /* CrystalCap, bit12~15 */ + priv->CrystalCap = priv->EEPROMCrystalCap; + /* ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2 */ + priv->ThermalMeter[0] = priv->EEPROMThermalMeter; priv->LedStrategy = SW_LED_MODE0; init_rate_adaptive(dev); RT_TRACE(COMP_INIT, "<==== ConfigAdapterInfo8192SForAutoLoadFail\n"); - } -// -// Description: -// Read HW adapter information by E-Fuse or EEPROM according CR9346 reported. -// -// Assumption: -// 1. CR9346 regiser has verified. -// 2. PASSIVE_LEVEL (USB interface) -// -// Created by Roger, 2008.10.21. -// -void -rtl8192SU_ReadAdapterInfo8192SUsb(struct net_device* dev) +/* + * Description: + * Read HW adapter information by E-Fuse + * or EEPROM according CR9346 reported. + * + * Assumption: + * 1. CR9346 regiser has verified. + * 2. PASSIVE_LEVEL (USB interface) + */ +void rtl8192SU_ReadAdapterInfo8192SUsb(struct net_device *dev) { - struct r8192_priv *priv = ieee80211_priv(dev); - u16 i,usValue; - u8 tmpU1b, tempval; - u16 EEPROMId; - u8 hwinfo[HWSET_MAX_SIZE_92S]; - u8 rf_path, index; // For EEPROM/EFUSE After V0.6_1117 - - - RT_TRACE(COMP_INIT, "====> ReadAdapterInfo8192SUsb\n"); + struct r8192_priv *priv = ieee80211_priv(dev); + u16 i; + u8 tmpU1b, tempval; + u16 EEPROMId; + u8 hwinfo[HWSET_MAX_SIZE_92S]; + u8 rf_path, index; /* For EEPROM/EFUSE After V0.6_1117 */ + struct eeprom_93cx6 eeprom; + u16 eeprom_val; + + eeprom.data = dev; + eeprom.register_read = rtl819x_eeprom_register_read; + eeprom.register_write = rtl819x_eeprom_register_write; + eeprom.width = PCI_EEPROM_WIDTH_93C46; - // - // <Roger_Note> The following operation are prevent Efuse leakage by turn on 2.5V. - // 2008.11.25. - // + /* + * The following operation are prevent Efuse leakage by turn on 2.5V. + */ tmpU1b = read_nic_byte(dev, EFUSE_TEST+3); write_nic_byte(dev, EFUSE_TEST+3, tmpU1b|0x80); - //PlatformStallExecution(1000); mdelay(10); write_nic_byte(dev, EFUSE_TEST+3, (tmpU1b&(~BIT7))); - // Retrieve Chip version. + /* Retrieve Chip version. */ priv->card_8192_version = (VERSION_8192S)((read_nic_dword(dev, PMC_FSM)>>16)&0xF); RT_TRACE(COMP_INIT, "Chip Version ID: 0x%2x\n", priv->card_8192_version); - switch(priv->card_8192_version) - { - case 0: - RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_ACUT.\n"); - break; - case 1: - RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_BCUT.\n"); - break; - case 2: - RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_CCUT.\n"); - break; - default: - RT_TRACE(COMP_INIT, "Unknown Chip Version!!\n"); - priv->card_8192_version = VERSION_8192S_BCUT; - break; + switch (priv->card_8192_version) { + case 0: + RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_ACUT.\n"); + break; + case 1: + RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_BCUT.\n"); + break; + case 2: + RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_CCUT.\n"); + break; + default: + RT_TRACE(COMP_INIT, "Unknown Chip Version!!\n"); + priv->card_8192_version = VERSION_8192S_BCUT; + break; } - //if (IS_BOOT_FROM_EEPROM(Adapter)) - if(priv->EepromOrEfuse) - { // Read frin EEPROM - write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader - //PlatformStallExecution(10000); + if (priv->EepromOrEfuse) { /* Read from EEPROM */ + /* Isolation signals from Loader */ + write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); mdelay(10); - write_nic_byte(dev, PMC_FSM, 0x02); // Enable Loader Data Keep - // Read all Content from EEPROM or EFUSE. - for(i = 0; i < HWSET_MAX_SIZE_92S; i += 2) - { - usValue = eprom_read(dev, (u16) (i>>1)); - *((u16*)(&hwinfo[i])) = usValue; + /* Enable Loader Data Keep */ + write_nic_byte(dev, PMC_FSM, 0x02); + /* Read all Content from EEPROM or EFUSE. */ + for (i = 0; i < HWSET_MAX_SIZE_92S; i += 2) { + eeprom_93cx6_read(&eeprom, (u16) (i>>1), &eeprom_val); + *((u16 *)(&hwinfo[i])) = eeprom_val; } - } - else if (!(priv->EepromOrEfuse)) - { // Read from EFUSE - - // - // <Roger_Notes> We set Isolation signals from Loader and reset EEPROM after system resuming - // from suspend mode. - // 2008.10.21. - // - //PlatformEFIOWrite1Byte(Adapter, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader - //PlatformStallExecution(10000); - //PlatformEFIOWrite1Byte(Adapter, SYS_FUNC_EN+1, 0x40); - //PlatformEFIOWrite1Byte(Adapter, SYS_FUNC_EN+1, 0x50); - - //tmpU1b = PlatformEFIORead1Byte(Adapter, EFUSE_TEST+3); - //PlatformEFIOWrite1Byte(Adapter, EFUSE_TEST+3, (tmpU1b | 0x80)); - //PlatformEFIOWrite1Byte(Adapter, EFUSE_TEST+3, 0x72); - //PlatformEFIOWrite1Byte(Adapter, EFUSE_CLK, 0x03); - - // Read EFUSE real map to shadow. + } else if (!(priv->EepromOrEfuse)) { /* Read from EFUSE */ + /* Read EFUSE real map to shadow. */ EFUSE_ShadowMapUpdate(dev); memcpy(hwinfo, &priv->EfuseMap[EFUSE_INIT_MAP][0], HWSET_MAX_SIZE_92S); + } else { + RT_TRACE(COMP_INIT, "%s(): Invalid boot type", __func__); } - else - { - RT_TRACE(COMP_INIT, "ReadAdapterInfo8192SUsb(): Invalid boot type!!\n"); - } - - //YJ,test,090106 - //dump_buf(hwinfo,HWSET_MAX_SIZE_92S); - // - // <Roger_Notes> The following are EFUSE/EEPROM independent operations!! - // - //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("MAP: \n"), hwinfo, HWSET_MAX_SIZE_92S); - // - // <Roger_Notes> Event though CR9346 regiser can verify whether Autoload is success or not, but we still - // double check ID codes for 92S here(e.g., due to HW GPIO polling fail issue). - // 2008.10.21. - // + /* + * Even though CR9346 regiser can verify whether Autoload + * is success or not, but we still double check ID codes for 92S here + * (e.g., due to HW GPIO polling fail issue) + */ EEPROMId = *((u16 *)&hwinfo[0]); - - if( EEPROMId != RTL8190_EEPROM_ID ) - { + if (EEPROMId != RTL8190_EEPROM_ID) { RT_TRACE(COMP_INIT, "ID(%#x) is invalid!!\n", EEPROMId); priv->bTXPowerDataReadFromEEPORM = FALSE; priv->AutoloadFailFlag=TRUE; - } - else - { + } else { priv->AutoloadFailFlag=FALSE; priv->bTXPowerDataReadFromEEPORM = TRUE; } - // Read IC Version && Channel Plan - if(!priv->AutoloadFailFlag) - { - // VID, PID + /* Read IC Version && Channel Plan */ + if (!priv->AutoloadFailFlag) { + /* VID, PID */ priv->eeprom_vid = *(u16 *)&hwinfo[EEPROM_VID]; priv->eeprom_pid = *(u16 *)&hwinfo[EEPROM_PID]; priv->bIgnoreDiffRateTxPowerOffset = false; //cosa for test - // EEPROM Version ID, Channel plan + /* EEPROM Version ID, Channel plan */ priv->EEPROMVersion = *(u8 *)&hwinfo[EEPROM_Version]; priv->eeprom_ChannelPlan = *(u8 *)&hwinfo[EEPROM_ChannelPlan]; - // Customer ID, 0x00 and 0xff are reserved for Realtek. + /* Customer ID, 0x00 and 0xff are reserved for Realtek. */ priv->eeprom_CustomerID = *(u8 *)&hwinfo[EEPROM_CustomID]; priv->eeprom_SubCustomerID = *(u8 *)&hwinfo[EEPROM_SubCustomID]; - } - else - { - //priv->eeprom_vid = 0; - //priv->eeprom_pid = 0; - //priv->EEPROMVersion = 0; - //priv->eeprom_ChannelPlan = 0; - //priv->eeprom_CustomerID = 0; - //priv->eeprom_SubCustomerID = 0; - + } else { rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(dev); return; } - RT_TRACE(COMP_INIT, "EEPROM Id = 0x%4x\n", EEPROMId); RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid); RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid); @@ -3684,18 +3637,13 @@ rtl8192SU_ReadAdapterInfo8192SUsb(struct net_device* dev) RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", priv->eeprom_ChannelPlan); RT_TRACE(COMP_INIT, "bIgnoreDiffRateTxPowerOffset = %d\n", priv->bIgnoreDiffRateTxPowerOffset); - - // Read USB optional function. - if(!priv->AutoloadFailFlag) - { + /* Read USB optional function. */ + if (!priv->AutoloadFailFlag) { priv->EEPROMUsbOption = *(u8 *)&hwinfo[EEPROM_USB_OPTIONAL]; - } - else - { + } else { priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC; } - priv->EEPROMUsbEndPointNumber = rtl8192SU_UsbOptionToEndPointNumber((priv->EEPROMUsbOption&EEPROM_EP_NUMBER)>>3); RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption); @@ -4134,18 +4082,12 @@ short rtl8192_init(struct net_device *dev) rtl8192_init_priv_variable(dev); rtl8192_init_priv_lock(priv); rtl8192_init_priv_task(dev); - rtl8192_get_eeprom_size(dev); priv->ops->rtl819x_read_eeprom_info(dev); rtl8192_get_channel_map(dev); init_hal_dm(dev); init_timer(&priv->watch_dog_timer); priv->watch_dog_timer.data = (unsigned long)dev; priv->watch_dog_timer.function = watch_dog_timer_callback; - - //rtl8192_adapter_start(dev); -#ifdef DEBUG_EPROM - dump_eprom(dev); -#endif return 0; } @@ -5513,85 +5455,88 @@ void rtl819x_update_rxcounts( } } -extern void rtl819x_watchdog_wqcallback(struct work_struct *work) +void rtl819x_watchdog_wqcallback(struct work_struct *work) { - struct delayed_work *dwork = container_of(work,struct delayed_work,work); - struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq); - struct net_device *dev = priv->ieee80211->dev; + struct delayed_work *dwork = container_of(work, + struct delayed_work, + work); + struct r8192_priv *priv = container_of(dwork, + struct r8192_priv, + watch_dog_wq); + struct net_device *dev = priv->ieee80211->dev; struct ieee80211_device* ieee = priv->ieee80211; - RESET_TYPE ResetType = RESET_TYPE_NORESET; - static u8 check_reset_cnt=0; + RESET_TYPE ResetType = RESET_TYPE_NORESET; + static u8 check_reset_cnt; + u32 TotalRxBcnNum = 0; + u32 TotalRxDataNum = 0; bool bBusyTraffic = false; if(!priv->up) return; hal_dm_watchdog(dev); - - {//to get busy traffic condition - if(ieee->state == IEEE80211_LINKED) - { - //windows mod 666 to 100. - //if( ieee->LinkDetectInfo.NumRxOkInPeriod> 666 || - // ieee->LinkDetectInfo.NumTxOkInPeriod> 666 ) { - if( ieee->LinkDetectInfo.NumRxOkInPeriod> 100 || - ieee->LinkDetectInfo.NumTxOkInPeriod> 100 ) { + /* to get busy traffic condition */ + if (ieee->state == IEEE80211_LINKED) { + if (ieee->LinkDetectInfo.NumRxOkInPeriod > 666 || + ieee->LinkDetectInfo.NumTxOkInPeriod > 666) bBusyTraffic = true; - } - ieee->LinkDetectInfo.NumRxOkInPeriod = 0; - ieee->LinkDetectInfo.NumTxOkInPeriod = 0; - ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic; - } - } - //added by amy for AP roaming - { - if(priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA) - { - u32 TotalRxBcnNum = 0; - u32 TotalRxDataNum = 0; - rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum); - if((TotalRxBcnNum+TotalRxDataNum) == 0) - { - #ifdef TODO - if(rfState == eRfOff) - RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__); - #endif - printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__); - // Dot11d_Reset(dev); - priv->ieee80211->state = IEEE80211_ASSOCIATING; - notify_wx_assoc_event(priv->ieee80211); - RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid); - ieee->is_roaming = true; - priv->ieee80211->link_change(dev); - queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq); - } + ieee->LinkDetectInfo.NumRxOkInPeriod = 0; + ieee->LinkDetectInfo.NumTxOkInPeriod = 0; + ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic; + } + + if (priv->ieee80211->state == IEEE80211_LINKED && + priv->ieee80211->iw_mode == IW_MODE_INFRA) { + rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum); + if ((TotalRxBcnNum + TotalRxDataNum) == 0) { + RT_TRACE(COMP_ERR, "%s(): AP is powered off," + "connect another one\n", __func__); + /* Dot11d_Reset(dev); */ + priv->ieee80211->state = IEEE80211_ASSOCIATING; + notify_wx_assoc_event(priv->ieee80211); + RemovePeerTS(priv->ieee80211, + priv->ieee80211->current_network.bssid); + ieee->is_roaming = true; + priv->ieee80211->link_change(dev); + if(ieee->LedControlHandler != NULL) + ieee->LedControlHandler(ieee->dev, + LED_CTL_START_TO_LINK); + queue_work(priv->ieee80211->wq, + &priv->ieee80211->associate_procedure_wq); } - priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod=0; - priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod=0; } -// CAM_read_entry(dev,4); - //check if reset the driver - if(check_reset_cnt++ >= 3 && !ieee->is_roaming) - { - ResetType = rtl819x_ifcheck_resetornot(dev); + priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod = 0; + priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod = 0; + + /* + * CAM_read_entry(dev,4); + * check if reset the driver + */ + if (check_reset_cnt++ >= 3 && !ieee->is_roaming) { + ResetType = rtl819x_ifcheck_resetornot(dev); check_reset_cnt = 3; - //DbgPrint("Start to check silent reset\n"); } - // RT_TRACE(COMP_RESET,"%s():priv->force_reset is %d,priv->ResetProgress is %d, priv->bForcedSilentReset is %d,priv->bDisableNormalResetCheck is %d,ResetType is %d\n",__FUNCTION__,priv->force_reset,priv->ResetProgress,priv->bForcedSilentReset,priv->bDisableNormalResetCheck,ResetType); -#if 1 - if( (priv->force_reset) || (priv->ResetProgress==RESET_TYPE_NORESET && + if ((priv->force_reset) || (priv->ResetProgress == RESET_TYPE_NORESET && (priv->bForcedSilentReset || - (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT)))) // This is control by OID set in Pomelo - { - RT_TRACE(COMP_RESET,"%s():priv->force_reset is %d,priv->ResetProgress is %d, priv->bForcedSilentReset is %d,priv->bDisableNormalResetCheck is %d,ResetType is %d\n",__FUNCTION__,priv->force_reset,priv->ResetProgress,priv->bForcedSilentReset,priv->bDisableNormalResetCheck,ResetType); + (!priv->bDisableNormalResetCheck && + /* This is control by OID set in Pomelo */ + ResetType == RESET_TYPE_SILENT)))) { + RT_TRACE(COMP_RESET, "%s(): priv->force_reset is %d," + "priv->ResetProgress is %d, " + "priv->bForcedSilentReset is %d, " + "priv->bDisableNormalResetCheck is %d, " + "ResetType is %d", + __func__, + priv->force_reset, + priv->ResetProgress, + priv->bForcedSilentReset, + priv->bDisableNormalResetCheck, + ResetType); rtl819x_ifsilentreset(dev); } -#endif priv->force_reset = false; priv->bForcedSilentReset = false; priv->bResetInProgress = false; - RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n"); - } void watch_dog_timer_callback(unsigned long data) @@ -5816,7 +5761,7 @@ int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) goto out; } - ipw = (struct ieee_param *)kmalloc(p->length, GFP_KERNEL); + ipw = kmalloc(p->length, GFP_KERNEL); if (ipw == NULL){ ret = -ENOMEM; goto out; @@ -7593,96 +7538,113 @@ void rtl8192_try_wake_queue(struct net_device *dev, int pri) void EnableHWSecurityConfig8192(struct net_device *dev) { - u8 SECR_value = 0x0; + u8 SECR_value = 0x0; struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev); - struct ieee80211_device* ieee = priv->ieee80211; + struct ieee80211_device *ieee = priv->ieee80211; SECR_value = SCR_TxEncEnable | SCR_RxDecEnable; -#if 1 - if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2)) - { - SECR_value |= SCR_RxUseDK; - SECR_value |= SCR_TxUseDK; - } - else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP))) - { - SECR_value |= SCR_RxUseDK; - SECR_value |= SCR_TxUseDK; + switch (ieee->pairwise_key_type) { + case KEY_TYPE_WEP40: + case KEY_TYPE_WEP104: + if (priv->ieee80211->auth_mode != 2) { + SECR_value |= SCR_RxUseDK; + SECR_value |= SCR_TxUseDK; + } + break; + case KEY_TYPE_TKIP: + case KEY_TYPE_CCMP: + if (ieee->iw_mode == IW_MODE_ADHOC) { + SECR_value |= SCR_RxUseDK; + SECR_value |= SCR_TxUseDK; + } + break; + default: + break; } -#endif - //add HWSec active enable here. -//default using hwsec. when peer AP is in N mode only and pairwise_key_type is none_aes(which HT_IOT_ACT_PURE_N_MODE indicates it), use software security. when peer AP is in b,g,n mode mixed and pairwise_key_type is none_aes, use g mode hw security. WB on 2008.7.4 + /* + * add HWSec active enable here. + * default using hwsec. + * when peer AP is in N mode only and pairwise_key_type is none_aes + * (which HT_IOT_ACT_PURE_N_MODE indicates it), + * use software security. + * when peer AP is in b,g,n mode mixed and pairwise_key_type is none_aes + * use g mode hw security. + */ ieee->hwsec_active = 1; - if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep)//!ieee->hwsec_support) //add hwsec_support flag to totol control hw_sec on/off - { + /* add hwsec_support flag to totol control hw_sec on/off */ + if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep) { ieee->hwsec_active = 0; SECR_value &= ~SCR_RxDecEnable; } - RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__, \ - ieee->hwsec_active, ieee->pairwise_key_type, SECR_value); - { - write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK ); - } + RT_TRACE(COMP_SEC, "%s(): hwsec: %d, pairwise_key: %d, " + "SECR_value: %x", + __func__, ieee->hwsec_active, + ieee->pairwise_key_type, SECR_value); + + write_nic_byte(dev, SECR, SECR_value); /* SECR_value | SCR_UseDK ); */ } -void setKey( struct net_device *dev, +void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType, u8 *MacAddr, u8 DefaultKey, - u32 *KeyContent ) + u32 *KeyContent) { u32 TargetCommand = 0; u32 TargetContent = 0; u16 usConfig = 0; u8 i; + if (EntryNo >= TOTAL_CAM_ENTRY) - RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n"); + RT_TRACE(COMP_ERR, "%s(): cam entry exceeds TOTAL_CAM_ENTRY", + __func__); - RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr); + RT_TRACE(COMP_SEC, "%s(): dev: %p, EntryNo: %d, " + "KeyIndex: %d, KeyType: %d, MacAddr: %pM", + __func__, dev, EntryNo, + KeyIndex, KeyType, MacAddr); if (DefaultKey) - usConfig |= BIT15 | (KeyType<<2); + usConfig |= BIT15 | (KeyType << 2); else - usConfig |= BIT15 | (KeyType<<2) | KeyIndex; -// usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex; + usConfig |= BIT15 | (KeyType << 2) | KeyIndex; - - for(i=0 ; i<CAM_CONTENT_COUNT; i++){ - TargetCommand = i+CAM_CONTENT_COUNT*EntryNo; + for (i = 0 ; i < CAM_CONTENT_COUNT; i++) { + TargetCommand = i + CAM_CONTENT_COUNT * EntryNo; TargetCommand |= BIT31|BIT16; - - if(i==0){//MAC|Config - TargetContent = (u32)(*(MacAddr+0)) << 16| - (u32)(*(MacAddr+1)) << 24| + switch (i) { + case 0: /* MAC|Config */ + TargetContent = (u32)(*(MacAddr + 0)) << 16| + (u32)(*(MacAddr + 1)) << 24| (u32)usConfig; write_nic_dword(dev, WCAMI, TargetContent); write_nic_dword(dev, RWCAM, TargetCommand); - // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo)); - } - else if(i==1){//MAC - TargetContent = (u32)(*(MacAddr+2)) | - (u32)(*(MacAddr+3)) << 8| - (u32)(*(MacAddr+4)) << 16| - (u32)(*(MacAddr+5)) << 24; + continue; + case 1: /* MAC */ + TargetContent = (u32)(*(MacAddr + 2))| + (u32)(*(MacAddr + 3)) << 8| + (u32)(*(MacAddr + 4)) << 16| + (u32)(*(MacAddr + 5)) << 24; write_nic_dword(dev, WCAMI, TargetContent); write_nic_dword(dev, RWCAM, TargetCommand); + continue; + default: /* Key Material */ + if (KeyContent != NULL) { + write_nic_dword(dev, WCAMI, + (u32)(*(KeyContent+i-2))); + write_nic_dword(dev, RWCAM, + TargetCommand); + } + continue; } - else { - //Key Material - if(KeyContent !=NULL){ - write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) ); - write_nic_dword(dev, RWCAM, TargetCommand); - } - } } - } /*************************************************************************** diff --git a/drivers/staging/rtl8192su/r819xU_cmdpkt.c b/drivers/staging/rtl8192su/r819xU_cmdpkt.c index 3ebfe79bb663..a8e9d2d96f5b 100644 --- a/drivers/staging/rtl8192su/r819xU_cmdpkt.c +++ b/drivers/staging/rtl8192su/r819xU_cmdpkt.c @@ -1,384 +1,255 @@ -/****************************************************************************** - - (c) Copyright 2008, RealTEK Technologies Inc. All Rights Reserved. - - Module: r819xusb_cmdpkt.c (RTL8190 TX/RX command packet handler Source C File) - - Note: The module is responsible for handling TX and RX command packet. - 1. TX : Send set and query configuration command packet. - 2. RX : Receive tx feedback, beacon state, query configuration - command packet. - - Function: - - Export: - - Abbrev: - - History: - Data Who Remark - - 05/06/2008 amy Create initial version porting from windows driver. - -******************************************************************************/ +/* + * (c) Copyright 2008, RealTEK Technologies Inc. All Rights Reserved. + * + * Module: r819xusb_cmdpkt.c + * (RTL8190 TX/RX command packet handler Source C File) + * + * Note: The module is responsible for handling TX and RX command packet. + * 1.TX: Send set and query configuration command packet. + * 2.RX: Receive tx feedback, beacon state, query configuration, command packet. + */ #include "r8192U.h" #include "r819xU_cmdpkt.h" -/*---------------------------Define Local Constant---------------------------*/ -/* Debug constant*/ -#define CMPK_DEBOUNCE_CNT 1 -/* 2007/10/24 MH Add for printing a range of data. */ -#define CMPK_PRINT(Address)\ -{\ - unsigned char i;\ - u32 temp[10];\ - \ - memcpy(temp, Address, 40);\ - for (i = 0; i <40; i+=4)\ - printk("\r\n %08x", temp[i]);\ -}\ -/*---------------------------Define functions---------------------------------*/ - -bool -SendTxCommandPacket( - struct net_device *dev, - void* pData, - u32 DataLen - ) + +bool SendTxCommandPacket(struct net_device *dev, void *pData, u32 DataLen) { bool rtStatus = true; struct r8192_priv *priv = ieee80211_priv(dev); struct sk_buff *skb; cb_desc *tcb_desc; unsigned char *ptr_buf; - //bool bLastInitPacket = false; - //PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK); + /* PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK); */ - //Get TCB and local buffer from common pool. (It is shared by CmdQ, MgntQ, and USB coalesce DataQ) + /* + * Get TCB and local buffer from common pool. + * (It is shared by CmdQ, MgntQ, and USB coalesce DataQ) + */ skb = dev_alloc_skb(USB_HWDESC_HEADER_LEN + DataLen + 4); - memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev)); - tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE); + if (skb == NULL) { + RT_TRACE(COMP_ERR, "(%s): unable to alloc skb buffer\n", + __func__); + rtStatus = false; + return rtStatus; + } + memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev)); + tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE); tcb_desc->queue_index = TXCMD_QUEUE; tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_NORMAL; tcb_desc->bLastIniPkt = 0; skb_reserve(skb, USB_HWDESC_HEADER_LEN); ptr_buf = skb_put(skb, DataLen); - memset(ptr_buf,0,DataLen); - memcpy(ptr_buf,pData,DataLen); - tcb_desc->txbuf_size= (u16)DataLen; - - if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)|| - (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\ - (priv->ieee80211->queue_stop) ) { - RT_TRACE(COMP_FIRMWARE,"===================NULL packet==================================> tx full!\n"); + memcpy(ptr_buf, pData, DataLen); + tcb_desc->txbuf_size = (u16)DataLen; + + if (!priv->ieee80211->check_nic_enough_desc(dev, tcb_desc->queue_index) || + (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index])) || + (priv->ieee80211->queue_stop)) { + RT_TRACE(COMP_FIRMWARE, "NULL packet => tx full\n"); skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb); } else { - priv->ieee80211->softmac_hard_start_xmit(skb,dev); + priv->ieee80211->softmac_hard_start_xmit(skb, dev); } //PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK); return rtStatus; } -/*----------------------------------------------------------------------------- +/* * Function: cmpk_message_handle_tx() * * Overview: Driver internal module can call the API to send message to - * firmware side. For example, you can send a debug command packet. - * Or you can send a request for FW to modify RLX4181 LBUS HW bank. - * Otherwise, you can change MAC/PHT/RF register by firmware at - * run time. We do not support message more than one segment now. + * firmware side. For example, you can send a debug command packet. + * Or you can send a request for FW to modify RLX4181 LBUS HW bank. + * Otherwise, you can change MAC/PHT/RF register by firmware at + * run time. We do not support message more than one segment now. * * Input: NONE * * Output: NONE * * Return: NONE - * - * Revised History: - * When Who Remark - * 05/06/2008 amy porting from windows code. - * - *---------------------------------------------------------------------------*/ + */ extern bool cmpk_message_handle_tx( struct net_device *dev, - u8* codevirtualaddress, + u8 *codevirtualaddress, u32 packettype, u32 buffer_len) { - - bool rt_status = true; + bool rt_status = true; return rt_status; -} /* CMPK_Message_Handle_Tx */ +} -/*----------------------------------------------------------------------------- - * Function: cmpk_counttxstatistic() - * - * Overview: - * - * Input: PADAPTER pAdapter - . - * CMPK_TXFB_T *psTx_FB - . - * - * Output: NONE - * - * Return: NONE - * - * Revised History: - * When Who Remark - * 05/12/2008 amy Create Version 0 porting from windows code. - * - *---------------------------------------------------------------------------*/ +/* + * Function: cmpk_counttxstatistic() + */ static void -cmpk_count_txstatistic( - struct net_device *dev, - cmpk_txfb_t *pstx_fb) +cmpk_count_txstatistic(struct net_device *dev, cmpk_txfb_t *pstx_fb) { struct r8192_priv *priv = ieee80211_priv(dev); #ifdef ENABLE_PS - RT_RF_POWER_STATE rtState; + RT_RF_POWER_STATE rtState; - pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_RF_STATE, (pu1Byte)(&rtState)); + pAdapter->HalFunc.GetHwRegHandler(pAdapter, + HW_VAR_RF_STATE, + (pu1Byte)(&rtState)); - // When RF is off, we should not count the packet for hw/sw synchronize - // reason, ie. there may be a duration while sw switch is changed and hw - // switch is being changed. 2006.12.04, by shien chang. + /* + * When RF is off, we should not count the packet for hw/sw synchronize + * reason, ie. there may be a duration while sw switch is changed and hw + * switch is being changed. + */ if (rtState == eRfOff) - { return; - } #endif #ifdef TODO - if(pAdapter->bInHctTest) + if (pAdapter->bInHctTest) return; #endif - /* We can not know the packet length and transmit type: broadcast or uni - or multicast. So the relative statistics must be collected in tx - feedback info. */ - if (pstx_fb->tok) - { + /* + * We can not know the packet length and transmit type: + * broadcast or uni or multicast. + * So the relative statistics must be collected in tx feedback info + */ + if (pstx_fb->tok) { priv->stats.txfeedbackok++; priv->stats.txoktotal++; priv->stats.txokbytestotal += pstx_fb->pkt_length; priv->stats.txokinperiod++; - /* We can not make sure broadcast/multicast or unicast mode. */ - if (pstx_fb->pkt_type == PACKET_MULTICAST) - { + if (pstx_fb->pkt_type == PACKET_MULTICAST) { priv->stats.txmulticast++; priv->stats.txbytesmulticast += pstx_fb->pkt_length; - } - else if (pstx_fb->pkt_type == PACKET_BROADCAST) - { + } else if (pstx_fb->pkt_type == PACKET_BROADCAST) { priv->stats.txbroadcast++; priv->stats.txbytesbroadcast += pstx_fb->pkt_length; - } - else - { + } else { priv->stats.txunicast++; priv->stats.txbytesunicast += pstx_fb->pkt_length; } - } - else - { + } else { priv->stats.txfeedbackfail++; priv->stats.txerrtotal++; priv->stats.txerrbytestotal += pstx_fb->pkt_length; - /* We can not make sure broadcast/multicast or unicast mode. */ if (pstx_fb->pkt_type == PACKET_MULTICAST) - { priv->stats.txerrmulticast++; - } else if (pstx_fb->pkt_type == PACKET_BROADCAST) - { priv->stats.txerrbroadcast++; - } else - { priv->stats.txerrunicast++; - } } - priv->stats.txretrycount += pstx_fb->retry_cnt; priv->stats.txfeedbackretry += pstx_fb->retry_cnt; +} -} /* cmpk_CountTxStatistic */ - - - -/*----------------------------------------------------------------------------- +/* * Function: cmpk_handle_tx_feedback() * * Overview: The function is responsible for extract the message inside TX - * feedbck message from firmware. It will contain dedicated info in - * ws-06-0063-rtl8190-command-packet-specification. Please - * refer to chapter "TX Feedback Element". We have to read 20 bytes - * in the command packet. + * feedbck message from firmware. It will contain dedicated info in + * ws-06-0063-rtl8190-command-packet-specification. Please + * refer to chapter "TX Feedback Element". We have to read 20 bytes + * in the command packet. * * Input: struct net_device * dev - * u8 * pmsg - Msg Ptr of the command packet. + * u8 *pmsg - Msg Ptr of the command packet. * * Output: NONE * * Return: NONE - * - * Revised History: - * When Who Remark - * 05/08/2008 amy Create Version 0 porting from windows code. - * - *---------------------------------------------------------------------------*/ -static void -cmpk_handle_tx_feedback( - struct net_device *dev, - u8 * pmsg) + */ +static void cmpk_handle_tx_feedback(struct net_device *dev, u8 *pmsg) { struct r8192_priv *priv = ieee80211_priv(dev); - cmpk_txfb_t rx_tx_fb; /* */ + cmpk_txfb_t rx_tx_fb; priv->stats.txfeedback++; - /* 0. Display received message. */ - //cmpk_Display_Message(CMPK_RX_TX_FB_SIZE, pMsg); - /* 1. Extract TX feedback info from RFD to temp structure buffer. */ + memcpy((u8 *)&rx_tx_fb, pmsg, sizeof(cmpk_txfb_t)); - /* 2007/07/05 MH Use pointer to transfer structure memory. */ - //memcpy((UINT8 *)&rx_tx_fb, pMsg, sizeof(CMPK_TXFB_T)); - memcpy((u8*)&rx_tx_fb, pmsg, sizeof(cmpk_txfb_t)); /* 2. Use tx feedback info to count TX statistics. */ cmpk_count_txstatistic(dev, &rx_tx_fb); +} - /* 2007/01/17 MH Comment previous method for TX statistic function. */ - /* Collect info TX feedback packet to fill TCB. */ - /* We can not know the packet length and transmit type: broadcast or uni - or multicast. */ - //CountTxStatistics( pAdapter, &tcb ); - -} /* cmpk_Handle_Tx_Feedback */ - -void -cmdpkt_beacontimerinterrupt_819xusb( - struct net_device *dev -) +void cmdpkt_beacontimerinterrupt_819xusb(struct net_device *dev) { struct r8192_priv *priv = ieee80211_priv(dev); u16 tx_rate; - { - // - // 070117, rcnjko: 87B have to S/W beacon for DTM encryption_cmn. - // - if(priv->ieee80211->current_network.mode == IEEE_A || - priv->ieee80211->current_network.mode == IEEE_N_5G || - (priv->ieee80211->current_network.mode == IEEE_N_24G && (!priv->ieee80211->pHTInfo->bCurSuppCCK))) - { - tx_rate = 60; - DMESG("send beacon frame tx rate is 6Mbpm\n"); - } - else - { - tx_rate =10; - DMESG("send beacon frame tx rate is 1Mbpm\n"); - } - - rtl819xusb_beacon_tx(dev,tx_rate); // HW Beacon + if (priv->ieee80211->current_network.mode == IEEE_A || + priv->ieee80211->current_network.mode == IEEE_N_5G || + (priv->ieee80211->current_network.mode == IEEE_N_24G && + (!priv->ieee80211->pHTInfo->bCurSuppCCK))) { + tx_rate = 60; + DMESG("send beacon frame tx rate is 6Mbpm\n"); + } else { + tx_rate = 10; + DMESG("send beacon frame tx rate is 1Mbpm\n"); } - + rtl819xusb_beacon_tx(dev, tx_rate); /* HW Beacon */ } - - - -/*----------------------------------------------------------------------------- +/* * Function: cmpk_handle_interrupt_status() * * Overview: The function is responsible for extract the message from - * firmware. It will contain dedicated info in - * ws-07-0063-v06-rtl819x-command-packet-specification-070315.doc. - * Please refer to chapter "Interrupt Status Element". + * firmware. It will contain dedicated info in + * ws-07-0063-v06-rtl819x-command-packet-specification-070315.doc. + * Please refer to chapter "Interrupt Status Element". * * Input: struct net_device *dev, - * u8* pmsg - Message Pointer of the command packet. + * u8* pmsg - Message Pointer of the command packet. * * Output: NONE * * Return: NONE - * - * Revised History: - * When Who Remark - * 05/12/2008 amy Add this for rtl8192 porting from windows code. - * - *---------------------------------------------------------------------------*/ -static void -cmpk_handle_interrupt_status( - struct net_device *dev, - u8* pmsg) + */ +static void cmpk_handle_interrupt_status(struct net_device *dev, u8 *pmsg) { cmpk_intr_sta_t rx_intr_status; /* */ struct r8192_priv *priv = ieee80211_priv(dev); DMESG("---> cmpk_Handle_Interrupt_Status()\n"); - /* 0. Display received message. */ - //cmpk_Display_Message(CMPK_RX_BEACON_STATE_SIZE, pMsg); - /* 1. Extract TX feedback info from RFD to temp structure buffer. */ - /* It seems that FW use big endian(MIPS) and DRV use little endian in - windows OS. So we have to read the content byte by byte or transfer - endian type before copy the message copy. */ - //rx_bcn_state.Element_ID = pMsg[0]; - //rx_bcn_state.Length = pMsg[1]; rx_intr_status.length = pmsg[1]; - if (rx_intr_status.length != (sizeof(cmpk_intr_sta_t) - 2)) - { + if (rx_intr_status.length != (sizeof(cmpk_intr_sta_t) - 2)) { DMESG("cmpk_Handle_Interrupt_Status: wrong length!\n"); return; } - - - // Statistics of beacon for ad-hoc mode. - if( priv->ieee80211->iw_mode == IW_MODE_ADHOC) - { + /* Statistics of beacon for ad-hoc mode. */ + if (priv->ieee80211->iw_mode == IW_MODE_ADHOC) { //2 maybe need endian transform? rx_intr_status.interrupt_status = *((u32 *)(pmsg + 4)); //rx_intr_status.InterruptStatus = N2H4BYTE(*((UINT32 *)(pMsg + 4))); DMESG("interrupt status = 0x%x\n", rx_intr_status.interrupt_status); - if (rx_intr_status.interrupt_status & ISR_TxBcnOk) - { + if (rx_intr_status.interrupt_status & ISR_TxBcnOk) { priv->ieee80211->bibsscoordinator = true; priv->stats.txbeaconokint++; - } - else if (rx_intr_status.interrupt_status & ISR_TxBcnErr) - { + } else if (rx_intr_status.interrupt_status & ISR_TxBcnErr) { priv->ieee80211->bibsscoordinator = false; priv->stats.txbeaconerr++; } if (rx_intr_status.interrupt_status & ISR_BcnTimerIntr) - { cmdpkt_beacontimerinterrupt_819xusb(dev); - } - } - - // Other informations in interrupt status we need? - - + /* Other informations in interrupt status we need? */ DMESG("<---- cmpk_handle_interrupt_status()\n"); +} -} /* cmpk_handle_interrupt_status */ - - -/*----------------------------------------------------------------------------- +/* * Function: cmpk_handle_query_config_rx() * * Overview: The function is responsible for extract the message from * firmware. It will contain dedicated info in - * ws-06-0063-rtl8190-command-packet-specification. Please - * refer to chapter "Beacon State Element". + * ws-06-0063-rtl8190-command-packet-specification + * Please refer to chapter "Beacon State Element". * * Input: u8 * pmsg - Message Pointer of the command packet. * @@ -386,44 +257,28 @@ cmpk_handle_interrupt_status( * * Return: NONE * - * Revised History: - * When Who Remark - * 05/12/2008 amy Create Version 0 porting from windows code. - * - *---------------------------------------------------------------------------*/ -static void -cmpk_handle_query_config_rx( - struct net_device *dev, - u8* pmsg) + */ +static void cmpk_handle_query_config_rx(struct net_device *dev, u8 *pmsg) { - cmpk_query_cfg_t rx_query_cfg; /* */ - - /* 0. Display received message. */ - //cmpk_Display_Message(CMPK_RX_BEACON_STATE_SIZE, pMsg); + cmpk_query_cfg_t rx_query_cfg; + /* + * Extract TX feedback info from RFD to temp structure buffer. + */ + rx_query_cfg.cfg_action = (pmsg[4] & 0x80000000) >> 31; + rx_query_cfg.cfg_type = (pmsg[4] & 0x60) >> 5; + rx_query_cfg.cfg_size = (pmsg[4] & 0x18) >> 3; + rx_query_cfg.cfg_page = (pmsg[6] & 0x0F) >> 0; + rx_query_cfg.cfg_offset = pmsg[7]; + rx_query_cfg.value = (pmsg[8] << 24) | (pmsg[9] << 16) | + (pmsg[10] << 8) | (pmsg[11] << 0); + rx_query_cfg.mask = (pmsg[12] << 24) | (pmsg[13] << 16) | + (pmsg[14] << 8) | (pmsg[15] << 0); +} - /* 1. Extract TX feedback info from RFD to temp structure buffer. */ - /* It seems that FW use big endian(MIPS) and DRV use little endian in - windows OS. So we have to read the content byte by byte or transfer - endian type before copy the message copy. */ - //rx_query_cfg.Element_ID = pMsg[0]; - //rx_query_cfg.Length = pMsg[1]; - rx_query_cfg.cfg_action = (pmsg[4] & 0x80000000)>>31; - rx_query_cfg.cfg_type = (pmsg[4] & 0x60) >> 5; - rx_query_cfg.cfg_size = (pmsg[4] & 0x18) >> 3; - rx_query_cfg.cfg_page = (pmsg[6] & 0x0F) >> 0; - rx_query_cfg.cfg_offset = pmsg[7]; - rx_query_cfg.value = (pmsg[8] << 24) | (pmsg[9] << 16) | - (pmsg[10] << 8) | (pmsg[11] << 0); - rx_query_cfg.mask = (pmsg[12] << 24) | (pmsg[13] << 16) | - (pmsg[14] << 8) | (pmsg[15] << 0); - -} /* cmpk_Handle_Query_Config_Rx */ - - -/*----------------------------------------------------------------------------- +/* * Function: cmpk_count_tx_status() * - * Overview: Count aggregated tx status from firmwar of one type rx command + * Overview: Count aggregated tx status from firmware of one type rx command * packet element id = RX_TX_STATUS. * * Input: NONE @@ -431,14 +286,9 @@ cmpk_handle_query_config_rx( * Output: NONE * * Return: NONE - * - * Revised History: - * When Who Remark - * 05/12/2008 amy Create Version 0 porting from windows code. - * - *---------------------------------------------------------------------------*/ -static void cmpk_count_tx_status( struct net_device *dev, - cmpk_tx_status_t *pstx_status) + */ +static void cmpk_count_tx_status(struct net_device *dev, + cmpk_tx_status_t *pstx_status) { struct r8192_priv *priv = ieee80211_priv(dev); @@ -448,13 +298,13 @@ static void cmpk_count_tx_status( struct net_device *dev, pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_RF_STATE, (pu1Byte)(&rtState)); - // When RF is off, we should not count the packet for hw/sw synchronize - // reason, ie. there may be a duration while sw switch is changed and hw - // switch is being changed. 2006.12.04, by shien chang. + /* + * When RF is off, we should not count the packet for hw/sw synchronize + * reason, ie. there may be a duration while sw switch is changed and hw + * switch is being changed. + */ if (rtState == eRfOff) - { return; - } #endif priv->stats.txfeedbackok += pstx_status->txok; @@ -463,15 +313,11 @@ static void cmpk_count_tx_status( struct net_device *dev, priv->stats.txfeedbackfail += pstx_status->txfail; priv->stats.txerrtotal += pstx_status->txfail; - priv->stats.txretrycount += pstx_status->txretry; + priv->stats.txretrycount += pstx_status->txretry; priv->stats.txfeedbackretry += pstx_status->txretry; - //pAdapter->TxStats.NumTxOkBytesTotal += psTx_FB->pkt_length; - //pAdapter->TxStats.NumTxErrBytesTotal += psTx_FB->pkt_length; - //pAdapter->MgntInfo.LinkDetectInfo.NumTxOkInPeriod++; - - priv->stats.txmulticast += pstx_status->txmcok; - priv->stats.txbroadcast += pstx_status->txbcok; + priv->stats.txmulticast += pstx_status->txmcok; + priv->stats.txbroadcast += pstx_status->txbcok; priv->stats.txunicast += pstx_status->txucok; priv->stats.txerrmulticast += pstx_status->txmcfail; @@ -480,14 +326,12 @@ static void cmpk_count_tx_status( struct net_device *dev, priv->stats.txbytesmulticast += pstx_status->txmclength; priv->stats.txbytesbroadcast += pstx_status->txbclength; - priv->stats.txbytesunicast += pstx_status->txuclength; - - priv->stats.last_packet_rate = pstx_status->rate; -} /* cmpk_CountTxStatus */ - + priv->stats.txbytesunicast += pstx_status->txuclength; + priv->stats.last_packet_rate = pstx_status->rate; +} -/*----------------------------------------------------------------------------- +/* * Function: cmpk_handle_tx_status() * * Overview: Firmware add a new tx feedback status to reduce rx command @@ -498,27 +342,18 @@ static void cmpk_count_tx_status( struct net_device *dev, * Output: NONE * * Return: NONE - * - * Revised History: - * When Who Remark - * 05/12/2008 amy Create Version 0 porting from windows code. - * - *---------------------------------------------------------------------------*/ + */ static void -cmpk_handle_tx_status( - struct net_device *dev, - u8* pmsg) +cmpk_handle_tx_status(struct net_device *dev, u8 *pmsg) { - cmpk_tx_status_t rx_tx_sts; /* */ + cmpk_tx_status_t rx_tx_sts; - memcpy((void*)&rx_tx_sts, (void*)pmsg, sizeof(cmpk_tx_status_t)); + memcpy((void *)&rx_tx_sts, (void *)pmsg, sizeof(cmpk_tx_status_t)); /* 2. Use tx feedback info to count TX statistics. */ cmpk_count_tx_status(dev, &rx_tx_sts); +} -} /* cmpk_Handle_Tx_Status */ - - -/*----------------------------------------------------------------------------- +/* * Function: cmpk_handle_tx_rate_history() * * Overview: Firmware add a new tx rate history @@ -528,117 +363,90 @@ cmpk_handle_tx_status( * Output: NONE * * Return: NONE - * - * Revised History: - * When Who Remark - * 05/12/2008 amy Create Version 0 porting from windows code. - * - *---------------------------------------------------------------------------*/ -static void -cmpk_handle_tx_rate_history( - struct net_device *dev, - u8* pmsg) + */ +static void cmpk_handle_tx_rate_history(struct net_device *dev, u8 *pmsg) { cmpk_tx_rahis_t *ptxrate; -// RT_RF_POWER_STATE rtState; - u8 i, j; - u16 length = sizeof(cmpk_tx_rahis_t); - u32 *ptemp; + u8 i, j; + u16 length = sizeof(cmpk_tx_rahis_t); + u32 *ptemp; struct r8192_priv *priv = ieee80211_priv(dev); - #ifdef ENABLE_PS - pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_RF_STATE, (pu1Byte)(&rtState)); - - // When RF is off, we should not count the packet for hw/sw synchronize - // reason, ie. there may be a duration while sw switch is changed and hw - // switch is being changed. 2006.12.04, by shien chang. + pAdapter->HalFunc.GetHwRegHandler(pAdapter, + HW_VAR_RF_STATE, + (pu1Byte)(&rtState)); + /* + * When RF is off, we should not count the packet for hw/sw synchronize + * reason, ie. there may be a duration while sw switch is changed and hw + * switch is being changed. + */ if (rtState == eRfOff) - { return; - } #endif - ptemp = (u32 *)pmsg; - // - // Do endian transfer to word alignment(16 bits) for windows system. - // You must do different endian transfer for linux and MAC OS - // - for (i = 0; i < (length/4); i++) - { - u16 temp1, temp2; - - temp1 = ptemp[i]&0x0000FFFF; - temp2 = ptemp[i]>>16; - ptemp[i] = (temp1<<16)|temp2; + /* + * Do endian transfer to word alignment(16 bits) for windows system. + * You must do different endian transfer for linux and MAC OS + */ + for (i = 0; i < (length/4); i++) { + u16 temp1, temp2; + temp1 = ptemp[i] & 0x0000FFFF; + temp2 = ptemp[i] >> 16; + ptemp[i] = (temp1 << 16) | temp2; } ptxrate = (cmpk_tx_rahis_t *)pmsg; - if (ptxrate == NULL ) - { + if (ptxrate == NULL) return; - } - for (i = 0; i < 16; i++) - { - // Collect CCK rate packet num + for (i = 0; i < 16; i++) { + /* Collect CCK rate packet num */ if (i < 4) priv->stats.txrate.cck[i] += ptxrate->cck[i]; - - // Collect OFDM rate packet num - if (i< 8) + /* Collect OFDM rate packet num */ + if (i < 8) priv->stats.txrate.ofdm[i] += ptxrate->ofdm[i]; - for (j = 0; j < 4; j++) priv->stats.txrate.ht_mcs[j][i] += ptxrate->ht_mcs[j][i]; } -} /* cmpk_Handle_Tx_Rate_History */ - +} -/*----------------------------------------------------------------------------- +/* * Function: cmpk_message_handle_rx() * * Overview: In the function, we will capture different RX command packet - * info. Every RX command packet element has different message - * length and meaning in content. We only support three type of RX - * command packet now. Please refer to document - * ws-06-0063-rtl8190-command-packet-specification. + * info. Every RX command packet element has different message + * length and meaning in content. We only support three type of RX + * command packet now. Please refer to document + * ws-06-0063-rtl8190-command-packet-specification. * * Input: NONE * * Output: NONE * * Return: NONE - * - * Revised History: - * When Who Remark - * 05/06/2008 amy Create Version 0 porting from windows code. - * - *---------------------------------------------------------------------------*/ + */ extern u32 cmpk_message_handle_rx( struct net_device *dev, struct ieee80211_rx_stats *pstats) { -// u32 debug_level = DBG_LOUD; struct r8192_priv *priv = ieee80211_priv(dev); int total_length; u8 cmd_length, exe_cnt = 0; u8 element_id; u8 *pcmd_buff; - /* 0. Check inpt arguments. If is is a command queue message or pointer is - null. */ - if (/*(prfd->queue_id != CMPK_RX_QUEUE_ID) || */(pstats== NULL)) - { - /* Print error message. */ - /*RT_TRACE(COMP_SEND, DebugLevel, - ("\n\r[CMPK]-->Err queue id or pointer"));*/ + /* + * 0. Check input arguments. + * If is is a command queue message or pointer is null + */ + if ((pstats == NULL)) return 0; /* This is not a command packet. */ - } /* 1. Read received command packet message length from RFD. */ total_length = pstats->Length; @@ -648,70 +456,49 @@ cmpk_message_handle_rx( /* 3. Read command pakcet element id and length. */ element_id = pcmd_buff[0]; - /*RT_TRACE(COMP_SEND, DebugLevel, - ("\n\r[CMPK]-->element ID=%d Len=%d", element_id, total_length));*/ - - /* 4. Check every received command packet conent according to different - element type. Because FW may aggregate RX command packet to minimize - transmit time between DRV and FW.*/ - // Add a counter to prevent to locked in the loop too long - while (total_length > 0 || exe_cnt++ >100) - { - /* 2007/01/17 MH We support aggregation of different cmd in the same packet. */ - element_id = pcmd_buff[0]; - switch(element_id) - { - case RX_TX_FEEDBACK: - cmpk_handle_tx_feedback (dev, pcmd_buff); - cmd_length = CMPK_RX_TX_FB_SIZE; - break; - - case RX_INTERRUPT_STATUS: - cmpk_handle_interrupt_status(dev, pcmd_buff); - cmd_length = sizeof(cmpk_intr_sta_t); - break; - - case BOTH_QUERY_CONFIG: - cmpk_handle_query_config_rx(dev, pcmd_buff); - cmd_length = CMPK_BOTH_QUERY_CONFIG_SIZE; - break; - - case RX_TX_STATUS: - cmpk_handle_tx_status(dev, pcmd_buff); - cmd_length = CMPK_RX_TX_STS_SIZE; - break; - - case RX_TX_PER_PKT_FEEDBACK: - // You must at lease add a switch case element here, - // Otherwise, we will jump to default case. - //DbgPrint("CCX Test\r\n"); - cmd_length = CMPK_RX_TX_FB_SIZE; - break; - - case RX_TX_RATE_HISTORY: - //DbgPrint(" rx tx rate history\r\n"); - cmpk_handle_tx_rate_history(dev, pcmd_buff); - cmd_length = CMPK_TX_RAHIS_SIZE; - break; - - default: - - RT_TRACE(COMP_ERR, "---->cmpk_message_handle_rx():unknown CMD Element\n"); - return 1; /* This is a command packet. */ - } - // 2007/01/22 MH Display received rx command packet info. - //cmpk_Display_Message(cmd_length, pcmd_buff); + /* + * 4. Check every received command packet conent according to different + * element type. Because FW may aggregate RX command packet to minimize + * transmit time between DRV and FW. + */ - // 2007/01/22 MH Add to display tx statistic. - //cmpk_DisplayTxStatistic(pAdapter); - - /* 2007/03/09 MH Collect sidderent cmd element pkt num. */ + /* Add a counter to prevent to locked in the loop too long */ + while (total_length > 0 || exe_cnt++ > 100) { + /* We support aggregation of different cmd in the same packet */ + element_id = pcmd_buff[0]; + switch (element_id) { + case RX_TX_FEEDBACK: + cmpk_handle_tx_feedback(dev, pcmd_buff); + cmd_length = CMPK_RX_TX_FB_SIZE; + break; + case RX_INTERRUPT_STATUS: + cmpk_handle_interrupt_status(dev, pcmd_buff); + cmd_length = sizeof(cmpk_intr_sta_t); + break; + case BOTH_QUERY_CONFIG: + cmpk_handle_query_config_rx(dev, pcmd_buff); + cmd_length = CMPK_BOTH_QUERY_CONFIG_SIZE; + break; + case RX_TX_STATUS: + cmpk_handle_tx_status(dev, pcmd_buff); + cmd_length = CMPK_RX_TX_STS_SIZE; + break; + case RX_TX_PER_PKT_FEEDBACK: + cmd_length = CMPK_RX_TX_FB_SIZE; + break; + case RX_TX_RATE_HISTORY: + cmpk_handle_tx_rate_history(dev, pcmd_buff); + cmd_length = CMPK_TX_RAHIS_SIZE; + break; + default: + RT_TRACE(COMP_ERR, "(%s): unknown CMD Element\n", + __func__); + return 1; /* This is a command packet. */ + } priv->stats.rxcmdpkt[element_id]++; - total_length -= cmd_length; pcmd_buff += cmd_length; - } /* while (total_length > 0) */ - return 1; /* This is a command packet. */ - -} /* CMPK_Message_Handle_Rx */ + } + return 1; /* This is a command packet. */ +} diff --git a/drivers/staging/rtl8192su/r819xU_cmdpkt.h b/drivers/staging/rtl8192su/r819xU_cmdpkt.h index cced8e0d2788..d3c561551880 100644 --- a/drivers/staging/rtl8192su/r819xU_cmdpkt.h +++ b/drivers/staging/rtl8192su/r819xU_cmdpkt.h @@ -1,199 +1,191 @@ #ifndef R819XUSB_CMDPKT_H #define R819XUSB_CMDPKT_H -/* Different command packet have dedicated message length and definition. */ -#define CMPK_RX_TX_FB_SIZE sizeof(cmpk_txfb_t) //20 -#define CMPK_TX_SET_CONFIG_SIZE sizeof(cmpk_set_cfg_t) //16 -#define CMPK_BOTH_QUERY_CONFIG_SIZE sizeof(cmpk_set_cfg_t) //16 -#define CMPK_RX_TX_STS_SIZE sizeof(cmpk_tx_status_t)// -#define CMPK_RX_DBG_MSG_SIZE sizeof(cmpk_rx_dbginfo_t)// -#define CMPK_TX_RAHIS_SIZE sizeof(cmpk_tx_rahis_t) - -/* 2008/05/08 amy For USB constant. */ -#define ISR_TxBcnOk BIT27 // Transmit Beacon OK -#define ISR_TxBcnErr BIT26 // Transmit Beacon Error -#define ISR_BcnTimerIntr BIT13 // Beacon Timer Interrupt - -/* Define element ID of command packet. */ - -/*------------------------------Define structure----------------------------*/ -/* Define different command packet structure. */ -/* 1. RX side: TX feedback packet. */ -typedef struct tag_cmd_pkt_tx_feedback -{ - // DWORD 0 - u8 element_id; /* Command packet type. */ - u8 length; /* Command packet length. */ - /* 2007/07/05 MH Change tx feedback info field. */ - /*------TX Feedback Info Field */ - u8 TID:4; /* */ - u8 fail_reason:3; /* */ - u8 tok:1; /* Transmit ok. */ - u8 reserve1:4; /* */ - u8 pkt_type:2; /* */ - u8 bandwidth:1; /* */ - u8 qos_pkt:1; /* */ - - // DWORD 1 - u8 reserve2; /* */ - /*------TX Feedback Info Field */ - u8 retry_cnt; /* */ - u16 pkt_id; /* */ - - // DWORD 3 - u16 seq_num; /* */ - u8 s_rate; /* Start rate. */ - u8 f_rate; /* Final rate. */ - - // DWORD 4 - u8 s_rts_rate; /* */ - u8 f_rts_rate; /* */ - u16 pkt_length; /* */ - - // DWORD 5 - u16 reserve3; /* */ - u16 duration; /* */ -}cmpk_txfb_t; - -/* 2. RX side: Interrupt status packet. It includes Beacon State, - Beacon Timer Interrupt and other useful informations in MAC ISR Reg. */ -typedef struct tag_cmd_pkt_interrupt_status -{ - u8 element_id; /* Command packet type. */ - u8 length; /* Command packet length. */ - u16 reserve; - u32 interrupt_status; /* Interrupt Status. */ -}cmpk_intr_sta_t; - - -/* 3. TX side: Set configuration packet. */ -typedef struct tag_cmd_pkt_set_configuration -{ - u8 element_id; /* Command packet type. */ - u8 length; /* Command packet length. */ - u16 reserve1; /* */ - u8 cfg_reserve1:3; - u8 cfg_size:2; /* Configuration info. */ - u8 cfg_type:2; /* Configuration info. */ - u8 cfg_action:1; /* Configuration info. */ - u8 cfg_reserve2; /* Configuration info. */ - u8 cfg_page:4; /* Configuration info. */ - u8 cfg_reserve3:4; /* Configuration info. */ - u8 cfg_offset; /* Configuration info. */ - u32 value; /* */ - u32 mask; /* */ -}cmpk_set_cfg_t; - -/* 4. Both side : TX/RX query configuraton packet. The query structure is the - same as set configuration. */ -#define cmpk_query_cfg_t cmpk_set_cfg_t -/* 5. Multi packet feedback status. */ -typedef struct tag_tx_stats_feedback // PJ quick rxcmd 09042007 -{ - // For endian transfer --> Driver will not the same as firmware structure. - // DW 0 +/* + * Different command packets have dedicated message length and definition. + */ +#define CMPK_RX_TX_FB_SIZE sizeof(cmpk_txfb_t) /* 20 */ +#define CMPK_TX_SET_CONFIG_SIZE sizeof(cmpk_set_cfg_t) /* 16 */ +#define CMPK_BOTH_QUERY_CONFIG_SIZE sizeof(cmpk_set_cfg_t) /* 16 */ +#define CMPK_RX_TX_STS_SIZE sizeof(cmpk_tx_status_t) +#define CMPK_RX_DBG_MSG_SIZE sizeof(cmpk_rx_dbginfo_t) +#define CMPK_TX_RAHIS_SIZE sizeof(cmpk_tx_rahis_t) + +/* For USB constant. */ +#define ISR_TxBcnOk BIT27 /* Transmit Beacon OK */ +#define ISR_TxBcnErr BIT26 /* Transmit Beacon Error */ +#define ISR_BcnTimerIntr BIT13 /* Beacon Timer Interrupt */ + +/* + * Define different command packet structures + * + * 1. RX side: TX feedback packet. + */ +typedef struct tag_cmd_pkt_tx_feedback { + /* DWORD 0 */ + u8 element_id; /* Command packet type. */ + u8 length; /* Command packet length. */ + /* TX Feedback Info Field */ + u8 TID:4; + u8 fail_reason:3; + u8 tok:1; /* Transmit ok. */ + u8 reserve1:4; + u8 pkt_type:2; + u8 bandwidth:1; + u8 qos_pkt:1; + + /* DWORD 1 */ + u8 reserve2; + /* TX Feedback Info Field */ + u8 retry_cnt; + u16 pkt_id; + + /* DWORD 3 */ + u16 seq_num; + u8 s_rate; /* Start rate. */ + u8 f_rate; /* Final rate. */ + + /* DWORD 4 */ + u8 s_rts_rate; + u8 f_rts_rate; + u16 pkt_length; + + /* DWORD 5 */ + u16 reserve3; + u16 duration; +} cmpk_txfb_t; + +/* + * 2. RX side: Interrupt status packet. + * It includes Beacon State, Beacon Timer Interrupt + * and other useful informations in MAC ISR Reg. + */ +typedef struct tag_cmd_pkt_interrupt_status { + u8 element_id; /* Command packet type. */ + u8 length; /* Command packet length. */ + u16 reserve; + u32 interrupt_status; /* Interrupt Status. */ +} cmpk_intr_sta_t; + + +/* + * 3. TX side: Set configuration packet. + */ +typedef struct tag_cmd_pkt_set_configuration { + u8 element_id; /* Command packet type. */ + u8 length; /* Command packet length. */ u16 reserve1; - u8 length; // Command packet length - u8 element_id; // Command packet type - - // DW 1 - u16 txfail; // Tx Fail count - u16 txok; // Tx ok count - - // DW 2 - u16 txmcok; // tx multicast - u16 txretry; // Tx Retry count - - // DW 3 - u16 txucok; // tx unicast - u16 txbcok; // tx broadcast - - // DW 4 - u16 txbcfail; // - u16 txmcfail; // - - // DW 5 - u16 reserve2; // - u16 txucfail; // - - // DW 6-8 - u32 txmclength; - u32 txbclength; - u32 txuclength; - - // DW 9 - u16 reserve3_23; - u8 reserve3_1; - u8 rate; -}__attribute__((packed)) cmpk_tx_status_t; - -/* 6. Debug feedback message. */ -/* 2007/10/23 MH Define RX debug message */ -typedef struct tag_rx_debug_message_feedback -{ - // For endian transfer --> for driver - // DW 0 - u16 reserve1; - u8 length; // Command packet length - u8 element_id; // Command packet type - - // DW 1-?? - // Variable debug message. - -}cmpk_rx_dbginfo_t; - -/* 2008/03/20 MH Define transmit rate history. For big endian format. */ -typedef struct tag_tx_rate_history -{ - // For endian transfer --> for driver - // DW 0 - u8 element_id; // Command packet type - u8 length; // Command packet length - u16 reserved1; - - // DW 1-2 CCK rate counter - u16 cck[4]; - - // DW 3-6 - u16 ofdm[8]; - - // DW 7-14 - //UINT16 MCS_BW0_SG0[16]; - - // DW 15-22 - //UINT16 MCS_BW1_SG0[16]; - - // DW 23-30 - //UINT16 MCS_BW0_SG1[16]; - - // DW 31-38 - //UINT16 MCS_BW1_SG1[16]; - - // DW 7-14 BW=0 SG=0 - // DW 15-22 BW=1 SG=0 - // DW 23-30 BW=0 SG=1 - // DW 31-38 BW=1 SG=1 - u16 ht_mcs[4][16]; - -}__attribute__((packed)) cmpk_tx_rahis_t; + u8 cfg_reserve1:3; + u8 cfg_size:2; /* Configuration info. */ + u8 cfg_type:2; /* Configuration info. */ + u8 cfg_action:1; /* Configuration info. */ + u8 cfg_reserve2; /* Configuration info. */ + u8 cfg_page:4; /* Configuration info. */ + u8 cfg_reserve3:4; /* Configuration info. */ + u8 cfg_offset; /* Configuration info. */ + u32 value; + u32 mask; +} cmpk_set_cfg_t; + +/* + * 4. Both side : TX/RX query configuraton packet. + * The query structure is the same as set configuration. + */ +#define cmpk_query_cfg_t cmpk_set_cfg_t -typedef enum tag_command_packet_directories -{ +/* + * 5. Multi packet feedback status. + */ +typedef struct tag_tx_stats_feedback { + /* + * For endian transfer + * Driver will not the same as firmware structure. + */ + /* DW 0 */ + u16 reserve1; + u8 length; /* Command packet length */ + u8 element_id; /* Command packet type */ + + /* DW 1 */ + u16 txfail; /* Tx Fail count */ + u16 txok; /* Tx ok count */ + + /* DW 2 */ + u16 txmcok; /* tx multicast */ + u16 txretry; /* Tx Retry count */ + + /* DW 3 */ + u16 txucok; /* tx unicast */ + u16 txbcok; /* tx broadcast */ + + /* DW 4 */ + u16 txbcfail; + u16 txmcfail; + + /* DW 5 */ + u16 reserve2; + u16 txucfail; + + /* DW 6-8 */ + u32 txmclength; + u32 txbclength; + u32 txuclength; + + /* DW 9 */ + u16 reserve3_23; + u8 reserve3_1; + u8 rate; +} __attribute__((packed)) cmpk_tx_status_t; + +/* + * 6. Debug feedback message. + */ +typedef struct tag_rx_debug_message_feedback { + /* For endian transfer --> for driver */ + /* DW 0 */ + u16 reserve1; + u8 length; /* Command packet length */ + u8 element_id; /* Command packet type */ +} cmpk_rx_dbginfo_t; + +/* + * Define transmit rate history. For big endian format. + */ +typedef struct tag_tx_rate_history { + /* For endian transfer --> for driver */ + /* DW 0 */ + u8 element_id; /* Command packet type */ + u8 length; /* Command packet length */ + u16 reserved1; + /* DW 1-2 CCK rate counter */ + u16 cck[4]; + /* DW 3-6 */ + u16 ofdm[8]; + u16 ht_mcs[4][16]; +} __attribute__((packed)) cmpk_tx_rahis_t; + +typedef enum tag_command_packet_directories { RX_TX_FEEDBACK = 0, - RX_INTERRUPT_STATUS = 1, - TX_SET_CONFIG = 2, - BOTH_QUERY_CONFIG = 3, - RX_TX_STATUS = 4, - RX_DBGINFO_FEEDBACK = 5, - RX_TX_PER_PKT_FEEDBACK = 6, - RX_TX_RATE_HISTORY = 7, + RX_INTERRUPT_STATUS = 1, + TX_SET_CONFIG = 2, + BOTH_QUERY_CONFIG = 3, + RX_TX_STATUS = 4, + RX_DBGINFO_FEEDBACK = 5, + RX_TX_PER_PKT_FEEDBACK = 6, + RX_TX_RATE_HISTORY = 7, RX_CMD_ELE_MAX -}cmpk_element_e; +} cmpk_element_e; -extern bool cmpk_message_handle_tx(struct net_device *dev, u8* codevirtualaddress, u32 packettype, u32 buffer_len); +extern bool cmpk_message_handle_tx(struct net_device *dev, + u8 *codevirtualaddress, + u32 packettype, + u32 buffer_len); -extern u32 cmpk_message_handle_rx(struct net_device *dev, struct ieee80211_rx_stats * pstats); -extern bool SendTxCommandPacket( struct net_device *dev, void* pData, u32 DataLen); +extern u32 cmpk_message_handle_rx(struct net_device *dev, + struct ieee80211_rx_stats *pstats); +extern bool SendTxCommandPacket(struct net_device *dev, + void *pData, + u32 DataLen); #endif |