Google Git
Sign in
gfiber / kernel / skids / b796900e7484f66f7a06d6ddf2e73236561a478a / . / drivers / staging / rtl8192su / r8192U_core.c
blob: 1b6890611fb6dc822156e6ffbee719fb156712c3 [file] [log] [blame]
/******************************************************************************
* Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
* Linux device driver for RTL8192U
*
* Based on the r8187 driver, which is:
* Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* 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:
* Jerry chuang <wlanfae@realtek.com>
*/
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/eeprom_93cx6.h>
#undef LOOP_TEST
#undef DUMP_RX
#undef DUMP_TX
#undef DEBUG_TX_DESC2
#undef RX_DONT_PASS_UL
#undef DEBUG_EPROM
#undef DEBUG_RX_VERBOSE
#undef DUMMY_RX
#undef DEBUG_ZERO_RX
#undef DEBUG_RX_SKB
#undef DEBUG_TX_FRAG
#undef DEBUG_RX_FRAG
#undef DEBUG_TX_FILLDESC
#undef DEBUG_TX
#undef DEBUG_IRQ
#undef DEBUG_RX
#undef DEBUG_RXALLOC
#undef DEBUG_REGISTERS
#undef DEBUG_RING
#undef DEBUG_IRQ_TASKLET
#undef DEBUG_TX_ALLOC
#undef DEBUG_TX_DESC
#define CONFIG_RTL8192_IO_MAP
#include <asm/uaccess.h>
#include "r8192U.h"
#include "r8192U_wx.h"
#include "r8192S_rtl8225.h"
#include "r8192S_hw.h"
#include "r8192S_phy.h"
#include "r8192S_phyreg.h"
#include "r8192S_Efuse.h"
#include "r819xU_cmdpkt.h"
#include "r8192U_dm.h"
//#include "r8192xU_phyreg.h"
#include <linux/usb.h>
#include "r8192U_pm.h"
#include "ieee80211/dot11d.h"
u32 rt_global_debug_component = \
// COMP_TRACE |
// COMP_DBG |
// COMP_INIT |
// COMP_RECV |
// COMP_SEND |
// COMP_IO |
COMP_POWER |
// COMP_EPROM |
COMP_SWBW |
COMP_POWER_TRACKING |
COMP_TURBO |
COMP_QOS |
// COMP_RATE |
// COMP_RM |
COMP_DIG |
// COMP_EFUSE |
// COMP_CH |
// COMP_TXAGC |
COMP_HIPWR |
// COMP_HALDM |
COMP_SEC |
COMP_LED |
// COMP_RF |
// COMP_RXDESC |
COMP_FIRMWARE |
COMP_HT |
COMP_AMSDU |
COMP_SCAN |
// COMP_CMD |
COMP_DOWN |
COMP_RESET |
COMP_ERR; //always open err flags on
#define TOTAL_CAM_ENTRY 32
#define CAM_CONTENT_COUNT 8
static const struct usb_device_id rtl8192_usb_id_tbl[] = {
{USB_DEVICE(0x0bda, 0x8171)}, /* Realtek */
{USB_DEVICE(0x0bda, 0x8172)},
{USB_DEVICE(0x0bda, 0x8173)},
{USB_DEVICE(0x0bda, 0x8174)},
{USB_DEVICE(0x0bda, 0x8712)},
{USB_DEVICE(0x0bda, 0x8713)},
{USB_DEVICE(0x07aa, 0x0047)},
{USB_DEVICE(0x07d1, 0x3303)},
{USB_DEVICE(0x07d1, 0x3302)},
{USB_DEVICE(0x07d1, 0x3300)},
{USB_DEVICE(0x1740, 0x9603)},
{USB_DEVICE(0x1740, 0x9605)},
{USB_DEVICE(0x050d, 0x815F)},
{USB_DEVICE(0x06f8, 0xe031)},
{USB_DEVICE(0x7392, 0x7611)},
{USB_DEVICE(0x7392, 0x7612)},
{USB_DEVICE(0x7392, 0x7622)},
{USB_DEVICE(0x0DF6, 0x0045)},
{USB_DEVICE(0x0E66, 0x0015)},
{USB_DEVICE(0x0E66, 0x0016)},
{USB_DEVICE(0x0b05, 0x1786)},
/* these are not in the official list */
{USB_DEVICE(0x0df6, 0x004b)}, /* WL-349 */
{}
};
MODULE_LICENSE("GPL");
MODULE_VERSION("V 1.1");
MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
static char* ifname = "wlan%d";
static int hwwep = 1; //default use hw. set 0 to use software security
static int channels = 0x3fff;
module_param(ifname, charp, S_IRUGO|S_IWUSR );
//module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
module_param(hwwep,int, S_IRUGO|S_IWUSR);
module_param(channels,int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
//MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
MODULE_PARM_DESC(hwwep," Try to use hardware security support. ");
MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
const struct usb_device_id *id);
static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf);
static struct usb_driver rtl8192_usb_driver = {
.name = RTL819xU_MODULE_NAME, /* Driver name */
.id_table = rtl8192_usb_id_tbl, /* PCI_ID table */
.probe = rtl8192_usb_probe, /* probe fn */
.disconnect = rtl8192_usb_disconnect, /* remove fn */
.suspend = rtl8192U_suspend, /* PM suspend fn */
.resume = rtl8192U_resume, /* PM resume fn */
.reset_resume = rtl8192U_resume, /* PM reset resume fn */
};
static void rtl8192SU_read_eeprom_info(struct net_device *dev);
short rtl8192SU_tx(struct net_device *dev, struct sk_buff* skb);
void rtl8192SU_rx_nomal(struct sk_buff* skb);
void rtl8192SU_rx_cmd(struct sk_buff *skb);
bool rtl8192SU_adapter_start(struct net_device *dev);
short rtl8192SU_tx_cmd(struct net_device *dev, struct sk_buff *skb);
void rtl8192SU_link_change(struct net_device *dev);
void InitialGain8192S(struct net_device *dev,u8 Operation);
void rtl8192SU_query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe);
struct rtl819x_ops rtl8192su_ops = {
.nic_type = NIC_8192SU,
.rtl819x_read_eeprom_info = rtl8192SU_read_eeprom_info,
.rtl819x_tx = rtl8192SU_tx,
.rtl819x_tx_cmd = rtl8192SU_tx_cmd,
.rtl819x_rx_nomal = rtl8192SU_rx_nomal,
.rtl819x_rx_cmd = rtl8192SU_rx_cmd,
.rtl819x_adapter_start = rtl8192SU_adapter_start,
.rtl819x_link_change = rtl8192SU_link_change,
.rtl819x_initial_gain = InitialGain8192S,
.rtl819x_query_rxdesc_status = rtl8192SU_query_rxdesc_status,
};
typedef struct _CHANNEL_LIST
{
u8 Channel[32];
u8 Len;
}CHANNEL_LIST, *PCHANNEL_LIST;
static CHANNEL_LIST ChannelPlan[] = {
{{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64,149,153,157,161,165},24}, //FCC
{{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
{{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
{{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
{{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
{{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, //MKK //MKK
{{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
{{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
{{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, // For 11a , TELEC
{{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
{{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;
struct ieee80211_device* ieee = priv->ieee80211;
switch (channel_plan)
{
case COUNTRY_CODE_FCC:
case COUNTRY_CODE_IC:
case COUNTRY_CODE_ETSI:
case COUNTRY_CODE_SPAIN:
case COUNTRY_CODE_FRANCE:
case COUNTRY_CODE_MKK:
case COUNTRY_CODE_MKK1:
case COUNTRY_CODE_ISRAEL:
case COUNTRY_CODE_TELEC:
case COUNTRY_CODE_MIC:
{
Dot11d_Init(ieee);
ieee->bGlobalDomain = false;
//acturally 8225 & 8256 rf chip only support B,G,24N mode
if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256) || (priv->rf_chip == RF_6052))
{
min_chan = 1;
max_chan = 14;
}
else
{
RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
}
if (ChannelPlan[channel_plan].Len != 0){
// Clear old channel map
memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
// Set new channel map
for (i=0;i<ChannelPlan[channel_plan].Len;i++)
{
if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
break;
GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
}
}
break;
}
case COUNTRY_CODE_GLOBAL_DOMAIN:
{
GET_DOT11D_INFO(ieee)->bEnabled = 0;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
Dot11d_Reset(ieee);
ieee->bGlobalDomain = true;
break;
}
default:
break;
}
return;
}
#define eqMacAddr(a,b) ( ((a)[0]==(b)[0] && (a)[1]==(b)[1] && (a)[2]==(b)[2] && (a)[3]==(b)[3] && (a)[4]==(b)[4] && (a)[5]==(b)[5]) ? 1:0 )
#define rx_hal_is_cck_rate(_pDesc)\
((_pDesc->RxMCS == DESC92S_RATE1M ||\
_pDesc->RxMCS == DESC92S_RATE2M ||\
_pDesc->RxMCS == DESC92S_RATE5_5M ||\
_pDesc->RxMCS == DESC92S_RATE11M) &&\
!_pDesc->RxHT)
#define tx_hal_is_cck_rate(_DataRate)\
( _DataRate == MGN_1M ||\
_DataRate == MGN_2M ||\
_DataRate == MGN_5_5M ||\
_DataRate == MGN_11M )
void CamResetAllEntry(struct net_device *dev)
{
#if 1
u32 ulcommand = 0;
//2004/02/11 In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
// However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
// In this condition, Cam can not be reset because upper layer will not set this static key again.
//if(Adapter->EncAlgorithm == WEP_Encryption)
// return;
//debug
//DbgPrint("========================================\n");
//DbgPrint(" Call ResetAllEntry \n");
//DbgPrint("========================================\n\n");
ulcommand |= BIT31|BIT30;
write_nic_dword(dev, RWCAM, ulcommand);
#else
for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
CAM_mark_invalid(dev, ucIndex);
for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
CAM_empty_entry(dev, ucIndex);
#endif
}
void write_cam(struct net_device *dev, u8 addr, u32 data)
{
write_nic_dword(dev, WCAMI, data);
write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
}
u32 read_cam(struct net_device *dev, u8 addr)
{
write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
return read_nic_dword(dev, 0xa8);
}
void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
{
int status;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct usb_device *udev = priv->udev;
status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
indx|0xfe00, 0, &data, 1, HZ / 2);
if (status < 0)
{
printk("write_nic_byte_E TimeOut! status:%d\n", status);
}
}
u8 read_nic_byte_E(struct net_device *dev, int indx)
{
int status;
u8 data;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct usb_device *udev = priv->udev;
status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
indx|0xfe00, 0, &data, 1, HZ / 2);
if (status < 0)
{
printk("read_nic_byte_E TimeOut! status:%d\n", status);
}
return data;
}
//as 92U has extend page from 4 to 16, so modify functions below.
void write_nic_byte(struct net_device *dev, int indx, u8 data)
{
int status;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct usb_device *udev = priv->udev;
status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
indx, 0, &data, 1, HZ / 2);
if (status < 0)
{
printk("write_nic_byte TimeOut! status:%d\n", status);
}
}
void write_nic_word(struct net_device *dev, int indx, u16 data)
{
int status;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct usb_device *udev = priv->udev;
status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
indx, 0, &data, 2, HZ / 2);
if (status < 0)
{
printk("write_nic_word TimeOut! status:%d\n", status);
}
}
void write_nic_dword(struct net_device *dev, int indx, u32 data)
{
int status;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct usb_device *udev = priv->udev;
status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
indx, 0, &data, 4, HZ / 2);
if (status < 0)
{
printk("write_nic_dword TimeOut! status:%d\n", status);
}
}
u8 read_nic_byte(struct net_device *dev, int indx)
{
u8 data;
int status;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct usb_device *udev = priv->udev;
status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
indx, 0, &data, 1, HZ / 2);
if (status < 0)
{
printk("read_nic_byte TimeOut! status:%d\n", status);
}
return data;
}
u16 read_nic_word(struct net_device *dev, int indx)
{
u16 data;
int status;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct usb_device *udev = priv->udev;
status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
indx, 0, &data, 2, HZ / 2);
if (status < 0)
{
printk("read_nic_word TimeOut! status:%d\n", status);
}
return data;
}
u16 read_nic_word_E(struct net_device *dev, int indx)
{
u16 data;
int status;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct usb_device *udev = priv->udev;
status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
indx|0xfe00, 0, &data, 2, HZ / 2);
if (status < 0)
{
printk("read_nic_word TimeOut! status:%d\n", status);
}
return data;
}
u32 read_nic_dword(struct net_device *dev, int indx)
{
u32 data;
int status;
// int result;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct usb_device *udev = priv->udev;
status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
indx, 0, &data, 4, HZ / 2);
// if(0 != result) {
// printk(KERN_WARNING "read size of data = %d\, date = %d\n", result, data);
// }
if (status < 0)
{
printk("read_nic_dword TimeOut! status:%d\n", status);
if(status == -ENODEV) {
priv->usb_error = true;
}
}
return data;
}
//u8 read_phy_cck(struct net_device *dev, u8 adr);
//u8 read_phy_ofdm(struct net_device *dev, u8 adr);
/* this might still called in what was the PHY rtl8185/rtl8192 common code
* plans are to possibilty turn it again in one common code...
*/
inline void force_pci_posting(struct net_device *dev)
{
}
static struct net_device_stats *rtl8192_stats(struct net_device *dev);
void rtl8192_commit(struct net_device *dev);
//void rtl8192_restart(struct net_device *dev);
void rtl8192_restart(struct work_struct *work);
//void rtl8192_rq_tx_ack(struct work_struct *work);
void watch_dog_timer_callback(unsigned long data);
/****************************************************************************
-----------------------------PROCFS STUFF-------------------------
*****************************************************************************/
static struct proc_dir_entry *rtl8192_proc = NULL;
static int proc_get_stats_ap(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct ieee80211_device *ieee = priv->ieee80211;
struct ieee80211_network *target;
int len = 0;
list_for_each_entry(target, &ieee->network_list, list) {
len += snprintf(page + len, count - len,
"%s ", target->ssid);
if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
len += snprintf(page + len, count - len,
"WPA\n");
}
else{
len += snprintf(page + len, count - len,
"non_WPA\n");
}
}
*eof = 1;
return len;
}
static int proc_get_registers(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
int i,n,page0,page1,page2;
int max=0xff;
page0 = 0x000;
page1 = 0x100;
page2 = 0x800;
/* This dump the current register page */
if(!IS_BB_REG_OFFSET_92S(page0)){
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len,
"\nD: %2x > ",n);
for(i=0;i<16 && n<=max;i++,n++)
len += snprintf(page + len, count - len,
"%2.2x ",read_nic_byte(dev,(page0|n)));
}
}else{
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len, "\nD: %2x > ",n);
for(i=0;i<4 && n<=max;n+=4,i++)
len += snprintf(page + len, count - len,
"%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
}
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_registers_1(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
int i,n,page0;
int max=0xff;
page0 = 0x100;
/* This dump the current register page */
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len,
"\nD: %2x > ",n);
for(i=0;i<16 && n<=max;i++,n++)
len += snprintf(page + len, count - len,
"%2.2x ",read_nic_byte(dev,(page0|n)));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_registers_2(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
int i,n,page0;
int max=0xff;
page0 = 0x200;
/* This dump the current register page */
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len,
"\nD: %2x > ",n);
for(i=0;i<16 && n<=max;i++,n++)
len += snprintf(page + len, count - len,
"%2.2x ",read_nic_byte(dev,(page0|n)));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_registers_8(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
int len = 0;
int i,n,page0;
int max=0xff;
page0 = 0x800;
/* This dump the current register page */
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len, "\nD: %2x > ",n);
for(i=0;i<4 && n<=max;n+=4,i++)
len += snprintf(page + len, count - len,
"%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_registers_9(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
int i,n,page0;
int max=0xff;
page0 = 0x900;
/* This dump the current register page */
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len, "\nD: %2x > ",n);
for(i=0;i<4 && n<=max;n+=4,i++)
len += snprintf(page + len, count - len,
"%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_registers_a(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
int i,n,page0;
int max=0xff;
page0 = 0xa00;
/* This dump the current register page */
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len, "\nD: %2x > ",n);
for(i=0;i<4 && n<=max;n+=4,i++)
len += snprintf(page + len, count - len,
"%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_registers_b(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
int i,n,page0;
int max=0xff;
page0 = 0xb00;
/* This dump the current register page */
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len, "\nD: %2x > ",n);
for(i=0;i<4 && n<=max;n+=4,i++)
len += snprintf(page + len, count - len,
"%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_registers_c(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
int i,n,page0;
int max=0xff;
page0 = 0xc00;
/* This dump the current register page */
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len, "\nD: %2x > ",n);
for(i=0;i<4 && n<=max;n+=4,i++)
len += snprintf(page + len, count - len,
"%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_registers_d(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
int i,n,page0;
int max=0xff;
page0 = 0xd00;
/* This dump the current register page */
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len, "\nD: %2x > ",n);
for(i=0;i<4 && n<=max;n+=4,i++)
len += snprintf(page + len, count - len,
"%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_registers_e(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
int i,n,page0;
int max=0xff;
page0 = 0xe00;
/* This dump the current register page */
len += snprintf(page + len, count - len,
"\n####################page %x##################\n ", (page0>>8));
for(n=0;n<=max;)
{
len += snprintf(page + len, count - len, "\nD: %2x > ",n);
for(i=0;i<4 && n<=max;n+=4,i++)
len += snprintf(page + len, count - len,
"%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
static int proc_get_stats_tx(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
len += snprintf(page + len, count - len,
"TX VI priority ok int: %lu\n"
"TX VI priority error int: %lu\n"
"TX VO priority ok int: %lu\n"
"TX VO priority error int: %lu\n"
"TX BE priority ok int: %lu\n"
"TX BE priority error int: %lu\n"
"TX BK priority ok int: %lu\n"
"TX BK priority error int: %lu\n"
"TX MANAGE priority ok int: %lu\n"
"TX MANAGE priority error int: %lu\n"
"TX BEACON priority ok int: %lu\n"
"TX BEACON priority error int: %lu\n"
// "TX high priority ok int: %lu\n"
// "TX high priority failed error int: %lu\n"
"TX queue resume: %lu\n"
"TX queue stopped?: %d\n"
"TX fifo overflow: %lu\n"
// "TX beacon: %lu\n"
"TX VI queue: %d\n"
"TX VO queue: %d\n"
"TX BE queue: %d\n"
"TX BK queue: %d\n"
// "TX HW queue: %d\n"
"TX VI dropped: %lu\n"
"TX VO dropped: %lu\n"
"TX BE dropped: %lu\n"
"TX BK dropped: %lu\n"
"TX total data packets %lu\n",
// "TX beacon aborted: %lu\n",
priv->stats.txviokint,
priv->stats.txvierr,
priv->stats.txvookint,
priv->stats.txvoerr,
priv->stats.txbeokint,
priv->stats.txbeerr,
priv->stats.txbkokint,
priv->stats.txbkerr,
priv->stats.txmanageokint,
priv->stats.txmanageerr,
priv->stats.txbeaconokint,
priv->stats.txbeaconerr,
// priv->stats.txhpokint,
// priv->stats.txhperr,
priv->stats.txresumed,
netif_queue_stopped(dev),
priv->stats.txoverflow,
// priv->stats.txbeacon,
atomic_read(&(priv->tx_pending[VI_PRIORITY])),
atomic_read(&(priv->tx_pending[VO_PRIORITY])),
atomic_read(&(priv->tx_pending[BE_PRIORITY])),
atomic_read(&(priv->tx_pending[BK_PRIORITY])),
// read_nic_byte(dev, TXFIFOCOUNT),
priv->stats.txvidrop,
priv->stats.txvodrop,
priv->stats.txbedrop,
priv->stats.txbkdrop,
priv->stats.txdatapkt
// priv->stats.txbeaconerr
);
*eof = 1;
return len;
}
static int proc_get_stats_rx(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int len = 0;
len += snprintf(page + len, count - len,
"RX packets: %lu\n"
"RX urb status error: %lu\n"
"RX invalid urb error: %lu\n",
priv->stats.rxoktotal,
priv->stats.rxstaterr,
priv->stats.rxurberr);
*eof = 1;
return len;
}
void rtl8192_proc_module_init(void)
{
RT_TRACE(COMP_INIT, "Initializing proc filesystem");
rtl8192_proc=create_proc_entry(RTL819xU_MODULE_NAME, S_IFDIR, init_net.proc_net);
}
void rtl8192_proc_module_remove(void)
{
remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
}
void rtl8192_proc_remove_one(struct net_device *dev)
{
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
if (priv->dir_dev) {
// remove_proc_entry("stats-hw", priv->dir_dev);
remove_proc_entry("stats-tx", priv->dir_dev);
remove_proc_entry("stats-rx", priv->dir_dev);
// remove_proc_entry("stats-ieee", priv->dir_dev);
remove_proc_entry("stats-ap", priv->dir_dev);
remove_proc_entry("registers", priv->dir_dev);
remove_proc_entry("registers-1", priv->dir_dev);
remove_proc_entry("registers-2", priv->dir_dev);
remove_proc_entry("registers-8", priv->dir_dev);
remove_proc_entry("registers-9", priv->dir_dev);
remove_proc_entry("registers-a", priv->dir_dev);
remove_proc_entry("registers-b", priv->dir_dev);
remove_proc_entry("registers-c", priv->dir_dev);
remove_proc_entry("registers-d", priv->dir_dev);
remove_proc_entry("registers-e", priv->dir_dev);
// remove_proc_entry("cck-registers",priv->dir_dev);
// remove_proc_entry("ofdm-registers",priv->dir_dev);
//remove_proc_entry(dev->name, rtl8192_proc);
remove_proc_entry("wlan0", rtl8192_proc);
priv->dir_dev = NULL;
}
}
void rtl8192_proc_init_one(struct net_device *dev)
{
struct proc_dir_entry *e;
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
priv->dir_dev = create_proc_entry(dev->name,
S_IFDIR | S_IRUGO | S_IXUGO,
rtl8192_proc);
if (!priv->dir_dev) {
RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
dev->name);
return;
}
e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_stats_rx, dev);
if (!e) {
RT_TRACE(COMP_ERR,"Unable to initialize "
"/proc/net/rtl8192/%s/stats-rx\n",
dev->name);
}
e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_stats_tx, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/stats-tx\n",
dev->name);
}
e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_stats_ap, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/stats-ap\n",
dev->name);
}
e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers\n",
dev->name);
}
e = create_proc_read_entry("registers-1", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers_1, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers-1\n",
dev->name);
}
e = create_proc_read_entry("registers-2", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers_2, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers-2\n",
dev->name);
}
e = create_proc_read_entry("registers-8", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers_8, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers-8\n",
dev->name);
}
e = create_proc_read_entry("registers-9", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers_9, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers-9\n",
dev->name);
}
e = create_proc_read_entry("registers-a", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers_a, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers-a\n",
dev->name);
}
e = create_proc_read_entry("registers-b", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers_b, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers-b\n",
dev->name);
}
e = create_proc_read_entry("registers-c", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers_c, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers-c\n",
dev->name);
}
e = create_proc_read_entry("registers-d", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers_d, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers-d\n",
dev->name);
}
e = create_proc_read_entry("registers-e", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers_e, dev);
if (!e) {
RT_TRACE(COMP_ERR, "Unable to initialize "
"/proc/net/rtl8192/%s/registers-e\n",
dev->name);
}
}
/****************************************************************************
-----------------------------MISC STUFF-------------------------
*****************************************************************************/
/* this is only for debugging */
void print_buffer(u32 *buffer, int len)
{
int i;
u8 *buf =(u8*)buffer;
printk("ASCII BUFFER DUMP (len: %x):\n",len);
for(i=0;i<len;i++)
printk("%c",buf[i]);
printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
for(i=0;i<len;i++)
printk("%x",buf[i]);
printk("\n");
}
//short check_nic_enough_desc(struct net_device *dev, priority_t priority)
short check_nic_enough_desc(struct net_device *dev,int queue_index)
{
struct r8192_priv *priv = ieee80211_priv(dev);
int used = atomic_read(&priv->tx_pending[queue_index]);
return (used < MAX_TX_URB);
}
void tx_timeout(struct net_device *dev)
{
struct r8192_priv *priv = ieee80211_priv(dev);
//rtl8192_commit(dev);
schedule_work(&priv->reset_wq);
//DMESG("TXTIMEOUT");
}
/* this is only for debug */
void rtl8192_dump_reg(struct net_device *dev)
{
int i;
int n;
int max=0x1ff;
RT_TRACE(COMP_PHY, "Dumping NIC register map");
for(n=0;n<=max;)
{
printk( "\nD: %2x> ", n);
for(i=0;i<16 && n<=max;i++,n++)
printk("%2x ",read_nic_byte(dev,n));
}
printk("\n");
}
/****************************************************************************
------------------------------HW STUFF---------------------------
*****************************************************************************/
void rtl8192_set_mode(struct net_device *dev,int mode)
{
u8 ecmd;
ecmd=read_nic_byte(dev, EPROM_CMD);
ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
write_nic_byte(dev, EPROM_CMD, ecmd);
}
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);
msr &= ~ MSR_LINK_MASK;
/* do not change in link_state != WLAN_LINK_ASSOCIATED.
* msr must be updated if the state is ASSOCIATING.
* 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->iw_mode == IW_MODE_INFRA) {
msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
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
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)
{
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
// u32 tx;
RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
//printk("=====>%s()====ch:%d\n", __FUNCTION__, ch);
priv->chan=ch;
/* this hack should avoid frame TX during channel setting*/
// tx = read_nic_dword(dev,TX_CONF);
// tx &= ~TX_LOOPBACK_MASK;
#ifndef LOOP_TEST
// write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
//need to implement rf set channel here WB
if (priv->rf_set_chan)
priv->rf_set_chan(dev,priv->chan);
mdelay(10);
// write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
#endif
}
static void rtl8192_rx_isr(struct urb *urb);
u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
{
return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
+ pstats->RxBufShift);
}
static int rtl8192_rx_initiate(struct net_device*dev)
{
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
struct urb *entry;
struct sk_buff *skb;
struct rtl8192_rx_info *info;
/* nomal packet rx procedure */
while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
if (!skb)
break;
entry = usb_alloc_urb(0, GFP_KERNEL);
if (!entry) {
kfree_skb(skb);
break;
}
usb_fill_bulk_urb(entry, priv->udev,
usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
RX_URB_SIZE, rtl8192_rx_isr, skb);
info = (struct rtl8192_rx_info *) skb->cb;
info->urb = entry;
info->dev = dev;
info->out_pipe = 3; //denote rx normal packet queue
skb_queue_tail(&priv->rx_queue, skb);
usb_submit_urb(entry, GFP_KERNEL);
}
/* command packet rx procedure */
while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL);
if (!skb)
break;
entry = usb_alloc_urb(0, GFP_KERNEL);
if (!entry) {
kfree_skb(skb);
break;
}
usb_fill_bulk_urb(entry, priv->udev,
usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
RX_URB_SIZE, rtl8192_rx_isr, skb);
info = (struct rtl8192_rx_info *) skb->cb;
info->urb = entry;
info->dev = dev;
info->out_pipe = 9; //denote rx cmd packet queue
skb_queue_tail(&priv->rx_queue, skb);
usb_submit_urb(entry, GFP_KERNEL);
}
return 0;
}
void rtl8192_set_rxconf(struct net_device *dev)
{
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
u32 rxconf;
rxconf=read_nic_dword(dev,RCR);
rxconf = rxconf &~ MAC_FILTER_MASK;
rxconf = rxconf | RCR_AMF;
rxconf = rxconf | RCR_ADF;
rxconf = rxconf | RCR_AB;
rxconf = rxconf | RCR_AM;
//rxconf = rxconf | RCR_ACF;
if (dev->flags & IFF_PROMISC) {DMESG ("NIC in promisc mode");}
if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
dev->flags & IFF_PROMISC){
rxconf = rxconf | RCR_AAP;
} /*else if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
}*/else{
rxconf = rxconf | RCR_APM;
rxconf = rxconf | RCR_CBSSID;
}
if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
rxconf = rxconf | RCR_AICV;
rxconf = rxconf | RCR_APWRMGT;
}
if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
rxconf = rxconf | RCR_ACRC32;
rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
rxconf = rxconf &~ MAX_RX_DMA_MASK;
rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
// rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
rxconf = rxconf | RCR_ONLYERLPKT;
// rxconf = rxconf &~ RCR_CS_MASK;
// rxconf = rxconf | (1<<RCR_CS_SHIFT);
write_nic_dword(dev, RCR, rxconf);
#ifdef DEBUG_RX
DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RCR));
#endif
}
//wait to be removed
void rtl8192_rx_enable(struct net_device *dev)
{
//u8 cmd;
//struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
rtl8192_rx_initiate(dev);
// rtl8192_set_rxconf(dev);
}
void rtl8192_tx_enable(struct net_device *dev)
{
}
void rtl8192_rtx_disable(struct net_device *dev)
{
u8 cmd;
struct r8192_priv *priv = ieee80211_priv(dev);
struct sk_buff *skb;
struct rtl8192_rx_info *info;
cmd=read_nic_byte(dev,CMDR);
write_nic_byte(dev, CMDR, cmd &~ \
(CR_TE|CR_RE));
force_pci_posting(dev);
mdelay(10);
while ((skb = __skb_dequeue(&priv->rx_queue))) {
info = (struct rtl8192_rx_info *) skb->cb;
if (!info->urb)
continue;
usb_kill_urb(info->urb);
kfree_skb(skb);
}
if (skb_queue_len(&priv->skb_queue)) {
printk(KERN_WARNING "skb_queue not empty\n");
}
skb_queue_purge(&priv->skb_queue);
return;
}
int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
{
return 0;
}
inline u16 ieeerate2rtlrate(int rate)
{
switch(rate){
case 10:
return 0;
case 20:
return 1;
case 55:
return 2;
case 110:
return 3;
case 60:
return 4;
case 90:
return 5;
case 120:
return 6;
case 180:
return 7;
case 240:
return 8;
case 360:
return 9;
case 480:
return 10;
case 540:
return 11;
default:
return 3;
}
}
static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
inline u16 rtl8192_rate2rate(short rate)
{
if (rate >11) return 0;
return rtl_rate[rate];
}
static void rtl8192_rx_isr(struct urb *urb)
{
struct sk_buff *skb = (struct sk_buff *) urb->context;
struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
struct net_device *dev = info->dev;
struct r8192_priv *priv = ieee80211_priv(dev);
int out_pipe = info->out_pipe;
int err;
if(!priv->up)
return;
if (unlikely(urb->status)) {
info->urb = NULL;
priv->stats.rxstaterr++;
priv->ieee80211->stats.rx_errors++;
usb_free_urb(urb);
// printk("%s():rx status err\n",__FUNCTION__);
return;
}
skb_unlink(skb, &priv->rx_queue);
skb_put(skb, urb->actual_length);
skb_queue_tail(&priv->skb_queue, skb);
tasklet_schedule(&priv->irq_rx_tasklet);
skb = dev_alloc_skb(RX_URB_SIZE);
if (unlikely(!skb)) {
usb_free_urb(urb);
printk("%s():can,t alloc skb\n",__FUNCTION__);
/* TODO check rx queue length and refill *somewhere* */
return;
}
usb_fill_bulk_urb(urb, priv->udev,
usb_rcvbulkpipe(priv->udev, out_pipe),
skb_tail_pointer(skb),
RX_URB_SIZE, rtl8192_rx_isr, skb);
info = (struct rtl8192_rx_info *) skb->cb;
info->urb = urb;
info->dev = dev;
info->out_pipe = out_pipe;
urb->transfer_buffer = skb_tail_pointer(skb);
urb->context = skb;
skb_queue_tail(&priv->rx_queue, skb);
err = usb_submit_urb(urb, GFP_ATOMIC);
if(err && err != -EPERM)
printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
}
u32
rtl819xusb_rx_command_packet(
struct net_device *dev,
struct ieee80211_rx_stats *pstats
)
{
u32 status;
//RT_TRACE(COMP_RECV, DBG_TRACE, ("---> RxCommandPacketHandle819xUsb()\n"));
status = cmpk_message_handle_rx(dev, pstats);
if (status)
{
DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
}
else
{
//RT_TRACE(COMP_RECV, DBG_TRACE, ("RxCommandPacketHandle819xUsb: It is not a command packet\n"));
}
//RT_TRACE(COMP_RECV, DBG_TRACE, ("<--- RxCommandPacketHandle819xUsb()\n"));
return status;
}
void rtl8192_data_hard_stop(struct net_device *dev)
{
//FIXME !!
}
void rtl8192_data_hard_resume(struct net_device *dev)
{
// FIXME !!
}
/* this function TX data frames when the ieee80211 stack requires this.
* It checks also if we need to stop the ieee tx queue, eventually do it
*/
void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
{
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int ret;
unsigned long flags;
cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
u8 queue_index = tcb_desc->queue_index;
/* shall not be referred by command packet */
assert(queue_index != TXCMD_QUEUE);
spin_lock_irqsave(&priv->tx_lock,flags);
memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
// tcb_desc->RATRIndex = 7;
// tcb_desc->bTxDisableRateFallBack = 1;
// tcb_desc->bTxUseDriverAssingedRate = 1;
tcb_desc->bTxEnableFwCalcDur = 1;
skb_push(skb, priv->ieee80211->tx_headroom);
ret = priv->ops->rtl819x_tx(dev, skb);
//priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
//priv->ieee80211->stats.tx_packets++;
spin_unlock_irqrestore(&priv->tx_lock,flags);
// return ret;
return;
}
/* This is a rough attempt to TX a frame
* This is called by the ieee 80211 stack to TX management frames.
* If the ring is full packet are dropped (for data frame the queue
* is stopped before this can happen).
*/
int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
{
struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
int ret;
unsigned long flags;
cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
u8 queue_index = tcb_desc->queue_index;
spin_lock_irqsave(&priv->tx_lock,flags);
memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
if(queue_index == TXCMD_QUEUE) {
skb_push(skb, USB_HWDESC_HEADER_LEN);
priv->ops->rtl819x_tx_cmd(dev, skb);
ret = 1;
spin_unlock_irqrestore(&priv->tx_lock,flags);
return ret;
} else {
skb_push(skb, priv->ieee80211->tx_headroom);
ret = priv->ops->rtl819x_tx(dev, skb);
}
spin_unlock_irqrestore(&priv->tx_lock,flags);
return ret;
}
void rtl8192_try_wake_queue(struct net_device *dev, int pri);
static void rtl8192_tx_isr(struct urb *tx_urb)
{
struct sk_buff *skb = (struct sk_buff*)tx_urb->context;
struct net_device *dev = NULL;
struct r8192_priv *priv = NULL;
cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
u8 queue_index = tcb_desc->queue_index;
// bool bToSend0Byte;
// u16 BufLen = skb->len;
memcpy(&dev,(struct net_device*)(skb->cb),sizeof(struct net_device*));
priv = ieee80211_priv(dev);
if(tcb_desc->queue_index != TXCMD_QUEUE) {
if(tx_urb->status == 0) {
// dev->trans_start = jiffies;
// As act as station mode, destion shall be unicast address.
//priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
//priv->ieee80211->stats.tx_packets++;
priv->stats.txoktotal++;
priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
} else {
priv->ieee80211->stats.tx_errors++;
//priv->stats.txmanageerr++;
/* TODO */
}
}
/* free skb and tx_urb */
if(skb != NULL) {
dev_kfree_skb_any(skb);
usb_free_urb(tx_urb);
atomic_dec(&priv->tx_pending[queue_index]);
}
{
//
// Handle HW Beacon:
// We had transfer our beacon frame to host controler at this moment.
//
//
// Caution:
// Handling the wait queue of command packets.
// For Tx command packets, we must not do TCB fragment because it is not handled right now.
// We must cut the packets to match the size of TX_CMD_PKT before we send it.
//
if (queue_index == MGNT_QUEUE){
if (priv->ieee80211->ack_tx_to_ieee){
if (rtl8192_is_tx_queue_empty(dev)){
priv->ieee80211->ack_tx_to_ieee = 0;
ieee80211_ps_tx_ack(priv->ieee80211, 1);
}
}
}
/* Handle MPDU in wait queue. */
if(queue_index != BEACON_QUEUE) {
/* Don't send data frame during scanning.*/
if((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0)&&\
(!(priv->ieee80211->queue_stop))) {
if(NULL != (skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]))))
priv->ieee80211->softmac_hard_start_xmit(skb, dev);
return; //modified by david to avoid further processing AMSDU
}
}
}
}
void rtl8192_beacon_stop(struct net_device *dev)
{
u8 msr, msrm, msr2;
struct r8192_priv *priv = ieee80211_priv(dev);
msr = read_nic_byte(dev, MSR);
msrm = msr & MSR_LINK_MASK;
msr2 = msr & ~MSR_LINK_MASK;
if(NIC_8192U == priv->card_8192) {
usb_kill_urb(priv->rx_urb[MAX_RX_URB]);
}
if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
(msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
write_nic_byte(dev, MSR, msr);
}
}
void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
{
struct r8192_priv *priv = ieee80211_priv(dev);
struct ieee80211_network *net;
u8 i=0, basic_rate = 0;
net = & priv->ieee80211->current_network;
for (i=0; i<net->rates_len; i++)
{
basic_rate = net->rates[i]&0x7f;
switch(basic_rate)
{
case MGN_1M: *rate_config |= RRSR_1M; break;
case MGN_2M: *rate_config |= RRSR_2M; break;
case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
case MGN_11M: *rate_config |= RRSR_11M; break;
case MGN_6M: *rate_config |= RRSR_6M; break;
case MGN_9M: *rate_config |= RRSR_9M; break;
case MGN_12M: *rate_config |= RRSR_12M; break;
case MGN_18M: *rate_config |= RRSR_18M; break;
case MGN_24M: *rate_config |= RRSR_24M; break;
case MGN_36M: *rate_config |= RRSR_36M; break;
case MGN_48M: *rate_config |= RRSR_48M; break;
case MGN_54M: *rate_config |= RRSR_54M; break;
}
}
for (i=0; i<net->rates_ex_len; i++)
{
basic_rate = net->rates_ex[i]&0x7f;
switch(basic_rate)
{
case MGN_1M: *rate_config |= RRSR_1M; break;
case MGN_2M: *rate_config |= RRSR_2M; break;
case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
case MGN_11M: *rate_config |= RRSR_11M; break;
case MGN_6M: *rate_config |= RRSR_6M; break;
case MGN_9M: *rate_config |= RRSR_9M; break;
case MGN_12M: *rate_config |= RRSR_12M; break;
case MGN_18M: *rate_config |= RRSR_18M; break;
case MGN_24M: *rate_config |= RRSR_24M; break;
case MGN_36M: *rate_config |= RRSR_36M; break;
case MGN_48M: *rate_config |= RRSR_48M; break;
case MGN_54M: *rate_config |= RRSR_54M; break;
}
}
}
#define SHORT_SLOT_TIME 9
#define NON_SHORT_SLOT_TIME 20
void rtl8192_update_cap(struct net_device* dev, u16 cap)
{
//u32 tmp = 0;
struct r8192_priv *priv = ieee80211_priv(dev);
struct ieee80211_network *net = &priv->ieee80211->current_network;
priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
//LZM MOD 090303 HW_VAR_ACK_PREAMBLE
if(0)
{
u8 tmp = 0;
tmp = ((priv->nCur40MhzPrimeSC) << 5);
if (priv->short_preamble)
tmp |= 0x80;
write_nic_byte(dev, RRSR+2, tmp);
}
if (net->mode & (IEEE_G|IEEE_N_24G))
{
u8 slot_time = 0;
if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
{//short slot time
slot_time = SHORT_SLOT_TIME;
}
else //long slot time
slot_time = NON_SHORT_SLOT_TIME;
priv->slot_time = slot_time;
write_nic_byte(dev, SLOT_TIME, slot_time);
}
}
void rtl8192_net_update(struct net_device *dev)
{
struct r8192_priv *priv = ieee80211_priv(dev);
struct ieee80211_network *net;
u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
u16 rate_config = 0;
net = & priv->ieee80211->current_network;
rtl8192_config_rate(dev, &rate_config);
priv->basic_rate = rate_config &= 0x15f;
write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
//for(i=0;i<ETH_ALEN;i++)
// write_nic_byte(dev,BSSID+i,net->bssid[i]);
rtl8192_update_msr(dev);
// rtl8192_update_cap(dev, net->capability);
if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
{
write_nic_word(dev, ATIMWND, 2);
write_nic_word(dev, BCN_DMATIME, 1023);
write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
// write_nic_word(dev, BcnIntTime, 100);
write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
write_nic_byte(dev, BCN_ERR_THRESH, 100);
BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
// TODO: BcnIFS may required to be changed on ASIC
BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
}
}
//temporary hw beacon is not used any more.
//open it when necessary
#if 1
void rtl819xusb_beacon_tx(struct net_device *dev,u16 tx_rate)
{
}
#endif
inline u8 rtl8192_IsWirelessBMode(u16 rate)
{
if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
return 1;
else return 0;
}
u16 N_DBPSOfRate(u16 DataRate);
u16 ComputeTxTime(
u16 FrameLength,
u16 DataRate,
u8 bManagementFrame,
u8 bShortPreamble
)
{
u16 FrameTime;
u16 N_DBPS;
u16 Ceiling;
if( rtl8192_IsWirelessBMode(DataRate) )
{
if( bManagementFrame || !bShortPreamble || DataRate == 10 )
{ // long preamble
FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
}
else
{ // Short preamble
FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
}
if( ( FrameLength*8 % (DataRate/10) ) != 0 ) //Get the Ceilling
FrameTime ++;
} else { //802.11g DSSS-OFDM PLCP length field calculation.
N_DBPS = N_DBPSOfRate(DataRate);
Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
+ (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
}
return FrameTime;
}
u16 N_DBPSOfRate(u16 DataRate)
{
u16 N_DBPS = 24;
switch(DataRate)
{
case 60:
N_DBPS = 24;
break;
case 90:
N_DBPS = 36;
break;
case 120:
N_DBPS = 48;
break;
case 180:
N_DBPS = 72;
break;
case 240:
N_DBPS = 96;
break;
case 360:
N_DBPS = 144;
break;
case 480:
N_DBPS = 192;
break;
case 540:
N_DBPS = 216;
break;
default:
break;
}
return N_DBPS;
}
void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
{
usb_free_urb(tx_cmd_urb);
}
unsigned int txqueue2outpipe(struct r8192_priv* priv,unsigned int tx_queue) {
if(tx_queue >= 9)
{
RT_TRACE(COMP_ERR,"%s():Unknown queue ID!!!\n",__FUNCTION__);
return 0x04;
}
return priv->txqueue_to_outpipemap[tx_queue];
}
short rtl8192SU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
{
struct r8192_priv *priv = ieee80211_priv(dev);
int status;
struct urb *tx_urb;
unsigned int idx_pipe;
tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
u8 queue_index = tcb_desc->queue_index;
u32 PktSize = 0;
//printk("\n %s::::::::::::::::::::::queue_index = %d\n",__FUNCTION__, queue_index);
atomic_inc(&priv->tx_pending[queue_index]);
tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
if(!tx_urb){
dev_kfree_skb(skb);
return -ENOMEM;
}
memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
/* Tx descriptor ought to be set according to the skb->cb */
pdesc->LINIP = tcb_desc->bLastIniPkt;
PktSize = (u16)(skb->len - USB_HWDESC_HEADER_LEN);
pdesc->PktSize = PktSize;
//printk("PKTSize = %d %x\n",pdesc->PktSize,pdesc->PktSize);
//----------------------------------------------------------------------------
// Fill up USB_OUT_CONTEXT.
//----------------------------------------------------------------------------
// Get index to out pipe from specified QueueID.
idx_pipe = txqueue2outpipe(priv,queue_index);
//printk("=============>%s queue_index:%d, outpipe:%d\n", __func__,queue_index,priv->RtOutPipes[idx_pipe]);
usb_fill_bulk_urb(tx_urb,
priv->udev,
usb_sndbulkpipe(priv->udev,priv->RtOutPipes[idx_pipe]),
skb->data,
skb->len,
rtl8192_tx_isr,
skb);
status = usb_submit_urb(tx_urb, GFP_ATOMIC);
if (!status){
return 0;
}else{
printk("Error TX CMD URB, error %d",
status);
return -1;
}
}
/*
* Mapping Software/Hardware descriptor queue id to "Queue Select Field"
* in TxFwInfo data structure
* 2006.10.30 by Emily
*
* \param QUEUEID Software Queue
*/
u8 MapHwQueueToFirmwareQueue(u8 QueueID)
{
u8 QueueSelect = 0x0; //defualt set to
switch(QueueID) {
case BE_QUEUE:
QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
break;
case BK_QUEUE:
QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
break;
case VO_QUEUE:
QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
break;
case VI_QUEUE:
QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
break;
case MGNT_QUEUE:
QueueSelect = QSLT_MGNT;
break;
case BEACON_QUEUE:
QueueSelect = QSLT_BEACON;
break;
// TODO: 2006.10.30 mark other queue selection until we verify it is OK
// TODO: Remove Assertions
//#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
case TXCMD_QUEUE:
QueueSelect = QSLT_CMD;
break;
//#endif
case HIGH_QUEUE:
QueueSelect = QSLT_HIGH;
break;
default:
RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
break;
}
return QueueSelect;
}
u8 MRateToHwRate8190Pci(u8 rate)
{
u8 ret = DESC92S_RATE1M;
switch(rate)
{
// CCK and OFDM non-HT rates
case MGN_1M: ret = DESC92S_RATE1M; break;
case MGN_2M: ret = DESC92S_RATE2M; break;
case MGN_5_5M: ret = DESC92S_RATE5_5M; break;
case MGN_11M: ret = DESC92S_RATE11M; break;
case MGN_6M: ret = DESC92S_RATE6M; break;
case MGN_9M: ret = DESC92S_RATE9M; break;
case MGN_12M: ret = DESC92S_RATE12M; break;
case MGN_18M: ret = DESC92S_RATE18M; break;
case MGN_24M: ret = DESC92S_RATE24M; break;
case MGN_36M: ret = DESC92S_RATE36M; break;
case MGN_48M: ret = DESC92S_RATE48M; break;
case MGN_54M: ret = DESC92S_RATE54M; break;
// HT rates since here
case MGN_MCS0: ret = DESC92S_RATEMCS0; break;
case MGN_MCS1: ret = DESC92S_RATEMCS1; break;
case MGN_MCS2: ret = DESC92S_RATEMCS2; break;
case MGN_MCS3: ret = DESC92S_RATEMCS3; break;
case MGN_MCS4: ret = DESC92S_RATEMCS4; break;
case MGN_MCS5: ret = DESC92S_RATEMCS5; break;
case MGN_MCS6: ret = DESC92S_RATEMCS6; break;
case MGN_MCS7: ret = DESC92S_RATEMCS7; break;
case MGN_MCS8: ret = DESC92S_RATEMCS8; break;
case MGN_MCS9: ret = DESC92S_RATEMCS9; break;
case MGN_MCS10: ret = DESC92S_RATEMCS10; break;
case MGN_MCS11: ret = DESC92S_RATEMCS11; break;
case MGN_MCS12: ret = DESC92S_RATEMCS12; break;
case MGN_MCS13: ret = DESC92S_RATEMCS13; break;
case MGN_MCS14: ret = DESC92S_RATEMCS14; break;
case MGN_MCS15: ret = DESC92S_RATEMCS15; break;
// Set the highest SG rate
case MGN_MCS0_SG:
case MGN_MCS1_SG:
case MGN_MCS2_SG:
case MGN_MCS3_SG:
case MGN_MCS4_SG:
case MGN_MCS5_SG:
case MGN_MCS6_SG:
case MGN_MCS7_SG:
case MGN_MCS8_SG:
case MGN_MCS9_SG:
case MGN_MCS10_SG:
case MGN_MCS11_SG:
case MGN_MCS12_SG:
case MGN_MCS13_SG:
case MGN_MCS14_SG:
case MGN_MCS15_SG:
{
ret = DESC92S_RATEMCS15_SG;
break;
}
default: break;
}
return ret;
}
u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
{
u8 tmp_Short;
tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
if(TxHT==1 && TxRate != DESC90_RATEMCS15)
tmp_Short = 0;
return tmp_Short;
}
static void tx_zero_isr(struct urb *tx_urb)
{
return;
}
/*
* The tx procedure is just as following, skb->cb will contain all the following
*information: * priority, morefrag, rate, &dev.
* */
// <Note> Buffer format for 8192S Usb bulk out:
//
// --------------------------------------------------
// | 8192S Usb Tx Desc | 802_11_MAC_header | data |
// --------------------------------------------------
// | 32 bytes | 24 bytes |0-2318 bytes|
// --------------------------------------------------
// |<------------ BufferLen ------------------------->|
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;
struct usb_device *udev = priv->udev;
int pend;
int status;
struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
unsigned int idx_pipe;
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
* without interleaves * !!! For debug purpose */
if( pend > MAX_TX_URB){
switch (tcb_desc->queue_index) {
case VO_PRIORITY:
priv->stats.txvodrop++;
break;
case VI_PRIORITY:
priv->stats.txvidrop++;
break;
case BE_PRIORITY:
priv->stats.txbedrop++;
break;
default://BK_PRIORITY
priv->stats.txbkdrop++;
break;
}
printk("To discard skb packet!\n");
dev_kfree_skb_any(skb);
return -1;
}
tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
if(!tx_urb){
dev_kfree_skb_any(skb);
return -ENOMEM;
}
memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
tx_desc->NonQos = (IsQoSDataFrame(skb->data)==TRUE)? 0:1;
/* Fill Tx descriptor */
//memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
// This part can just fill to the first descriptor of the frame.
/* DWORD 0 */
tx_desc->TxHT = (tcb_desc->data_rate&0x80)?1:0;
tx_desc->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
//tx_desc->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
tx_desc->TxShort = QueryIsShort(tx_desc->TxHT, tx_desc->TxRate, tcb_desc);
// Aggregation related
if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
tx_desc->AllowAggregation = 1;
/* DWORD 1 */
//tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
//tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
} else {
tx_desc->AllowAggregation = 0;
/* DWORD 1 */
//tx_fwinfo->RxMF = 0;
//tx_fwinfo->RxAMD = 0;
}
//
// <Roger_Notes> For AMPDU case, we must insert SSN into TX_DESC,
// FW according as this SSN to do necessary packet retry.
// 2008.06.06.
//
{
u8 *pSeq;
u16 Temp;
//pSeq = (u8 *)(VirtualAddress+USB_HWDESC_HEADER_LEN + FRAME_OFFSET_SEQUENCE);
pSeq = (u8 *)(skb->data+USB_HWDESC_HEADER_LEN + 22);
Temp = pSeq[0];
Temp <<= 12;
Temp |= (*(u16 *)pSeq)>>4;
tx_desc->Seq = Temp;
}
/* Protection mode related */
tx_desc->RTSEn = (tcb_desc->bRTSEnable)?1:0;
tx_desc->CTS2Self = (tcb_desc->bCTSEnable)?1:0;
tx_desc->RTSSTBC = (tcb_desc->bRTSSTBC)?1:0;
tx_desc->RTSHT = (tcb_desc->rts_rate&0x80)?1:0;
tx_desc->RTSRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
tx_desc->RTSSubcarrier = (tx_desc->RTSHT==0)?(tcb_desc->RTSSC):0;
tx_desc->RTSBW = (tx_desc->RTSHT==1)?((tcb_desc->bRTSBW)?1:0):0;
tx_desc->RTSShort = (tx_desc->RTSHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
(tcb_desc->bRTSUseShortGI?1:0);
//LZM 090219
tx_desc->DisRTSFB = 0;
tx_desc->RTSRateFBLmt = 0xf;
// <Roger_EXP> 2008.09.22. We disable RTS rate fallback temporarily.
//tx_desc->DisRTSFB = 0x01;
/* Set Bandwidth and sub-channel settings. */
if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
{
if(tcb_desc->bPacketBW) {
tx_desc->TxBandwidth = 1;
tx_desc->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
} else {
tx_desc->TxBandwidth = 0;
tx_desc->TxSubCarrier = priv->nCur40MhzPrimeSC;
}
} else {
tx_desc->TxBandwidth = 0;
tx_desc->TxSubCarrier = 0;
}
//memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
/* DWORD 0 */
tx_desc->LINIP = 0;
//tx_desc->CmdInit = 1; //92su del
tx_desc->Offset = USB_HWDESC_HEADER_LEN;
{
tx_desc->PktSize = (skb->len - USB_HWDESC_HEADER_LEN) & 0xffff;
}
/*DWORD 1*/
//tx_desc->SecCAMID= 0;//92su del
tx_desc->RaBRSRID= tcb_desc->RATRIndex;
//#ifdef RTL8192S_PREPARE_FOR_NORMAL_RELEASE
{
MPDUOverhead = 0;
//tx_desc->NoEnc = 1;//92su del
}
tx_desc->SecType = 0x0;
if (tcb_desc->bHwSec)
{
switch (priv->ieee80211->pairwise_key_type)
{
case KEY_TYPE_WEP40:
case KEY_TYPE_WEP104:
tx_desc->SecType = 0x1;
//tx_desc->NoEnc = 0;//92su del
break;
case KEY_TYPE_TKIP:
tx_desc->SecType = 0x2;
//tx_desc->NoEnc = 0;//92su del
break;
case KEY_TYPE_CCMP:
tx_desc->SecType = 0x3;
//tx_desc->NoEnc = 0;//92su del
break;
case KEY_TYPE_NA:
tx_desc->SecType = 0x0;
//tx_desc->NoEnc = 1;//92su del
break;
default:
tx_desc->SecType = 0x0;
//tx_desc->NoEnc = 1;//92su del
break;
}
}
//tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);//92su del
tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
tx_desc->DataRateFBLmt = 0x1F;// Alwasy enable all rate fallback range
tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
/* Fill fields that are required to be initialized in all of the descriptors */
//DWORD 0
tx_desc->FirstSeg = 1;
tx_desc->LastSeg = 1;
tx_desc->OWN = 1;
{
//DWORD 2
//tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
tx_desc->TxBufferSize = (u32)(skb->len);//92su mod FIXLZM
}
/* Get index to out pipe from specified QueueID */
idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
//printk("=============>%s queue_index:%d, outpipe:%d\n", __func__,tcb_desc->queue_index,priv->RtOutPipes[idx_pipe]);
//RT_DEBUG_DATA(COMP_SEND,tx_fwinfo,sizeof(tx_fwinfo_819x_usb));
//RT_DEBUG_DATA(COMP_SEND,tx_desc,sizeof(tx_desc_819x_usb));
/* To submit bulk urb */
usb_fill_bulk_urb(tx_urb,
udev,
usb_sndbulkpipe(udev,priv->RtOutPipes[idx_pipe]),
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) {
/*
* we need to send 0 byte packet whenever 512N bytes/64N(HIGN SPEED/NORMAL SPEED) bytes packet has been transmitted.
* Otherwise, it will be halt to wait for another packet. WB. 2008.08.27
*/
bool bSend0Byte = false;
u8 zero = 0;
if(udev->speed == USB_SPEED_HIGH) {
if (skb->len > 0 && skb->len % 512 == 0)
bSend0Byte = true;
}
else {
if (skb->len > 0 && skb->len % 64 == 0)
bSend0Byte = true;
}
if (bSend0Byte) {
tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
if(!tx_urb_zero) {
RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
return -ENOMEM;
}
usb_fill_bulk_urb(tx_urb_zero,udev,
usb_sndbulkpipe(udev,idx_pipe), &zero,
0, tx_zero_isr, dev);
status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
switch (status) {
case 0:
break;
case -ECONNRESET:
case -ENOENT:
case -ESHUTDOWN:
break;
default:
RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d",
atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
return -1;
}
}
dev->trans_start = jiffies;
atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
return 0;
} else {
RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
status);
return -1;
}
}
void rtl8192SU_net_update(struct net_device *dev)
{
struct r8192_priv *priv = ieee80211_priv(dev);
struct ieee80211_device* ieee = priv->ieee80211;
struct ieee80211_network *net = &priv->ieee80211->current_network;
//u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
u16 rate_config = 0;
u32 regTmp = 0;
u8 rateIndex = 0;
u8 retrylimit = 0x30;
u16 cap = net->capability;
priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
//HW_VAR_BASIC_RATE
//update Basic rate: RR, BRSR
rtl8192_config_rate(dev, &rate_config); //HalSetBrateCfg
priv->basic_rate = rate_config = rate_config & 0x15f;
// Set RRSR rate table.
write_nic_byte(dev, RRSR, rate_config&0xff);
write_nic_byte(dev, RRSR+1, (rate_config>>8)&0xff);
// Set RTS initial rate
while(rate_config > 0x1)
{
rate_config = (rate_config>> 1);
rateIndex++;
}
write_nic_byte(dev, INIRTSMCS_SEL, rateIndex);
//HW_VAR_BASIC_RATE
//set ack preample
regTmp = (priv->nCur40MhzPrimeSC) << 5;
if (priv->short_preamble)
regTmp |= 0x80;
write_nic_byte(dev, RRSR+2, regTmp);
write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
//2008.10.24 added by tynli for beacon changed.
PHY_SetBeaconHwReg( dev, net->beacon_interval);
rtl8192_update_cap(dev, cap);
if (ieee->iw_mode == IW_MODE_ADHOC){
retrylimit = 7;
//we should enable ibss interrupt here, but disable it temporarily
if (0){
priv->irq_mask |= (IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
//rtl8192_irq_disable(dev);
//rtl8192_irq_enable(dev);
}
}
else{
if (0){
priv->irq_mask &= ~(IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
//rtl8192_irq_disable(dev);
//rtl8192_irq_enable(dev);
}
}
priv->ShortRetryLimit = priv->LongRetryLimit = retrylimit;
write_nic_word(dev, RETRY_LIMIT,
retrylimit << RETRY_LIMIT_SHORT_SHIFT | \
retrylimit << RETRY_LIMIT_LONG_SHIFT);
}
void rtl8192SU_update_ratr_table(struct net_device* dev)
{
struct r8192_priv* priv = ieee80211_priv(dev);
struct ieee80211_device* ieee = priv->ieee80211;
u8* pMcsRate = ieee->dot11HTOperationalRateSet;
//struct ieee80211_network *net = &ieee->current_network;
u32 ratr_value = 0;
u8 rate_index = 0;
int WirelessMode = ieee->mode;
u8 MimoPs = ieee->pHTInfo->PeerMimoPs;
u8 bNMode = 0;
rtl8192_config_rate(dev, (u16*)(&ratr_value));
ratr_value |= (*(u16*)(pMcsRate)) << 12;
//switch (ieee->mode)
switch (WirelessMode)
{
case IEEE_A:
ratr_value &= 0x00000FF0;
break;
case IEEE_B:
ratr_value &= 0x0000000D;
break;
case IEEE_G:
ratr_value &= 0x00000FF5;
break;
case IEEE_N_24G:
case IEEE_N_5G:
{
bNMode = 1;
if (MimoPs == 0) //MIMO_PS_STATIC
{
ratr_value &= 0x0007F005;
}
else
{ // MCS rate only => for 11N mode.
u32 ratr_mask;
// 1T2R or 1T1R, Spatial Stream 2 should be disabled
if ( priv->rf_type == RF_1T2R ||
priv->rf_type == RF_1T1R ||
(ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_TX_2SS) )
ratr_mask = 0x000ff005;
else
ratr_mask = 0x0f0ff005;
if((ieee->pHTInfo->bCurTxBW40MHz) &&
!(ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_TX_40_MHZ))
ratr_mask |= 0x00000010; // Set 6MBps
// Select rates for rate adaptive mechanism.
ratr_value &= ratr_mask;
}
}
break;
default:
if(0)
{
if(priv->rf_type == RF_1T2R) // 1T2R, Spatial Stream 2 should be disabled
{
ratr_value &= 0x000ff0f5;
}
else
{
ratr_value &= 0x0f0ff0f5;
}
}
//printk("====>%s(), mode is not correct:%x\n", __FUNCTION__, ieee->mode);
break;
}
ratr_value &= 0x0FFFFFFF;
// Get MAX MCS available.
if ( (bNMode && ((ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_SHORT_GI)==0)) &&
((ieee->pHTInfo->bCurBW40MHz && ieee->pHTInfo->bCurShortGI40MHz) ||
(!ieee->pHTInfo->bCurBW40MHz && ieee->pHTInfo->bCurShortGI20MHz)))
{
u8 shortGI_rate = 0;
u32 tmp_ratr_value = 0;
ratr_value |= 0x10000000;//???
tmp_ratr_value = (ratr_value>>12);
for(shortGI_rate=15; shortGI_rate>0; shortGI_rate--)
{
if((1<<shortGI_rate) & tmp_ratr_value)
break;
}
shortGI_rate = (shortGI_rate<<12)|(shortGI_rate<<8)|(shortGI_rate<<4)|(shortGI_rate);
write_nic_byte(dev, SG_RATE, shortGI_rate);
//printk("==>SG_RATE:%x\n", read_nic_byte(dev, SG_RATE));
}
write_nic_dword(dev, ARFR0+rate_index*4, ratr_value);
printk("=============>ARFR0+rate_index*4:%#x\n", ratr_value);
//2 UFWP
if (ratr_value & 0xfffff000){
//printk("===>set to N mode\n");
HalSetFwCmd8192S(dev, FW_CMD_RA_REFRESH_N);
}
else {
//printk("===>set to B/G mode\n");
HalSetFwCmd8192S(dev, FW_CMD_RA_REFRESH_BG);
}
}
void rtl8192SU_link_change(struct net_device *dev)
{
struct r8192_priv *priv = ieee80211_priv(dev);
struct ieee80211_device *ieee = priv->ieee80211;
u32 reg = 0;
reg = read_nic_dword(dev, RCR);
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
priv->ReceiveConfig = reg &= ~RCR_CBSSID;
write_nic_dword(dev, RCR, reg);
rtl8192_update_msr(dev);
}
static struct ieee80211_qos_parameters def_qos_parameters = {
{3,3,3,3},/* cw_min */
{7,7,7,7},/* cw_max */
{2,2,2,2},/* aifs */
{0,0,0,0},/* flags */
{0,0,0,0} /* tx_op_limit */
};
void rtl8192_update_beacon(struct work_struct * work)
{
struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
struct net_device *dev = priv->ieee80211->dev;
struct ieee80211_device* ieee = priv->ieee80211;
struct ieee80211_network* net = &ieee->current_network;
if (ieee->pHTInfo->bCurrentHTSupport)
HTUpdateSelfAndPeerSetting(ieee, net);
ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
// Joseph test for turbo mode with AP
ieee->pHTInfo->RT2RT_HT_Mode = net->bssht.RT2RT_HT_Mode;
rtl8192_update_cap(dev, net->capability);
}
/*
* background support to run QoS activate functionality
*/
int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
void rtl8192_qos_activate(struct work_struct * work)
{
struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
struct net_device *dev = priv->ieee80211->dev;
struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
u8 mode = priv->ieee80211->current_network.mode;
//u32 size = sizeof(struct ieee80211_qos_parameters);
u8 u1bAIFS;
u32 u4bAcParam;
int i;
if (priv == NULL)
return;
mutex_lock(&priv->mutex);
if(priv->ieee80211->state != IEEE80211_LINKED)
goto success;
RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
/* It better set slot time at first */
/* For we just support b/g mode at present, let the slot time at 9/20 selection */
/* update the ac parameter to related registers */
for(i = 0; i < QOS_QUEUE_NUM; i++) {
//Mode G/A: slotTimeTimer = 9; Mode B: 20
u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
(((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
(((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
//write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4322);
}
success:
mutex_unlock(&priv->mutex);
}
static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
int active_network,
struct ieee80211_network *network)
{
int ret = 0;
u32 size = sizeof(struct ieee80211_qos_parameters);
if(priv->ieee80211->state !=IEEE80211_LINKED)
return ret;
if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
return ret;
if (network->flags & NETWORK_HAS_QOS_MASK) {
if (active_network &&
(network->flags & NETWORK_HAS_QOS_PARAMETERS))
network->qos_data.active = network->qos_data.supported;
if ((network->qos_data.active == 1) && (active_network == 1) &&
(network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
(network->qos_data.old_param_count !=
network->qos_data.param_count)) {
network->qos_data.old_param_count =
network->qos_data.param_count;
queue_work(priv->priv_wq, &priv->qos_activate);
RT_TRACE (COMP_QOS, "QoS parameters change call "
"qos_activate\n");
}
} else {
memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
&def_qos_parameters, size);
if ((network->qos_data.active == 1) && (active_network == 1)) {
queue_work(priv->priv_wq, &priv->qos_activate);
RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
}
network->qos_data.active = 0;
network->qos_data.supported = 0;
}
return 0;
}
/* handle manage frame frame beacon and probe response */
static int rtl8192_handle_beacon(struct net_device * dev,
struct ieee80211_probe_response *beacon,
struct ieee80211_network *network)
{
struct r8192_priv *priv = ieee80211_priv(dev);
rtl8192_qos_handle_probe_response(priv,1,network);
queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
return 0;
}
/*
* handling the beaconing responses. if we get different QoS setting
* off the network from the associated setting, adjust the QoS
* setting
*/
static int rtl8192_qos_association_resp(struct r8192_priv *priv,
struct ieee80211_network *network)
{
int ret = 0;
unsigned long flags;
u32 size = sizeof(struct ieee80211_qos_parameters);
int set_qos_param = 0;
if ((priv == NULL) || (network == NULL))
return ret;
if(priv->ieee80211->state !=IEEE80211_LINKED)
return ret;
if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
return ret;
spin_lock_irqsave(&priv->ieee80211->lock, flags);
if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
&network->qos_data.parameters,\
sizeof(struct ieee80211_qos_parameters));
priv->ieee80211->current_network.qos_data.active = 1;
{
set_qos_param = 1;
/* update qos parameter for current network */
priv->ieee80211->current_network.qos_data.old_param_count = \
priv->ieee80211->current_network.qos_data.param_count;
priv->ieee80211->current_network.qos_data.param_count = \
network->qos_data.param_count;
}
} else {
memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
&def_qos_parameters, size);
priv->ieee80211->current_network.qos_data.active = 0;
priv->ieee80211->current_network.qos_data.supported = 0;
set_qos_param = 1;
}
spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
if (set_qos_param == 1)
queue_work(priv->priv_wq, &priv->qos_activate);
return ret;
}
static int rtl8192_handle_assoc_response(struct net_device *dev,
struct ieee80211_assoc_response_frame *resp,
struct ieee80211_network *network)
{
struct r8192_priv *priv = ieee80211_priv(dev);
rtl8192_qos_association_resp(priv, network);
return 0;
}
void rtl8192_update_ratr_table(struct net_device* dev)
// POCTET_STRING posLegacyRate,
// u8* pMcsRate)
// PRT_WLAN_STA pEntry)
{
struct r8192_priv* priv = ieee80211_priv(dev);
struct ieee80211_device* ieee = priv->ieee80211;
u8* pMcsRate = ieee->dot11HTOperationalRateSet;
//struct ieee80211_network *net = &ieee->current_network;
u32 ratr_value = 0;
u8 rate_index = 0;
rtl8192_config_rate(dev, (u16*)(&ratr_value));
ratr_value |= (*(u16*)(pMcsRate)) << 12;
// switch (net->mode)
switch (ieee->mode)
{
case IEEE_A:
ratr_value &= 0x00000FF0;
break;
case IEEE_B:
ratr_value &= 0x0000000F;
break;
case IEEE_G:
ratr_value &= 0x00000FF7;
break;
case IEEE_N_24G:
case IEEE_N_5G:
if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
ratr_value &= 0x0007F007;
else{
if (priv->rf_type == RF_1T2R)
ratr_value &= 0x000FF007;
else
ratr_value &= 0x0F81F007;
}
break;
default:
break;
}
ratr_value &= 0x0FFFFFFF;
if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
ratr_value |= 0x80000000;
}else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
ratr_value |= 0x80000000;
}
write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
write_nic_byte(dev, UFWP, 1);
}
static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
bool GetNmodeSupportBySecCfg8192(struct net_device*dev)
{
#if 1
struct r8192_priv* priv = ieee80211_priv(dev);
struct ieee80211_device* ieee = priv->ieee80211;
struct ieee80211_network * network = &ieee->current_network;
int wpa_ie_len= ieee->wpa_ie_len;
struct ieee80211_crypt_data* crypt;
int encrypt;
return TRUE;
crypt = ieee->crypt[ieee->tx_keyidx];
//we use connecting AP's capability instead of only security config on our driver to distinguish whether it should use N mode or G mode
encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
/* simply judge */
if(encrypt && (wpa_ie_len == 0)) {
/* wep encryption, no N mode setting */
return false;
// } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
} else if((wpa_ie_len != 0)) {
/* parse pairwise key type */
//if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
if (((ieee->wpa_ie[0] == 0xdd) && (!memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) || ((ieee->wpa_ie[0] == 0x30) && (!memcmp(&ieee->wpa_ie[10],ccmp_rsn_ie, 4))))
return true;
else
return false;
} else {
return true;
}
return true;
#endif
}
bool GetHalfNmodeSupportByAPs819xUsb(struct net_device* dev)
{
bool Reval;
struct r8192_priv* priv = ieee80211_priv(dev);
struct ieee80211_device* ieee = priv->ieee80211;
// Added by Roger, 2008.08.29.
return false;
if(ieee->bHalfWirelessN24GMode == true)
Reval = true;
else
Reval = false;
return Reval;
}
void rtl8192_refresh_supportrate(struct r8192_priv* priv)
{
struct ieee80211_device* ieee = priv->ieee80211;
//we donot consider set support rate for ABG mode, only HT MCS rate is set here.
if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
{
memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
//RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
//RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
}
else
memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
return;
}
u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
{
struct r8192_priv *priv = ieee80211_priv(dev);
u8 ret = 0;
switch(priv->rf_chip)
{
case RF_8225:
case RF_8256:
case RF_PSEUDO_11N:
case RF_6052:
ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
break;
case RF_8258:
ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
break;
default:
ret = WIRELESS_MODE_B;
break;
}
return ret;
}
void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
{
struct r8192_priv *priv = ieee80211_priv(dev);
u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
#if 1
if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
{
if(bSupportMode & WIRELESS_MODE_N_24G)
{
wireless_mode = WIRELESS_MODE_N_24G;
}
else if(bSupportMode & WIRELESS_MODE_N_5G)
{
wireless_mode = WIRELESS_MODE_N_5G;
}
else if((bSupportMode & WIRELESS_MODE_A))
{
wireless_mode = WIRELESS_MODE_A;
}
else if((bSupportMode & WIRELESS_MODE_G))
{
wireless_mode = WIRELESS_MODE_G;