Google Git
Sign in
gfiber / kernel / windcharger / d95f9bd73fd3a4ebabf7c524941f6b6095388c55 / . / drivers / staging / rtl8187se / r8180_core.c
blob: 7e2fecae813c066b44ac01c1f1f4f2c7f05fa9d9 [file] [log] [blame]
/*
This is part of rtl818x pci OpenSource driver - v 0.1
Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it>
Released under the terms of GPL (General Public License)
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.
Parts of BB/RF code are derived from David Young rtl8180 netbsd driver.
RSSI calc function from 'The Deuce'
Some ideas borrowed from the 8139too.c driver included in linux kernel.
We (I?) want to thanks the Authors of those projecs and also the
Ndiswrapper's project Authors.
A big big thanks goes also to Realtek corp. for their help in my attempt to
add RTL8185 and RTL8225 support, and to David Young also.
*/
#if 0
double __floatsidf (int i) { return i; }
unsigned int __fixunsdfsi (double d) { return d; }
double __adddf3(double a, double b) { return a+b; }
double __addsf3(float a, float b) { return a+b; }
double __subdf3(double a, double b) { return a-b; }
double __extendsfdf2(float a) {return a;}
#endif
#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 DEBUG_TX
//#define DEBUG_TX_DESC2
//#define DEBUG_RX
//#define DEBUG_RX_SKB
//#define CONFIG_RTL8180_IO_MAP
#include <linux/syscalls.h>
//#include <linux/fcntl.h>
//#include <asm/uaccess.h>
#include "r8180_hw.h"
#include "r8180.h"
#include "r8180_sa2400.h" /* PHILIPS Radio frontend */
#include "r8180_max2820.h" /* MAXIM Radio frontend */
#include "r8180_gct.h" /* GCT Radio frontend */
#include "r8180_rtl8225.h" /* RTL8225 Radio frontend */
#include "r8180_rtl8255.h" /* RTL8255 Radio frontend */
#include "r8180_93cx6.h" /* Card EEPROM */
#include "r8180_wx.h"
#include "r8180_dm.h"
#ifdef CONFIG_RTL8180_PM
#include "r8180_pm.h"
#endif
#ifdef ENABLE_DOT11D
#include "dot11d.h"
#endif
#ifdef CONFIG_RTL8185B
//#define CONFIG_RTL8180_IO_MAP
#endif
#ifndef PCI_VENDOR_ID_BELKIN
#define PCI_VENDOR_ID_BELKIN 0x1799
#endif
#ifndef PCI_VENDOR_ID_DLINK
#define PCI_VENDOR_ID_DLINK 0x1186
#endif
static struct pci_device_id rtl8180_pci_id_tbl[] __devinitdata = {
{
.vendor = PCI_VENDOR_ID_REALTEK,
// .device = 0x8180,
.device = 0x8199,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = 0,
},
#if 0
{
.vendor = PCI_VENDOR_ID_BELKIN,
.device = 0x6001,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = 1,
},
{ /* Belkin F5D6020 v3 */
.vendor = PCI_VENDOR_ID_BELKIN,
.device = 0x6020,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = 2,
},
{ /* D-Link DWL-610 */
.vendor = PCI_VENDOR_ID_DLINK,
.device = 0x3300,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = 3,
},
{
.vendor = PCI_VENDOR_ID_REALTEK,
.device = 0x8185,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = 4,
},
#endif
{
.vendor = 0,
.device = 0,
.subvendor = 0,
.subdevice = 0,
.driver_data = 0,
}
};
static char* ifname = "wlan%d";
static int hwseqnum = 0;
//static char* ifname = "ath%d";
static int hwwep = 0;
static int channels = 0x3fff;
#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 cpMacAddr(des,src) ((des)[0]=(src)[0],(des)[1]=(src)[1],(des)[2]=(src)[2],(des)[3]=(src)[3],(des)[4]=(src)[4],(des)[5]=(src)[5])
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, rtl8180_pci_id_tbl);
MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
MODULE_DESCRIPTION("Linux driver for Realtek RTL8180 / RTL8185 WiFi cards");
/*
MODULE_PARM(ifname, "s");
MODULE_PARM_DESC(devname," Net interface name, wlan%d=default");
MODULE_PARM(hwseqnum,"i");
MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
MODULE_PARM(hwwep,"i");
MODULE_PARM_DESC(hwwep," Try to use hardware WEP support. Still broken and not available on all cards");
MODULE_PARM(channels,"i");
MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
*/
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 9)
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);
#else
MODULE_PARM(ifname, "s");
MODULE_PARM(hwseqnum,"i");
MODULE_PARM(hwwep,"i");
MODULE_PARM(channels,"i");
#endif
MODULE_PARM_DESC(devname," Net interface name, wlan%d=default");
//MODULE_PARM_DESC(devname," Net interface name, ath%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 WEP support. Still broken and not available on all cards");
MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
static int __devinit rtl8180_pci_probe(struct pci_dev *pdev,
const struct pci_device_id *id);
static void __devexit rtl8180_pci_remove(struct pci_dev *pdev);
static void rtl8180_shutdown (struct pci_dev *pdev)
{
struct net_device *dev = pci_get_drvdata(pdev);
if (dev->netdev_ops->ndo_stop)
dev->netdev_ops->ndo_stop(dev);
pci_disable_device(pdev);
}
static struct pci_driver rtl8180_pci_driver = {
.name = RTL8180_MODULE_NAME, /* Driver name */
.id_table = rtl8180_pci_id_tbl, /* PCI_ID table */
.probe = rtl8180_pci_probe, /* probe fn */
.remove = __devexit_p(rtl8180_pci_remove),/* remove fn */
#ifdef CONFIG_RTL8180_PM
.suspend = rtl8180_suspend, /* PM suspend fn */
.resume = rtl8180_resume, /* PM resume fn */
#else
.suspend = NULL, /* PM suspend fn */
.resume = NULL, /* PM resume fn */
#endif
.shutdown = rtl8180_shutdown,
};
#ifdef CONFIG_RTL8180_IO_MAP
u8 read_nic_byte(struct net_device *dev, int x)
{
return 0xff&inb(dev->base_addr +x);
}
u32 read_nic_dword(struct net_device *dev, int x)
{
return inl(dev->base_addr +x);
}
u16 read_nic_word(struct net_device *dev, int x)
{
return inw(dev->base_addr +x);
}
void write_nic_byte(struct net_device *dev, int x,u8 y)
{
outb(y&0xff,dev->base_addr +x);
}
void write_nic_word(struct net_device *dev, int x,u16 y)
{
outw(y,dev->base_addr +x);
}
void write_nic_dword(struct net_device *dev, int x,u32 y)
{
outl(y,dev->base_addr +x);
}
#else /* RTL_IO_MAP */
u8 read_nic_byte(struct net_device *dev, int x)
{
return 0xff&readb((u8*)dev->mem_start +x);
}
u32 read_nic_dword(struct net_device *dev, int x)
{
return readl((u8*)dev->mem_start +x);
}
u16 read_nic_word(struct net_device *dev, int x)
{
return readw((u8*)dev->mem_start +x);
}
void write_nic_byte(struct net_device *dev, int x,u8 y)
{
writeb(y,(u8*)dev->mem_start +x);
udelay(20);
}
void write_nic_dword(struct net_device *dev, int x,u32 y)
{
writel(y,(u8*)dev->mem_start +x);
udelay(20);
}
void write_nic_word(struct net_device *dev, int x,u16 y)
{
writew(y,(u8*)dev->mem_start +x);
udelay(20);
}
#endif /* RTL_IO_MAP */
inline void force_pci_posting(struct net_device *dev)
{
read_nic_byte(dev,EPROM_CMD);
#ifndef CONFIG_RTL8180_IO_MAP
mb();
#endif
}
irqreturn_t rtl8180_interrupt(int irq, void *netdev, struct pt_regs *regs);
void set_nic_rxring(struct net_device *dev);
void set_nic_txring(struct net_device *dev);
static struct net_device_stats *rtl8180_stats(struct net_device *dev);
void rtl8180_commit(struct net_device *dev);
void rtl8180_start_tx_beacon(struct net_device *dev);
/****************************************************************************
-----------------------------PROCFS STUFF-------------------------
*****************************************************************************/
static struct proc_dir_entry *rtl8180_proc = NULL;
static int proc_get_registers(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
// struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
int len = 0;
int i,n;
int max=0xff;
/* This dump the current register page */
for(n=0;n<=max;)
{
//printk( "\nD: %2x> ", n);
len += snprintf(page + len, count - len,
"\nD: %2x > ",n);
for(i=0;i<16 && n<=max;i++,n++)
len += snprintf(page + len, count - len,
"%2x ",read_nic_byte(dev,n));
// printk("%2x ",read_nic_byte(dev,n));
}
len += snprintf(page + len, count - len,"\n");
*eof = 1;
return len;
}
int get_curr_tx_free_desc(struct net_device *dev, int priority);
static int proc_get_stats_hw(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
//struct net_device *dev = data;
//struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
int len = 0;
#ifdef CONFIG_RTL8185B
#else
len += snprintf(page + len, count - len,
"NIC int: %lu\n"
"Total int: %lu\n"
"--------------------\n"
"LP avail desc %d\n"
"NP avail desc %d\n"
"--------------------\n"
"LP phys dma addr %x\n"
"LP NIC ptr %x\n"
"LP virt 32base %x\n"
"LP virt 32tail %x\n"
"--------------------\n"
"NP phys dma addr %x\n"
"NP NIC ptr %x\n"
"NP virt 32base %x\n"
"NP virt 32tail %x\n"
"--------------------\n"
"BP phys dma addr %x\n"
"BP NIC ptr %x\n"
"BP virt 32base %x\n"
"BP virt 32tail %x\n",
priv->stats.ints,
priv->stats.shints,
get_curr_tx_free_desc(dev,LOW_PRIORITY),
get_curr_tx_free_desc(dev,NORM_PRIORITY),
(u32)priv->txvipringdma,
read_nic_dword(dev,TLPDA),
(u32)priv->txvipring,
(u32)priv->txvipringtail,
(u32)priv->txvopringdma,
read_nic_dword(dev,TNPDA),
(u32)priv->txvopring,
(u32)priv->txvopringtail,
(u32)priv->txbeaconringdma,
read_nic_dword(dev,TBDA),
(u32)priv->txbeaconring,
(u32)priv->txbeaconringtail);
#endif
*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 r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
int len = 0;
len += snprintf(page + len, count - len,
/* "RX descriptor not available: %lu\n"
"RX incomplete (missing last descriptor): %lu\n"
"RX not data: %lu\n"
//"RX descriptor pointer reset: %lu\n"
"RX descriptor pointer lost: %lu\n"
//"RX pointer workaround: %lu\n"
"RX error int: %lu\n"
"RX fifo overflow: %lu\n"
"RX int: %lu\n"
"RX packet: %lu\n"
"RX bytes: %lu\n"
"RX DMA fail: %lu\n",
priv->stats.rxrdu,
priv->stats.rxnolast,
priv->stats.rxnodata,
//priv->stats.rxreset,
priv->stats.rxnopointer,
//priv->stats.rxwrkaround,
priv->stats.rxerr,
priv->stats.rxoverflow,
priv->stats.rxint,
priv->ieee80211->stats.rx_packets,
priv->ieee80211->stats.rx_bytes,
priv->stats.rxdmafail */
"RX OK: %lu\n"
"RX Retry: %lu\n"
"RX CRC Error(0-500): %lu\n"
"RX CRC Error(500-1000): %lu\n"
"RX CRC Error(>1000): %lu\n"
"RX ICV Error: %lu\n",
priv->stats.rxint,
priv->stats.rxerr,
priv->stats.rxcrcerrmin,
priv->stats.rxcrcerrmid,
priv->stats.rxcrcerrmax,
priv->stats.rxicverr
);
*eof = 1;
return len;
}
#if 0
static int proc_get_stats_ieee(char *page, char **start,
off_t offset, int count,
int *eof, void *data)
{
struct net_device *dev = data;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
int len = 0;
len += snprintf(page + len, count - len,
"TXed association requests: %u\n"
"TXed authentication requests: %u\n"
"RXed successful association response: %u\n"
"RXed failed association response: %u\n"
"RXed successful authentication response: %u\n"
"RXed failed authentication response: %u\n"
"Association requests without response: %u\n"
"Authentication requests without response: %u\n"
"TX probe response: %u\n"
"RX probe request: %u\n"
"TX probe request: %lu\n"
"RX authentication requests: %lu\n"
"RX association requests: %lu\n"
"Reassociations: %lu\n",
priv->ieee80211->ieee_stats.tx_ass,
priv->ieee80211->ieee_stats.tx_aut,
priv->ieee80211->ieee_stats.rx_ass_ok,
priv->ieee80211->ieee_stats.rx_ass_err,
priv->ieee80211->ieee_stats.rx_aut_ok,
priv->ieee80211->ieee_stats.rx_aut_err,
priv->ieee80211->ieee_stats.ass_noresp,
priv->ieee80211->ieee_stats.aut_noresp,
priv->ieee80211->ieee_stats.tx_probe,
priv->ieee80211->ieee_stats.rx_probe,
priv->ieee80211->ieee_stats.tx_probe_rq,
priv->ieee80211->ieee_stats.rx_auth_rq,
priv->ieee80211->ieee_stats.rx_assoc_rq,
priv->ieee80211->ieee_stats.reassoc);
*eof = 1;
return len;
}
#endif
#if 0
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 r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct mac_htable_t *list;
int i;
int len = 0;
if(priv->ieee80211->iw_mode != IW_MODE_MASTER){
len += snprintf(page + len, count - len,
"Card is not acting as AP...\n"
);
}else{
len += snprintf(page + len, count - len,
"List of associated STA:\n"
);
for(i=0;i<MAC_HTABLE_ENTRY;i++)
for (list = priv->ieee80211->assoc_htable[i]; list!=NULL; list = list->next){
len += snprintf(page + len, count - len,
MACSTR"\n",MAC2STR(list->adr));
}
}
*eof = 1;
return len;
}
#endif
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 r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
int len = 0;
unsigned long totalOK;
totalOK=priv->stats.txnpokint+priv->stats.txhpokint+priv->stats.txlpokint;
len += snprintf(page + len, count - len,
/* "TX normal priority ok int: %lu\n"
"TX normal priority error int: %lu\n"
"TX high priority ok int: %lu\n"
"TX high priority failed error int: %lu\n"
"TX low priority ok int: %lu\n"
"TX low priority failed error int: %lu\n"
"TX bytes: %lu\n"
"TX packets: %lu\n"
"TX queue resume: %lu\n"
"TX queue stopped?: %d\n"
"TX fifo overflow: %lu\n"
//"SW TX stop: %lu\n"
//"SW TX wake: %lu\n"
"TX beacon: %lu\n"
"TX beacon aborted: %lu\n",
priv->stats.txnpokint,
priv->stats.txnperr,
priv->stats.txhpokint,
priv->stats.txhperr,
priv->stats.txlpokint,
priv->stats.txlperr,
priv->ieee80211->stats.tx_bytes,
priv->ieee80211->stats.tx_packets,
priv->stats.txresumed,
netif_queue_stopped(dev),
priv->stats.txoverflow,
//priv->ieee80211->ieee_stats.swtxstop,
//priv->ieee80211->ieee_stats.swtxawake,
priv->stats.txbeacon,
priv->stats.txbeaconerr */
"TX OK: %lu\n"
"TX Error: %lu\n"
"TX Retry: %lu\n"
"TX beacon OK: %lu\n"
"TX beacon error: %lu\n",
totalOK,
priv->stats.txnperr+priv->stats.txhperr+priv->stats.txlperr,
priv->stats.txretry,
priv->stats.txbeacon,
priv->stats.txbeaconerr
);
*eof = 1;
return len;
}
#if WIRELESS_EXT < 17
static struct iw_statistics *r8180_get_wireless_stats(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
return &priv->wstats;
}
#endif
void rtl8180_proc_module_init(void)
{
DMESG("Initializing proc filesystem");
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
rtl8180_proc=create_proc_entry(RTL8180_MODULE_NAME, S_IFDIR, proc_net);
#else
rtl8180_proc=create_proc_entry(RTL8180_MODULE_NAME, S_IFDIR, init_net.proc_net);
#endif
}
void rtl8180_proc_module_remove(void)
{
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
remove_proc_entry(RTL8180_MODULE_NAME, proc_net);
#else
remove_proc_entry(RTL8180_MODULE_NAME, init_net.proc_net);
#endif
}
void rtl8180_proc_remove_one(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_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(dev->name, rtl8180_proc);
priv->dir_dev = NULL;
}
}
void rtl8180_proc_init_one(struct net_device *dev)
{
struct proc_dir_entry *e;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
priv->dir_dev = rtl8180_proc;
if (!priv->dir_dev) {
DMESGE("Unable to initialize /proc/net/r8180/%s\n",
dev->name);
return;
}
e = create_proc_read_entry("stats-hw", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_stats_hw, dev);
if (!e) {
DMESGE("Unable to initialize "
"/proc/net/r8180/%s/stats-hw\n",
dev->name);
}
e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_stats_rx, dev);
if (!e) {
DMESGE("Unable to initialize "
"/proc/net/r8180/%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) {
DMESGE("Unable to initialize "
"/proc/net/r8180/%s/stats-tx\n",
dev->name);
}
#if 0
e = create_proc_read_entry("stats-ieee", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_stats_ieee, dev);
if (!e) {
DMESGE("Unable to initialize "
"/proc/net/rtl8180/%s/stats-ieee\n",
dev->name);
}
#endif
#if 0
e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_stats_ap, dev);
if (!e) {
DMESGE("Unable to initialize "
"/proc/net/rtl8180/%s/stats-ap\n",
dev->name);
}
#endif
e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
priv->dir_dev, proc_get_registers, dev);
if (!e) {
DMESGE("Unable to initialize "
"/proc/net/r8180/%s/registers\n",
dev->name);
}
}
/****************************************************************************
-----------------------------MISC STUFF-------------------------
*****************************************************************************/
/*
FIXME: check if we can use some standard already-existent
data type+functions in kernel
*/
short buffer_add(struct buffer **buffer, u32 *buf, dma_addr_t dma,
struct buffer **bufferhead)
{
#ifdef DEBUG_RING
DMESG("adding buffer to TX/RX struct");
#endif
struct buffer *tmp;
if(! *buffer){
*buffer = kmalloc(sizeof(struct buffer),GFP_KERNEL);
if (*buffer == NULL) {
DMESGE("Failed to kmalloc head of TX/RX struct");
return -1;
}
(*buffer)->next=*buffer;
(*buffer)->buf=buf;
(*buffer)->dma=dma;
if(bufferhead !=NULL)
(*bufferhead) = (*buffer);
return 0;
}
tmp=*buffer;
while(tmp->next!=(*buffer)) tmp=tmp->next;
if ((tmp->next= kmalloc(sizeof(struct buffer),GFP_KERNEL)) == NULL){
DMESGE("Failed to kmalloc TX/RX struct");
return -1;
}
tmp->next->buf=buf;
tmp->next->dma=dma;
tmp->next->next=*buffer;
return 0;
}
void buffer_free(struct net_device *dev,struct buffer **buffer,int len,short
consistent)
{
struct buffer *tmp,*next;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct pci_dev *pdev=priv->pdev;
//int i;
if(! *buffer) return;
/*for(tmp=*buffer; tmp->next != *buffer; tmp=tmp->next)
*/
tmp=*buffer;
do{
next=tmp->next;
if(consistent){
pci_free_consistent(pdev,len,
tmp->buf,tmp->dma);
}else{
pci_unmap_single(pdev, tmp->dma,
len,PCI_DMA_FROMDEVICE);
kfree(tmp->buf);
}
kfree(tmp);
tmp = next;
}
while(next != *buffer);
*buffer=NULL;
}
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("%02x",buf[i]);
printk("\n");
}
int get_curr_tx_free_desc(struct net_device *dev, int priority)
{
struct r8180_priv *priv = ieee80211_priv(dev);
u32* tail;
u32* head;
int ret;
switch (priority){
case MANAGE_PRIORITY:
head = priv->txmapringhead;
tail = priv->txmapringtail;
break;
case BK_PRIORITY:
head = priv->txbkpringhead;
tail = priv->txbkpringtail;
break;
case BE_PRIORITY:
head = priv->txbepringhead;
tail = priv->txbepringtail;
break;
case VI_PRIORITY:
head = priv->txvipringhead;
tail = priv->txvipringtail;
break;
case VO_PRIORITY:
head = priv->txvopringhead;
tail = priv->txvopringtail;
break;
case HI_PRIORITY:
head = priv->txhpringhead;
tail = priv->txhpringtail;
break;
default:
return -1;
}
//DMESG("%x %x", head, tail);
/* FIXME FIXME FIXME FIXME */
#if 0
if( head <= tail ) return priv->txringcount-1 - (tail - head)/8;
return (head - tail)/8/4;
#else
if( head <= tail )
ret = priv->txringcount - (tail - head)/8;
else
ret = (head - tail)/8;
if(ret > priv->txringcount ) DMESG("BUG");
return ret;
#endif
}
short check_nic_enought_desc(struct net_device *dev, int priority)
{
struct r8180_priv *priv = ieee80211_priv(dev);
struct ieee80211_device *ieee = netdev_priv(dev);
int requiredbyte, required;
requiredbyte = priv->ieee80211->fts + sizeof(struct ieee80211_header_data);
if(ieee->current_network.QoS_Enable) {
requiredbyte += 2;
};
required = requiredbyte / (priv->txbuffsize-4);
if (requiredbyte % priv->txbuffsize) required++;
/* for now we keep two free descriptor as a safety boundary
* between the tail and the head
*/
return (required+2 < get_curr_tx_free_desc(dev,priority));
}
/* This function is only for debuging purpose */
void check_tx_ring(struct net_device *dev, int pri)
{
static int maxlog =3;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
u32* tmp;
struct buffer *buf;
int i;
int nic;
u32* tail;
u32* head;
u32* begin;
u32 nicbegin;
struct buffer* buffer;
maxlog --;
if (maxlog <0 ) return;
switch(pri) {
case MANAGE_PRIORITY:
tail = priv->txmapringtail;
begin = priv->txmapring;
head = priv->txmapringhead;
nic = read_nic_dword(dev,TX_MANAGEPRIORITY_RING_ADDR);
buffer = priv->txmapbufs;
nicbegin = priv->txmapringdma;
break;
case BK_PRIORITY:
tail = priv->txbkpringtail;
begin = priv->txbkpring;
head = priv->txbkpringhead;
nic = read_nic_dword(dev,TX_BKPRIORITY_RING_ADDR);
buffer = priv->txbkpbufs;
nicbegin = priv->txbkpringdma;
break;
case BE_PRIORITY:
tail = priv->txbepringtail;
begin = priv->txbepring;
head = priv->txbepringhead;
nic = read_nic_dword(dev,TX_BEPRIORITY_RING_ADDR);
buffer = priv->txbepbufs;
nicbegin = priv->txbepringdma;
break;
case VI_PRIORITY:
tail = priv->txvipringtail;
begin = priv->txvipring;
head = priv->txvipringhead;
nic = read_nic_dword(dev,TX_VIPRIORITY_RING_ADDR);
buffer = priv->txvipbufs;
nicbegin = priv->txvipringdma;
break;
case VO_PRIORITY:
tail = priv->txvopringtail;
begin = priv->txvopring;
head = priv->txvopringhead;
nic = read_nic_dword(dev,TX_VOPRIORITY_RING_ADDR);
buffer = priv->txvopbufs;
nicbegin = priv->txvopringdma;
break;
case HI_PRIORITY:
tail = priv->txhpringtail;
begin = priv->txhpring;
head = priv->txhpringhead;
nic = read_nic_dword(dev,TX_HIGHPRIORITY_RING_ADDR);
buffer = priv->txhpbufs;
nicbegin = priv->txhpringdma;
break;
default:
return ;
break;
}
if(!priv->txvopbufs)
DMESGE ("NIC TX ack, but TX queue corrupted!");
else{
for(i=0,buf=buffer, tmp=begin;
tmp<begin+(priv->txringcount)*8;
tmp+=8,buf=buf->next,i++)
DMESG("BUF%d %s %x %s. Next : %x",i,
*tmp & (1<<31) ? "filled" : "empty",
*(buf->buf),
*tmp & (1<<15)? "ok": "err", *(tmp+4));
}
return;
}
/* this function is only for debugging purpose */
void check_rxbuf(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
u32* tmp;
struct buffer *buf;
u8 rx_desc_size;
#ifdef CONFIG_RTL8185B
rx_desc_size = 8;
#else
rx_desc_size = 4;
#endif
if(!priv->rxbuffer)
DMESGE ("NIC RX ack, but RX queue corrupted!");
else{
for(buf=priv->rxbuffer, tmp=priv->rxring;
tmp < priv->rxring+(priv->rxringcount)*rx_desc_size;
tmp+=rx_desc_size, buf=buf->next)
DMESG("BUF %s %x",
*tmp & (1<<31) ? "empty" : "filled",
*(buf->buf));
}
return;
}
void dump_eprom(struct net_device *dev)
{
int i;
for(i=0; i<63; i++)
DMESG("EEPROM addr %x : %x", i, eprom_read(dev,i));
}
void rtl8180_dump_reg(struct net_device *dev)
{
int i;
int n;
int max=0xff;
DMESG("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");
}
void fix_tx_fifo(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
u32 *tmp;
int i;
#ifdef DEBUG_TX_ALLOC
DMESG("FIXING TX FIFOs");
#endif
for (tmp=priv->txmapring, i=0;
i < priv->txringcount;
tmp+=8, i++){
*tmp = *tmp &~ (1<<31);
}
for (tmp=priv->txbkpring, i=0;
i < priv->txringcount;
tmp+=8, i++) {
*tmp = *tmp &~ (1<<31);
}
for (tmp=priv->txbepring, i=0;
i < priv->txringcount;
tmp+=8, i++){
*tmp = *tmp &~ (1<<31);
}
for (tmp=priv->txvipring, i=0;
i < priv->txringcount;
tmp+=8, i++) {
*tmp = *tmp &~ (1<<31);
}
for (tmp=priv->txvopring, i=0;
i < priv->txringcount;
tmp+=8, i++){
*tmp = *tmp &~ (1<<31);
}
for (tmp=priv->txhpring, i=0;
i < priv->txringcount;
tmp+=8,i++){
*tmp = *tmp &~ (1<<31);
}
for (tmp=priv->txbeaconring, i=0;
i < priv->txbeaconcount;
tmp+=8, i++){
*tmp = *tmp &~ (1<<31);
}
#ifdef DEBUG_TX_ALLOC
DMESG("TX FIFOs FIXED");
#endif
priv->txmapringtail = priv->txmapring;
priv->txmapringhead = priv->txmapring;
priv->txmapbufstail = priv->txmapbufs;
priv->txbkpringtail = priv->txbkpring;
priv->txbkpringhead = priv->txbkpring;
priv->txbkpbufstail = priv->txbkpbufs;
priv->txbepringtail = priv->txbepring;
priv->txbepringhead = priv->txbepring;
priv->txbepbufstail = priv->txbepbufs;
priv->txvipringtail = priv->txvipring;
priv->txvipringhead = priv->txvipring;
priv->txvipbufstail = priv->txvipbufs;
priv->txvopringtail = priv->txvopring;
priv->txvopringhead = priv->txvopring;
priv->txvopbufstail = priv->txvopbufs;
priv->txhpringtail = priv->txhpring;
priv->txhpringhead = priv->txhpring;
priv->txhpbufstail = priv->txhpbufs;
priv->txbeaconringtail = priv->txbeaconring;
priv->txbeaconbufstail = priv->txbeaconbufs;
set_nic_txring(dev);
ieee80211_reset_queue(priv->ieee80211);
priv->ack_tx_to_ieee = 0;
}
void fix_rx_fifo(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
u32 *tmp;
struct buffer *rxbuf;
u8 rx_desc_size;
#ifdef CONFIG_RTL8185B
rx_desc_size = 8; // 4*8 = 32 bytes
#else
rx_desc_size = 4;
#endif
#ifdef DEBUG_RXALLOC
DMESG("FIXING RX FIFO");
check_rxbuf(dev);
#endif
for (tmp=priv->rxring, rxbuf=priv->rxbufferhead;
(tmp < (priv->rxring)+(priv->rxringcount)*rx_desc_size);
tmp+=rx_desc_size,rxbuf=rxbuf->next){
*(tmp+2) = rxbuf->dma;
*tmp=*tmp &~ 0xfff;
*tmp=*tmp | priv->rxbuffersize;
*tmp |= (1<<31);
}
#ifdef DEBUG_RXALLOC
DMESG("RX FIFO FIXED");
check_rxbuf(dev);
#endif
priv->rxringtail=priv->rxring;
priv->rxbuffer=priv->rxbufferhead;
priv->rx_skb_complete=1;
set_nic_rxring(dev);
}
/****************************************************************************
------------------------------HW STUFF---------------------------
*****************************************************************************/
unsigned char QUALITY_MAP[] = {
0x64, 0x64, 0x64, 0x63, 0x63, 0x62, 0x62, 0x61,
0x61, 0x60, 0x60, 0x5f, 0x5f, 0x5e, 0x5d, 0x5c,
0x5b, 0x5a, 0x59, 0x57, 0x56, 0x54, 0x52, 0x4f,
0x4c, 0x49, 0x45, 0x41, 0x3c, 0x37, 0x31, 0x29,
0x24, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
0x22, 0x22, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20,
0x20, 0x20, 0x20, 0x1f, 0x1f, 0x1e, 0x1e, 0x1e,
0x1d, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a, 0x19, 0x19,
0x18, 0x17, 0x16, 0x15, 0x14, 0x12, 0x11, 0x0f,
0x0e, 0x0c, 0x0a, 0x08, 0x06, 0x04, 0x01, 0x00
};
unsigned char STRENGTH_MAP[] = {
0x64, 0x64, 0x63, 0x62, 0x61, 0x60, 0x5f, 0x5e,
0x5d, 0x5c, 0x5b, 0x5a, 0x57, 0x54, 0x52, 0x50,
0x4e, 0x4c, 0x4a, 0x48, 0x46, 0x44, 0x41, 0x3f,
0x3c, 0x3a, 0x37, 0x36, 0x36, 0x1c, 0x1c, 0x1b,
0x1b, 0x1a, 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17,
0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13,
0x13, 0x12, 0x12, 0x11, 0x11, 0x10, 0x10, 0x0f,
0x0f, 0x0e, 0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0b,
0x0b, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x07,
0x07, 0x06, 0x06, 0x05, 0x04, 0x03, 0x02, 0x00
};
void rtl8180_RSSI_calc(struct net_device *dev, u8 *rssi, u8 *qual){
//void Mlme_UpdateRssiSQ(struct net_device *dev, u8 *rssi, u8 *qual){
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
u32 temp;
u32 temp2;
u32 temp3;
u32 lsb;
u32 q;
u32 orig_qual;
u8 _rssi;
q = *qual;
orig_qual = *qual;
_rssi = 0; // avoid gcc complains..
if (q <= 0x4e) {
temp = QUALITY_MAP[q];
} else {
if( q & 0x80 ) {
temp = 0x32;
} else {
temp = 1;
}
}
*qual = temp;
temp2 = *rssi;
switch(priv->rf_chip){
case RFCHIPID_RFMD:
lsb = temp2 & 1;
temp2 &= 0x7e;
if ( !lsb || !(temp2 <= 0x3c) ) {
temp2 = 0x64;
} else {
temp2 = 100 * temp2 / 0x3c;
}
*rssi = temp2 & 0xff;
_rssi = temp2 & 0xff;
break;
case RFCHIPID_INTERSIL:
lsb = temp2;
temp2 &= 0xfffffffe;
temp2 *= 251;
temp3 = temp2;
temp2 <<= 6;
temp3 += temp2;
temp3 <<= 1;
temp2 = 0x4950df;
temp2 -= temp3;
lsb &= 1;
if ( temp2 <= 0x3e0000 ) {
if ( temp2 < 0xffef0000 )
temp2 = 0xffef0000;
} else {
temp2 = 0x3e0000;
}
if ( !lsb ) {
temp2 -= 0xf0000;
} else {
temp2 += 0xf0000;
}
temp3 = 0x4d0000;
temp3 -= temp2;
temp3 *= 100;
temp3 = temp3 / 0x6d;
temp3 >>= 0x10;
_rssi = temp3 & 0xff;
*rssi = temp3 & 0xff;
break;
case RFCHIPID_GCT:
lsb = temp2 & 1;
temp2 &= 0x7e;
if ( ! lsb || !(temp2 <= 0x3c) ){
temp2 = 0x64;
} else {
temp2 = (100 * temp2) / 0x3c;
}
*rssi = temp2 & 0xff;
_rssi = temp2 & 0xff;
break;
case RFCHIPID_PHILIPS:
if( orig_qual <= 0x4e ){
_rssi = STRENGTH_MAP[orig_qual];
*rssi = _rssi;
} else {
orig_qual -= 0x80;
if ( !orig_qual ){
_rssi = 1;
*rssi = 1;
} else {
_rssi = 0x32;
*rssi = 0x32;
}
}
break;
/* case 4 */
case RFCHIPID_MAXIM:
lsb = temp2 & 1;
temp2 &= 0x7e;
temp2 >>= 1;
temp2 += 0x42;
if( lsb != 0 ){
temp2 += 0xa;
}
*rssi = temp2 & 0xff;
_rssi = temp2 & 0xff;
break;
}
if ( _rssi < 0x64 ){
if ( _rssi == 0 ) {
*rssi = 1;
}
} else {
*rssi = 0x64;
}
return;
}
void rtl8180_irq_enable(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
priv->irq_enabled = 1;
/*
write_nic_word(dev,INTA_MASK,INTA_RXOK | INTA_RXDESCERR | INTA_RXOVERFLOW |\
INTA_TXOVERFLOW | INTA_HIPRIORITYDESCERR | INTA_HIPRIORITYDESCOK |\
INTA_NORMPRIORITYDESCERR | INTA_NORMPRIORITYDESCOK |\
INTA_LOWPRIORITYDESCERR | INTA_LOWPRIORITYDESCOK | INTA_TIMEOUT);
*/
write_nic_word(dev,INTA_MASK, priv->irq_mask);
}
void rtl8180_irq_disable(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
#ifdef CONFIG_RTL8185B
write_nic_dword(dev,IMR,0);
#else
write_nic_word(dev,INTA_MASK,0);
#endif
force_pci_posting(dev);
priv->irq_enabled = 0;
}
void rtl8180_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 rtl8180_adapter_start(struct net_device *dev);
void rtl8180_beacon_tx_enable(struct net_device *dev);
void rtl8180_update_msr(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
u8 msr;
u32 rxconf;
msr = read_nic_byte(dev, MSR);
msr &= ~ MSR_LINK_MASK;
rxconf=read_nic_dword(dev,RX_CONF);
if(priv->ieee80211->state == IEEE80211_LINKED)
{
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 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
else
msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
rxconf |= (1<<RX_CHECK_BSSID_SHIFT);
}else {
msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
rxconf &= ~(1<<RX_CHECK_BSSID_SHIFT);
}
write_nic_byte(dev, MSR, msr);
write_nic_dword(dev, RX_CONF, rxconf);
}
void rtl8180_set_chan(struct net_device *dev,short ch)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
if((ch > 14) || (ch < 1))
{
printk("In %s: Invalid chnanel %d\n", __func__, ch);
return;
}
priv->chan=ch;
//printk("in %s:channel is %d\n",__func__,ch);
priv->rf_set_chan(dev,priv->chan);
}
void rtl8180_rx_enable(struct net_device *dev)
{
u8 cmd;
u32 rxconf;
/* for now we accept data, management & ctl frame*/
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
rxconf=read_nic_dword(dev,RX_CONF);
rxconf = rxconf &~ MAC_FILTER_MASK;
rxconf = rxconf | (1<<ACCEPT_MNG_FRAME_SHIFT);
rxconf = rxconf | (1<<ACCEPT_DATA_FRAME_SHIFT);
rxconf = rxconf | (1<<ACCEPT_BCAST_FRAME_SHIFT);
rxconf = rxconf | (1<<ACCEPT_MCAST_FRAME_SHIFT);
// rxconf = rxconf | (1<<ACCEPT_CRCERR_FRAME_SHIFT);
if (dev->flags & IFF_PROMISC) DMESG ("NIC in promisc mode");
if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
dev->flags & IFF_PROMISC){
rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
}else{
rxconf = rxconf | (1<<ACCEPT_NICMAC_FRAME_SHIFT);
if(priv->card_8185 == 0)
rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
}
/*if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
}*/
if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
rxconf = rxconf | (1<<ACCEPT_CTL_FRAME_SHIFT);
rxconf = rxconf | (1<<ACCEPT_ICVERR_FRAME_SHIFT);
rxconf = rxconf | (1<<ACCEPT_PWR_FRAME_SHIFT);
}
if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
rxconf = rxconf | (1<<ACCEPT_CRCERR_FRAME_SHIFT);
//if(!priv->card_8185){
rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
//}
rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
rxconf = rxconf &~ MAX_RX_DMA_MASK;
rxconf = rxconf | (MAX_RX_DMA_2048<<MAX_RX_DMA_SHIFT);
//if(!priv->card_8185)
rxconf = rxconf | RCR_ONLYERLPKT;
rxconf = rxconf &~ RCR_CS_MASK;
if(!priv->card_8185)
rxconf |= (priv->rcr_csense<<RCR_CS_SHIFT);
// rxconf &=~ 0xfff00000;
// rxconf |= 0x90100000;//9014f76f;
write_nic_dword(dev, RX_CONF, rxconf);
fix_rx_fifo(dev);
#ifdef DEBUG_RX
DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RX_CONF));
#endif
cmd=read_nic_byte(dev,CMD);
write_nic_byte(dev,CMD,cmd | (1<<CMD_RX_ENABLE_SHIFT));
/* In rtl8139 driver seems that DMA threshold has to be written
* after enabling RX, so we rewrite RX_CONFIG register
*/
//mdelay(100);
// write_nic_dword(dev, RX_CONF, rxconf);
}
void set_nic_txring(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
// DMESG("ring %x %x", priv->txlpringdma,read_nic_dword(dev,TLPDA));
write_nic_dword(dev, TX_MANAGEPRIORITY_RING_ADDR, priv->txmapringdma);
// DMESG("ring %x %x", priv->txlpringdma,read_nic_dword(dev,TLPDA));
write_nic_dword(dev, TX_BKPRIORITY_RING_ADDR, priv->txbkpringdma);
// DMESG("ring %x %x", priv->txlpringdma,read_nic_dword(dev,TLPDA));
write_nic_dword(dev, TX_BEPRIORITY_RING_ADDR, priv->txbepringdma);
// DMESG("ring %x %x", priv->txlpringdma,read_nic_dword(dev,TLPDA));
write_nic_dword(dev, TX_VIPRIORITY_RING_ADDR, priv->txvipringdma);
// DMESG("ring %x %x", priv->txlpringdma,read_nic_dword(dev,TLPDA));
write_nic_dword(dev, TX_VOPRIORITY_RING_ADDR, priv->txvopringdma);
// DMESG("ring %x %x", priv->txlpringdma,read_nic_dword(dev,TLPDA));
write_nic_dword(dev, TX_HIGHPRIORITY_RING_ADDR, priv->txhpringdma);
// DMESG("ring %x %x", priv->txlpringdma,read_nic_dword(dev,TLPDA));
write_nic_dword(dev, TX_BEACON_RING_ADDR, priv->txbeaconringdma);
}
void rtl8180_conttx_enable(struct net_device *dev)
{
u32 txconf;
txconf = read_nic_dword(dev,TX_CONF);
txconf = txconf &~ TX_LOOPBACK_MASK;
txconf = txconf | (TX_LOOPBACK_CONTINUE <<TX_LOOPBACK_SHIFT);
write_nic_dword(dev,TX_CONF,txconf);
}
void rtl8180_conttx_disable(struct net_device *dev)
{
u32 txconf;
txconf = read_nic_dword(dev,TX_CONF);
txconf = txconf &~ TX_LOOPBACK_MASK;
txconf = txconf | (TX_LOOPBACK_NONE <<TX_LOOPBACK_SHIFT);
write_nic_dword(dev,TX_CONF,txconf);
}
void rtl8180_tx_enable(struct net_device *dev)
{
u8 cmd;
u8 tx_agc_ctl;
u8 byte;
u32 txconf;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
txconf= read_nic_dword(dev,TX_CONF);
if(priv->card_8185){
byte = read_nic_byte(dev,CW_CONF);
byte &= ~(1<<CW_CONF_PERPACKET_CW_SHIFT);
byte &= ~(1<<CW_CONF_PERPACKET_RETRY_SHIFT);
write_nic_byte(dev, CW_CONF, byte);
tx_agc_ctl = read_nic_byte(dev, TX_AGC_CTL);
tx_agc_ctl &= ~(1<<TX_AGC_CTL_PERPACKET_GAIN_SHIFT);
tx_agc_ctl &= ~(1<<TX_AGC_CTL_PERPACKET_ANTSEL_SHIFT);
tx_agc_ctl |=(1<<TX_AGC_CTL_FEEDBACK_ANT);
write_nic_byte(dev, TX_AGC_CTL, tx_agc_ctl);
/*
write_nic_word(dev, 0x5e, 0x01);
force_pci_posting(dev);
mdelay(1);
write_nic_word(dev, 0xfe, 0x10);
force_pci_posting(dev);
mdelay(1);
write_nic_word(dev, 0x5e, 0x00);
force_pci_posting(dev);
mdelay(1);
*/
write_nic_byte(dev, 0xec, 0x3f); /* Disable early TX */
}
if(priv->card_8185){
txconf = txconf &~ (1<<TCR_PROBE_NOTIMESTAMP_SHIFT);
}else{
if(hwseqnum)
txconf= txconf &~ (1<<TX_CONF_HEADER_AUTOICREMENT_SHIFT);
else
txconf= txconf | (1<<TX_CONF_HEADER_AUTOICREMENT_SHIFT);
}
txconf = txconf &~ TX_LOOPBACK_MASK;
txconf = txconf | (TX_LOOPBACK_NONE <<TX_LOOPBACK_SHIFT);
txconf = txconf &~ TCR_DPRETRY_MASK;
txconf = txconf &~ TCR_RTSRETRY_MASK;
txconf = txconf | (priv->retry_data<<TX_DPRETRY_SHIFT);
txconf = txconf | (priv->retry_rts<<TX_RTSRETRY_SHIFT);
txconf = txconf &~ (1<<TX_NOCRC_SHIFT);
if(priv->card_8185){
if(priv->hw_plcp_len)
txconf = txconf &~ TCR_PLCP_LEN;
else
txconf = txconf | TCR_PLCP_LEN;
}else{
txconf = txconf &~ TCR_SAT;
}
txconf = txconf &~ TCR_MXDMA_MASK;
txconf = txconf | (TCR_MXDMA_2048<<TCR_MXDMA_SHIFT);
txconf = txconf | TCR_CWMIN;
txconf = txconf | TCR_DISCW;
// if(priv->ieee80211->hw_wep)
// txconf=txconf &~ (1<<TX_NOICV_SHIFT);
// else
txconf=txconf | (1<<TX_NOICV_SHIFT);
write_nic_dword(dev,TX_CONF,txconf);
fix_tx_fifo(dev);
#ifdef DEBUG_TX
DMESG("txconf: %x %x",txconf,read_nic_dword(dev,TX_CONF));
#endif
cmd=read_nic_byte(dev,CMD);
write_nic_byte(dev,CMD,cmd | (1<<CMD_TX_ENABLE_SHIFT));
// mdelay(100);
write_nic_dword(dev,TX_CONF,txconf);
// #endif
/*
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
write_nic_byte(dev, TX_DMA_POLLING, priv->dma_poll_mask);
rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
*/
}
void rtl8180_beacon_tx_enable(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
#ifdef CONFIG_RTL8185B
priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_BQ);
write_nic_byte(dev,TPPollStop, priv->dma_poll_mask);
#else
priv->dma_poll_mask &=~(1<<TX_DMA_STOP_BEACON_SHIFT);
write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
#endif
rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
}
void rtl8180_beacon_tx_disable(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
#ifdef CONFIG_RTL8185B
priv->dma_poll_stop_mask |= TPPOLLSTOP_BQ;
write_nic_byte(dev,TPPollStop, priv->dma_poll_stop_mask);
#else
priv->dma_poll_mask |= (1<<TX_DMA_STOP_BEACON_SHIFT);
write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
#endif
rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
}
void rtl8180_rtx_disable(struct net_device *dev)
{
u8 cmd;
struct r8180_priv *priv = ieee80211_priv(dev);
cmd=read_nic_byte(dev,CMD);
write_nic_byte(dev, CMD, cmd &~ \
((1<<CMD_RX_ENABLE_SHIFT)|(1<<CMD_TX_ENABLE_SHIFT)));
force_pci_posting(dev);
mdelay(10);
/*while (read_nic_byte(dev,CMD) & (1<<CMD_RX_ENABLE_SHIFT))
udelay(10);
*/
if(!priv->rx_skb_complete)
dev_kfree_skb_any(priv->rx_skb);
}
#if 0
int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
{
int i;
u32 *tmp;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
priv->txbeaconring = (u32*)pci_alloc_consistent(priv->pdev,
sizeof(u32)*8*count,
&priv->txbeaconringdma);
if (!priv->txbeaconring) return -1;
for (tmp=priv->txbeaconring,i=0;i<count;i++){
*tmp = *tmp &~ (1<<31); // descriptor empty, owned by the drv
/*
*(tmp+2) = (u32)dma_tmp;
*(tmp+3) = bufsize;
*/
if(i+1<count)
*(tmp+4) = (u32)priv->txbeaconringdma+((i+1)*8*4);
else
*(tmp+4) = (u32)priv->txbeaconringdma;
tmp=tmp+8;
}
return 0;
}
#endif
short alloc_tx_desc_ring(struct net_device *dev, int bufsize, int count,
int addr)
{
int i;
u32 *desc;
u32 *tmp;
dma_addr_t dma_desc, dma_tmp;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct pci_dev *pdev = priv->pdev;
void *buf;
if((bufsize & 0xfff) != bufsize) {
DMESGE ("TX buffer allocation too large");
return 0;
}
desc = (u32*)pci_alloc_consistent(pdev,
sizeof(u32)*8*count+256, &dma_desc);
if(desc==NULL) return -1;
if(dma_desc & 0xff){
/*
* descriptor's buffer must be 256 byte aligned
* we shouldn't be here, since we set DMA mask !
*/
WARN(1, "DMA buffer is not aligned\n");
}
tmp=desc;
for (i=0;i<count;i++)
{
buf = (void*)pci_alloc_consistent(pdev,bufsize,&dma_tmp);
if (buf == NULL) return -ENOMEM;
switch(addr) {
#if 0
case TX_NORMPRIORITY_RING_ADDR:
if(-1 == buffer_add(&(priv->txnpbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer NP");
return -ENOMEM;
}
break;
case TX_LOWPRIORITY_RING_ADDR:
if(-1 == buffer_add(&(priv->txlpbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer LP");
return -ENOMEM;
}
break;
case TX_HIGHPRIORITY_RING_ADDR:
if(-1 == buffer_add(&(priv->txhpbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer HP");
return -ENOMEM;
}
break;
#else
case TX_MANAGEPRIORITY_RING_ADDR:
if(-1 == buffer_add(&(priv->txmapbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer NP");
return -ENOMEM;
}
break;
case TX_BKPRIORITY_RING_ADDR:
if(-1 == buffer_add(&(priv->txbkpbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer LP");
return -ENOMEM;
}
break;
case TX_BEPRIORITY_RING_ADDR:
if(-1 == buffer_add(&(priv->txbepbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer NP");
return -ENOMEM;
}
break;
case TX_VIPRIORITY_RING_ADDR:
if(-1 == buffer_add(&(priv->txvipbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer LP");
return -ENOMEM;
}
break;
case TX_VOPRIORITY_RING_ADDR:
if(-1 == buffer_add(&(priv->txvopbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer NP");
return -ENOMEM;
}
break;
#endif
case TX_HIGHPRIORITY_RING_ADDR:
if(-1 == buffer_add(&(priv->txhpbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer HP");
return -ENOMEM;
}
break;
case TX_BEACON_RING_ADDR:
if(-1 == buffer_add(&(priv->txbeaconbufs),buf,dma_tmp,NULL)){
DMESGE("Unable to allocate mem for buffer BP");
return -ENOMEM;
}
break;
}
*tmp = *tmp &~ (1<<31); // descriptor empty, owned by the drv
*(tmp+2) = (u32)dma_tmp;
*(tmp+3) = bufsize;
if(i+1<count)
*(tmp+4) = (u32)dma_desc+((i+1)*8*4);
else
*(tmp+4) = (u32)dma_desc;
tmp=tmp+8;
}
switch(addr) {
case TX_MANAGEPRIORITY_RING_ADDR:
priv->txmapringdma=dma_desc;
priv->txmapring=desc;
break;
case TX_BKPRIORITY_RING_ADDR:
priv->txbkpringdma=dma_desc;
priv->txbkpring=desc;
break;
case TX_BEPRIORITY_RING_ADDR:
priv->txbepringdma=dma_desc;
priv->txbepring=desc;
break;
case TX_VIPRIORITY_RING_ADDR:
priv->txvipringdma=dma_desc;
priv->txvipring=desc;
break;
case TX_VOPRIORITY_RING_ADDR:
priv->txvopringdma=dma_desc;
priv->txvopring=desc;
break;
case TX_HIGHPRIORITY_RING_ADDR:
priv->txhpringdma=dma_desc;
priv->txhpring=desc;
break;
case TX_BEACON_RING_ADDR:
priv->txbeaconringdma=dma_desc;
priv->txbeaconring=desc;
break;
}
#ifdef DEBUG_TX
DMESG("Tx dma physical address: %x",dma_desc);
#endif
return 0;
}
void free_tx_desc_rings(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct pci_dev *pdev=priv->pdev;
int count = priv->txringcount;
pci_free_consistent(pdev, sizeof(u32)*8*count+256,
priv->txmapring, priv->txmapringdma);
buffer_free(dev,&(priv->txmapbufs),priv->txbuffsize,1);
pci_free_consistent(pdev, sizeof(u32)*8*count+256,
priv->txbkpring, priv->txbkpringdma);
buffer_free(dev,&(priv->txbkpbufs),priv->txbuffsize,1);
pci_free_consistent(pdev, sizeof(u32)*8*count+256,
priv->txbepring, priv->txbepringdma);
buffer_free(dev,&(priv->txbepbufs),priv->txbuffsize,1);
pci_free_consistent(pdev, sizeof(u32)*8*count+256,
priv->txvipring, priv->txvipringdma);
buffer_free(dev,&(priv->txvipbufs),priv->txbuffsize,1);
pci_free_consistent(pdev, sizeof(u32)*8*count+256,
priv->txvopring, priv->txvopringdma);
buffer_free(dev,&(priv->txvopbufs),priv->txbuffsize,1);
pci_free_consistent(pdev, sizeof(u32)*8*count+256,
priv->txhpring, priv->txhpringdma);
buffer_free(dev,&(priv->txhpbufs),priv->txbuffsize,1);
count = priv->txbeaconcount;
pci_free_consistent(pdev, sizeof(u32)*8*count+256,
priv->txbeaconring, priv->txbeaconringdma);
buffer_free(dev,&(priv->txbeaconbufs),priv->txbuffsize,1);
}
#if 0
void free_beacon_desc_ring(struct net_device *dev,int count)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct pci_dev *pdev=priv->pdev;
pci_free_consistent(pdev, sizeof(u32)*8*count+256,
priv->txbeaconring, priv->txbeaconringdma);
if (priv->beacon_buf)
pci_free_consistent(priv->pdev,
priv->master_beaconsize,priv->beacon_buf,priv->beacondmabuf);
}
#endif
void free_rx_desc_ring(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct pci_dev *pdev = priv->pdev;
int count = priv->rxringcount;
#ifdef CONFIG_RTL8185B
pci_free_consistent(pdev, sizeof(u32)*8*count+256,
priv->rxring, priv->rxringdma);
#else
pci_free_consistent(pdev, sizeof(u32)*4*count+256,
priv->rxring, priv->rxringdma);
#endif
buffer_free(dev,&(priv->rxbuffer),priv->rxbuffersize,0);
}
short alloc_rx_desc_ring(struct net_device *dev, u16 bufsize, int count)
{
int i;
u32 *desc;
u32 *tmp;
dma_addr_t dma_desc,dma_tmp;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct pci_dev *pdev=priv->pdev;
void *buf;
u8 rx_desc_size;
#ifdef CONFIG_RTL8185B
rx_desc_size = 8; // 4*8 = 32 bytes
#else
rx_desc_size = 4;
#endif
if((bufsize & 0xfff) != bufsize){
DMESGE ("RX buffer allocation too large");
return -1;
}
desc = (u32*)pci_alloc_consistent(pdev,sizeof(u32)*rx_desc_size*count+256,
&dma_desc);
if(dma_desc & 0xff){
/*
* descriptor's buffer must be 256 byte aligned
* should never happen since we specify the DMA mask
*/
WARN(1, "DMA buffer is not aligned\n");
}
priv->rxring=desc;
priv->rxringdma=dma_desc;
tmp=desc;
for (i=0;i<count;i++){
if ((buf= kmalloc(bufsize * sizeof(u8),GFP_ATOMIC)) == NULL){
DMESGE("Failed to kmalloc RX buffer");
return -1;
}
dma_tmp = pci_map_single(pdev,buf,bufsize * sizeof(u8),
PCI_DMA_FROMDEVICE);
#ifdef DEBUG_ZERO_RX
int j;
for(j=0;j<bufsize;j++) ((u8*)buf)[i] = 0;
#endif
//buf = (void*)pci_alloc_consistent(pdev,bufsize,&dma_tmp);
if(-1 == buffer_add(&(priv->rxbuffer), buf,dma_tmp,
&(priv->rxbufferhead))){
DMESGE("Unable to allocate mem RX buf");
return -1;
}
*tmp = 0; //zero pads the header of the descriptor
*tmp = *tmp |( bufsize&0xfff);
*(tmp+2) = (u32)dma_tmp;
*tmp = *tmp |(1<<31); // descriptor void, owned by the NIC
#ifdef DEBUG_RXALLOC
DMESG("Alloc %x size buffer, DMA mem @ %x, virtual mem @ %x",
(u32)(bufsize&0xfff), (u32)dma_tmp, (u32)buf);
#endif
tmp=tmp+rx_desc_size;
}
*(tmp-rx_desc_size) = *(tmp-rx_desc_size) | (1<<30); // this is the last descriptor
#ifdef DEBUG_RXALLOC
DMESG("RX DMA physical address: %x",dma_desc);
#endif
return 0;
}
void set_nic_rxring(struct net_device *dev)
{
u8 pgreg;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
//rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
pgreg=read_nic_byte(dev, PGSELECT);
write_nic_byte(dev, PGSELECT, pgreg &~ (1<<PGSELECT_PG_SHIFT));
//rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
write_nic_dword(dev, RXRING_ADDR,priv->rxringdma);
}
void rtl8180_reset(struct net_device *dev)
{
//u32 txconf = 0x80e00707; //FIXME: Make me understandable
u8 cr;
//write_nic_dword(dev,TX_CONF,txconf);
rtl8180_irq_disable(dev);
cr=read_nic_byte(dev,CMD);
cr = cr & 2;
cr = cr | (1<<CMD_RST_SHIFT);
write_nic_byte(dev,CMD,cr);
force_pci_posting(dev);
mdelay(200);
if(read_nic_byte(dev,CMD) & (1<<CMD_RST_SHIFT))
DMESGW("Card reset timeout!");
else
DMESG("Card successfully reset");
//#ifndef CONFIG_RTL8185B
rtl8180_set_mode(dev,EPROM_CMD_LOAD);
force_pci_posting(dev);
mdelay(200);
//#endif
}
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,720};
inline u16 rtl8180_rate2rate(short rate)
{
if (rate >12) return 10;
return rtl_rate[rate];
}
inline u8 rtl8180_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( rtl8180_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;
}
//{by amy 080312
//
// Description:
// For Netgear case, they want good-looking singal strength.
// 2004.12.05, by rcnjko.
//
long
NetgearSignalStrengthTranslate(
long LastSS,
long CurrSS
)
{
long RetSS;
// Step 1. Scale mapping.
if(CurrSS >= 71 && CurrSS <= 100)
{
RetSS = 90 + ((CurrSS - 70) / 3);
}
else if(CurrSS >= 41 && CurrSS <= 70)
{
RetSS = 78 + ((CurrSS - 40) / 3);
}
else if(CurrSS >= 31 && CurrSS <= 40)
{
RetSS = 66 + (CurrSS - 30);
}
else if(CurrSS >= 21 && CurrSS <= 30)
{
RetSS = 54 + (CurrSS - 20);
}
else if(CurrSS >= 5 && CurrSS <= 20)
{
RetSS = 42 + (((CurrSS - 5) * 2) / 3);
}
else if(CurrSS == 4)
{
RetSS = 36;
}
else if(CurrSS == 3)
{
RetSS = 27;
}
else if(CurrSS == 2)
{
RetSS = 18;
}
else if(CurrSS == 1)
{
RetSS = 9;
}
else
{
RetSS = CurrSS;
}
//RT_TRACE(COMP_DBG, DBG_LOUD, ("##### After Mapping: LastSS: %d, CurrSS: %d, RetSS: %d\n", LastSS, CurrSS, RetSS));
// Step 2. Smoothing.
if(LastSS > 0)
{
RetSS = ((LastSS * 5) + (RetSS)+ 5) / 6;
}
//RT_TRACE(COMP_DBG, DBG_LOUD, ("$$$$$ After Smoothing: LastSS: %d, CurrSS: %d, RetSS: %d\n", LastSS, CurrSS, RetSS));
return RetSS;
}
//
// Description:
// Translate 0-100 signal strength index into dBm.
//
long
TranslateToDbm8185(
u8 SignalStrengthIndex // 0-100 index.
)
{
long SignalPower; // in dBm.
// Translate to dBm (x=0.5y-95).
SignalPower = (long)((SignalStrengthIndex + 1) >> 1);
SignalPower -= 95;
return SignalPower;
}
//
// Description:
// Perform signal smoothing for dynamic mechanism.
// This is different with PerformSignalSmoothing8185 in smoothing fomula.
// No dramatic adjustion is apply because dynamic mechanism need some degree
// of correctness. Ported from 8187B.
// 2007-02-26, by Bruce.
//
void
PerformUndecoratedSignalSmoothing8185(
struct r8180_priv *priv,
bool bCckRate
)
{
// Determin the current packet is CCK rate.
priv->bCurCCKPkt = bCckRate;
if(priv->UndecoratedSmoothedSS >= 0)
{
priv->UndecoratedSmoothedSS = ( (priv->UndecoratedSmoothedSS * 5) + (priv->SignalStrength * 10) ) / 6;
}
else
{
priv->UndecoratedSmoothedSS = priv->SignalStrength * 10;
}
priv->UndercorateSmoothedRxPower = ( (priv->UndercorateSmoothedRxPower * 50) + (priv->RxPower* 11)) / 60;
// printk("Sommthing SignalSterngth (%d) => UndecoratedSmoothedSS (%d)\n", priv->SignalStrength, priv->UndecoratedSmoothedSS);
// printk("Sommthing RxPower (%d) => UndecoratedRxPower (%d)\n", priv->RxPower, priv->UndercorateSmoothedRxPower);
//if(priv->CurCCKRSSI >= 0 && bCckRate)
if(bCckRate)
{
priv->CurCCKRSSI = priv->RSSI;
}
else
{
priv->CurCCKRSSI = 0;
}
// Boundary checking.
// TODO: The overflow condition does happen, if we want to fix,
// we shall recalculate thresholds first.
if(priv->UndecoratedSmoothedSS > 100)
{
// printk("UndecoratedSmoothedSS(%d) overflow, SignalStrength(%d)\n", priv->UndecoratedSmoothedSS, priv->SignalStrength);
}
if(priv->UndecoratedSmoothedSS < 0)
{
// printk("UndecoratedSmoothedSS(%d) underflow, SignalStrength(%d)\n", priv->UndecoratedSmoothedSS, priv->SignalStrength);
}
}
//by amy 080312}
/* This is rough RX isr handling routine*/
void rtl8180_rx(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct sk_buff *tmp_skb;
//struct sk_buff *skb;
short first,last;
u32 len;
int lastlen;
unsigned char quality, signal;
u8 rate;
//u32 *prism_hdr;
u32 *tmp,*tmp2;
u8 rx_desc_size;
u8 padding;
//u32 count=0;
char rxpower = 0;
u32 RXAGC = 0;
long RxAGC_dBm = 0;
u8 LNA=0, BB=0;
u8 LNA_gain[4]={02, 17, 29, 39};
u8 Antenna = 0;
struct ieee80211_hdr *hdr;//by amy
u16 fc,type;
u8 bHwError = 0,bCRC = 0,bICV = 0;
//bHwError = 0;
//bCRC = 0;
//bICV = 0;
bool bCckRate = false;
u8 RSSI = 0;
long SignalStrengthIndex = 0;//+by amy 080312
// u8 SignalStrength = 0;
struct ieee80211_rx_stats stats = {
.signal = 0,
.noise = -98,
.rate = 0,
// .mac_time = jiffies,
.freq = IEEE80211_24GHZ_BAND,
};
#ifdef CONFIG_RTL8185B
stats.nic_type = NIC_8185B;
rx_desc_size = 8;
#else
stats.nic_type = NIC_8185;
rx_desc_size = 4;
#endif
//printk("receive frame!%d\n",count++);
//if (!priv->rxbuffer) DMESG ("EE: NIC RX ack, but RX queue corrupted!");
//else {
if ((*(priv->rxringtail)) & (1<<31)) {
/* we have got an RX int, but the descriptor
* we are pointing is empty*/
priv->stats.rxnodata++;
priv->ieee80211->stats.rx_errors++;
/* if (! *(priv->rxring) & (1<<31)) {
priv->stats.rxreset++;
priv->rxringtail=priv->rxring;
priv->rxbuffer=priv->rxbufferhead;
}else{*/
#if 0
/* Maybe it is possible that the NIC has skipped some descriptors or
* it has reset its internal pointer to the beginning of the ring
* we search for the first filled descriptor in the ring, or we break
* putting again the pointer in the old location if we do not found any.
* This is quite dangerous, what does happen if the nic writes
* two descriptor (say A and B) when we have just checked the descriptor
* A and we are going to check the descriptor B..This might happen if the
* interrupt was dummy, there was not really filled descriptors and
* the NIC didn't lose pointer
*/
//priv->stats.rxwrkaround++;
tmp = priv->rxringtail;
while (*(priv->rxringtail) & (1<<31)){
priv->rxringtail+=4;
if(priv->rxringtail >=
(priv->rxring)+(priv->rxringcount )*4)
priv->rxringtail=priv->rxring;
priv->rxbuffer=(priv->rxbuffer->next);
if(priv->rxringtail == tmp ){
//DMESG("EE: Could not find RX pointer");
priv->stats.rxnopointer++;
break;
}
}
#else
tmp2 = NULL;
tmp = priv->rxringtail;
do{
if(tmp == priv->rxring)
//tmp = priv->rxring + (priv->rxringcount )*rx_desc_size; xiong-2006-11-15
tmp = priv->rxring + (priv->rxringcount - 1)*rx_desc_size;
else
tmp -= rx_desc_size;
if(! (*tmp & (1<<31)))
tmp2 = tmp;
}while(tmp != priv->rxring);
if(tmp2) priv->rxringtail = tmp2;
#endif
//}
}
/* while there are filled descriptors */
while(!(*(priv->rxringtail) & (1<<31))){
if(*(priv->rxringtail) & (1<<26))
DMESGW("RX buffer overflow");
if(*(priv->rxringtail) & (1<<12))
priv->stats.rxicverr++;
if(*(priv->rxringtail) & (1<<27)){
priv->stats.rxdmafail++;
//DMESG("EE: RX DMA FAILED at buffer pointed by descriptor %x",(u32)priv->rxringtail);
goto drop;
}
pci_dma_sync_single_for_cpu(priv->pdev,
priv->rxbuffer->dma,
priv->rxbuffersize * \
sizeof(u8),
PCI_DMA_FROMDEVICE);
first = *(priv->rxringtail) & (1<<29) ? 1:0;
if(first) priv->rx_prevlen=0;
last = *(priv->rxringtail) & (1<<28) ? 1:0;
if(last){
lastlen=((*priv->rxringtail) &0xfff);
/* if the last descriptor (that should
* tell us the total packet len) tell
* us something less than the descriptors
* len we had until now, then there is some
* problem..
* workaround to prevent kernel panic
*/
if(lastlen < priv->rx_prevlen)
len=0;
else
len=lastlen-priv->rx_prevlen;
if(*(priv->rxringtail) & (1<<13)) {
//lastlen=((*priv->rxringtail) &0xfff);
if ((*(priv->rxringtail) & 0xfff) <500)
priv->stats.rxcrcerrmin++;
else if ((*(priv->rxringtail) & 0x0fff) >1000)
priv->stats.rxcrcerrmax++;
else
priv->stats.rxcrcerrmid++;
}
}else{
len = priv->rxbuffersize;
}
#ifdef CONFIG_RTL8185B
if(first && last) {
padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
}else if(first) {
padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
if(padding) {
len -= 2;
}
}else {
padding = 0;
}
#ifdef CONFIG_RTL818X_S
padding = 0;
#endif
#endif
priv->rx_prevlen+=len;
if(priv->rx_prevlen > MAX_FRAG_THRESHOLD + 100){
/* HW is probably passing several buggy frames
* without FD or LD flag set.
* Throw this garbage away to prevent skb
* memory exausting
*/
if(!priv->rx_skb_complete)
dev_kfree_skb_any(priv->rx_skb);
priv->rx_skb_complete = 1;
}
#ifdef DEBUG_RX_FRAG
DMESG("Iteration.. len %x",len);
if(first) DMESG ("First descriptor");
if(last) DMESG("Last descriptor");
#endif
#ifdef DEBUG_RX_VERBOSE
print_buffer( priv->rxbuffer->buf, len);
#endif
#ifdef CONFIG_RTL8185B
signal=(unsigned char)(((*(priv->rxringtail+3))& (0x00ff0000))>>16);
signal=(signal&0xfe)>>1; // Modify by hikaru 6.6
quality=(unsigned char)((*(priv->rxringtail+3)) & (0xff));
stats.mac_time[0] = *(priv->rxringtail+1);
stats.mac_time[1] = *(priv->rxringtail+2);
rxpower =((char)(((*(priv->rxringtail+4))& (0x00ff0000))>>16))/2 - 42;
RSSI = ((u8)(((*(priv->rxringtail+3)) & (0x0000ff00))>> 8)) & (0x7f);
#else
signal=((*(priv->rxringtail+1))& (0xff0000))>>16;
signal=(signal&0xfe)>>1; // Modify by hikaru 6.6
quality=((*(priv->rxringtail+1)) & (0xff));
stats.mac_time[0] = *(priv->rxringtail+2);
stats.mac_time[1] = *(priv->rxringtail+3);
#endif
rate=((*(priv->rxringtail)) &
((1<<23)|(1<<22)|(1<<21)|(1<<20)))>>20;
stats.rate = rtl8180_rate2rate(rate);
//DMESG("%d",rate);
Antenna = (((*(priv->rxringtail +3))& (0x00008000)) == 0 )? 0:1 ;
// printk("in rtl8180_rx():Antenna is %d\n",Antenna);
//by amy for antenna
if(!rtl8180_IsWirelessBMode(stats.rate))
{ // OFDM rate.
RxAGC_dBm = rxpower+1; //bias
}
else
{ // CCK rate.
RxAGC_dBm = signal;//bit 0 discard
LNA = (u8) (RxAGC_dBm & 0x60 ) >> 5 ; //bit 6~ bit 5
BB = (u8) (RxAGC_dBm & 0x1F); // bit 4 ~ bit 0
RxAGC_dBm = -( LNA_gain[LNA] + (BB *2) ); //Pin_11b=-(LNA_gain+BB_gain) (dBm)
RxAGC_dBm +=4; //bias
}
if(RxAGC_dBm & 0x80) //absolute value
RXAGC= ~(RxAGC_dBm)+1;
bCckRate = rtl8180_IsWirelessBMode(stats.rate);
// Translate RXAGC into 1-100.
if(!rtl8180_IsWirelessBMode(stats.rate))
{ // OFDM rate.
if(RXAGC>90)
RXAGC=90;
else if(RXAGC<25)
RXAGC=25;
RXAGC=(90-RXAGC)*100/65;
}
else
{ // CCK rate.
if(RXAGC>95)
RXAGC=95;
else if(RXAGC<30)
RXAGC=30;
RXAGC=(95-RXAGC)*100/65;
}
priv->SignalStrength = (u8)RXAGC;
priv->RecvSignalPower = RxAGC_dBm ; // It can use directly by SD3 CMLin
priv->RxPower = rxpower;
priv->RSSI = RSSI;
//{by amy 080312
// SQ translation formular is provided by SD3 DZ. 2006.06.27, by rcnjko.
if(quality >= 127)
quality = 1;//0; //0 will cause epc to show signal zero , walk aroud now;
else if(quality < 27)
quality = 100;
else
quality = 127 - quality;
priv->SignalQuality = quality;
if(!priv->card_8185)
printk("check your card type\n");
stats.signal = (u8)quality;//priv->wstats.qual.level = priv->SignalStrength;
stats.signalstrength = RXAGC;
if(stats.signalstrength > 100)
stats.signalstrength = 100;
stats.signalstrength = (stats.signalstrength * 70)/100 + 30;
// printk("==========================>rx : RXAGC is %d,signalstrength is %d\n",RXAGC,stats.signalstrength);
stats.rssi = priv->wstats.qual.qual = priv->SignalQuality;
stats.noise = priv->wstats.qual.noise = 100 - priv ->wstats.qual.qual;
//by amy 080312}
bHwError = (((*(priv->rxringtail))& (0x00000fff)) == 4080)| (((*(priv->rxringtail))& (0x04000000)) != 0 )
| (((*(priv->rxringtail))& (0x08000000)) != 0 )| (((~(*(priv->rxringtail)))& (0x10000000)) != 0 )| (((~(*(priv->rxringtail)))& (0x20000000)) != 0 );
bCRC = ((*(priv->rxringtail)) & (0x00002000)) >> 13;
bICV = ((*(priv->rxringtail)) & (0x00001000)) >> 12;
hdr = (struct ieee80211_hdr *)priv->rxbuffer->buf;
fc = le16_to_cpu(hdr->frame_ctl);
type = WLAN_FC_GET_TYPE(fc);
if((IEEE80211_FTYPE_CTL != type) &&
(eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
&& (!bHwError) && (!bCRC)&& (!bICV))
{
//by amy 080312
// Perform signal smoothing for dynamic mechanism on demand.
// This is different with PerformSignalSmoothing8185 in smoothing fomula.
// No dramatic adjustion is apply because dynamic mechanism need some degree
// of correctness. 2007.01.23, by shien chang.
PerformUndecoratedSignalSmoothing8185(priv,bCckRate);
//
// For good-looking singal strength.
//
SignalStrengthIndex = NetgearSignalStrengthTranslate(
priv->LastSignalStrengthInPercent,
priv->SignalStrength);
priv->LastSignalStrengthInPercent = SignalStrengthIndex;
priv->Stats_SignalStrength = TranslateToDbm8185((u8)SignalStrengthIndex);
//
// We need more correct power of received packets and the "SignalStrength" of RxStats is beautified,
// so we record the correct power here.
//
priv->Stats_SignalQuality =(long) (priv->Stats_SignalQuality * 5 + (long)priv->SignalQuality + 5) / 6;
priv->Stats_RecvSignalPower = (long)(priv->Stats_RecvSignalPower * 5 + priv->RecvSignalPower -1) / 6;
// Figure out which antenna that received the lasted packet.
priv->LastRxPktAntenna = Antenna ? 1 : 0; // 0: aux, 1: main.
//by amy 080312
SwAntennaDiversityRxOk8185(dev, priv->SignalStrength);
}
//by amy for antenna
#ifndef DUMMY_RX
if(first){
if(!priv->rx_skb_complete){
/* seems that HW sometimes fails to reiceve and
doesn't provide the last descriptor */
#ifdef DEBUG_RX_SKB
DMESG("going to free incomplete skb");
#endif
dev_kfree_skb_any(priv->rx_skb);
priv->stats.rxnolast++;
#ifdef DEBUG_RX_SKB
DMESG("free incomplete skb OK");
#endif
}
/* support for prism header has been originally added by Christian */
if(priv->prism_hdr && priv->ieee80211->iw_mode == IW_MODE_MONITOR){
#if 0
priv->rx_skb = dev_alloc_skb(len+2+PRISM_HDR_SIZE);
if(! priv->rx_skb) goto drop;
prism_hdr = (u32*) skb_put(priv->rx_skb,PRISM_HDR_SIZE);
prism_hdr[0]=htonl(0x80211001); //version
prism_hdr[1]=htonl(0x40); //length
prism_hdr[2]=htonl(stats.mac_time[1]); //mactime (HIGH)
prism_hdr[3]=htonl(stats.mac_time[0]); //mactime (LOW)
rdtsc(prism_hdr[5], prism_hdr[4]); //hostime (LOW+HIGH)
prism_hdr[4]=htonl(prism_hdr[4]); //Byte-Order aendern
prism_hdr[5]=htonl(prism_hdr[5]); //Byte-Order aendern
prism_hdr[6]=0x00; //phytype
prism_hdr[7]=htonl(priv->chan); //channel
prism_hdr[8]=htonl(stats.rate); //datarate
prism_hdr[9]=0x00; //antenna
prism_hdr[10]=0x00; //priority
prism_hdr[11]=0x00; //ssi_type
prism_hdr[12]=htonl(stats.signal); //ssi_signal
prism_hdr[13]=htonl(stats.noise); //ssi_noise
prism_hdr[14]=0x00; //preamble
prism_hdr[15]=0x00; //encoding
#endif
}else{
priv->rx_skb = dev_alloc_skb(len+2);
if( !priv->rx_skb) goto drop;
#ifdef DEBUG_RX_SKB
DMESG("Alloc initial skb %x",len+2);
#endif
}
priv->rx_skb_complete=0;
priv->rx_skb->dev=dev;
}else{
/* if we are here we should have already RXed
* the first frame.
* If we get here and the skb is not allocated then
* we have just throw out garbage (skb not allocated)
* and we are still rxing garbage....
*/
if(!priv->rx_skb_complete){
tmp_skb= dev_alloc_skb(priv->rx_skb->len +len+2);
if(!tmp_skb) goto drop;
tmp_skb->dev=dev;
#ifdef DEBUG_RX_SKB
DMESG("Realloc skb %x",len+2);
#endif
#ifdef DEBUG_RX_SKB
DMESG("going copy prev frag %x",priv->rx_skb->len);
#endif
memcpy(skb_put(tmp_skb,priv->rx_skb->len),
priv->rx_skb->data,
priv->rx_skb->len);
#ifdef DEBUG_RX_SKB
DMESG("skb copy prev frag complete");
#endif
dev_kfree_skb_any(priv->rx_skb);
#ifdef DEBUG_RX_SKB
DMESG("prev skb free ok");
#endif
priv->rx_skb=tmp_skb;
}
}
#ifdef DEBUG_RX_SKB
DMESG("going to copy current payload %x",len);
#endif
if(!priv->rx_skb_complete) {
#ifdef CONFIG_RTL8185B
if(padding) {
memcpy(skb_put(priv->rx_skb,len),
(((unsigned char *)priv->rxbuffer->buf) + 2),len);
} else {
#endif
memcpy(skb_put(priv->rx_skb,len),
priv->rxbuffer->buf,len);
#ifdef CONFIG_RTL8185B
}
#endif
}
#ifdef DEBUG_RX_SKB
DMESG("current fragment skb copy complete");
#endif
if(last && !priv->rx_skb_complete){
#ifdef DEBUG_RX_SKB
DMESG("Got last fragment");
#endif
if(priv->rx_skb->len > 4)
skb_trim(priv->rx_skb,priv->rx_skb->len-4);
#ifdef DEBUG_RX_SKB
DMESG("yanked out crc, passing to the upper layer");
#endif
#ifndef RX_DONT_PASS_UL
if(!ieee80211_rx(priv->ieee80211,
priv->rx_skb, &stats)){
#ifdef DEBUG_RX
DMESGW("Packet not consumed");
#endif
#endif // RX_DONT_PASS_UL
dev_kfree_skb_any(priv->rx_skb);
#ifndef RX_DONT_PASS_UL
}
#endif
#ifdef DEBUG_RX
else{
DMESG("Rcv frag");
}
#endif
priv->rx_skb_complete=1;
}
#endif //DUMMY_RX
pci_dma_sync_single_for_device(priv->pdev,
priv->rxbuffer->dma,
priv->rxbuffersize * \
sizeof(u8),
PCI_DMA_FROMDEVICE);
drop: // this is used when we have not enought mem
/* restore the descriptor */
*(priv->rxringtail+2)=priv->rxbuffer->dma;
*(priv->rxringtail)=*(priv->rxringtail) &~ 0xfff;
*(priv->rxringtail)=
*(priv->rxringtail) | priv->rxbuffersize;
*(priv->rxringtail)=
*(priv->rxringtail) | (1<<31);
//^empty descriptor
//wmb();
#ifdef DEBUG_RX
DMESG("Current descriptor: %x",(u32)priv->rxringtail);
#endif
//unsigned long flags;
//spin_lock_irqsave(&priv->irq_lock,flags);
priv->rxringtail+=rx_desc_size;
if(priv->rxringtail >=
(priv->rxring)+(priv->rxringcount )*rx_desc_size)
priv->rxringtail=priv->rxring;
//spin_unlock_irqrestore(&priv->irq_lock,flags);
priv->rxbuffer=(priv->rxbuffer->next);
}
// if(get_curr_tx_free_desc(dev,priority))
// ieee80211_sta_ps_sleep(priv->ieee80211, &tmp, &tmp2);
}
void rtl8180_dma_kick(struct net_device *dev, int priority)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
/*
switch(priority){
case LOW_PRIORITY:
write_nic_byte(dev,TX_DMA_POLLING,
(1<< TX_DMA_POLLING_LOWPRIORITY_SHIFT) |
priv->dma_poll_mask);
break;
case NORM_PRIORITY:
write_nic_byte(dev,TX_DMA_POLLING,
(1<< TX_DMA_POLLING_NORMPRIORITY_SHIFT) |
priv->dma_poll_mask);
break;
case HI_PRIORITY:
write_nic_byte(dev,TX_DMA_POLLING,
(1<< TX_DMA_POLLING_HIPRIORITY_SHIFT) |
priv->dma_poll_mask);
break;
}
*/
write_nic_byte(dev, TX_DMA_POLLING,
(1 << (priority + 1)) | priv->dma_poll_mask);
rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
force_pci_posting(dev);
}
#if 0
void rtl8180_tx_queues_stop(struct net_device *dev)
{
//struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
u8 dma_poll_mask = (1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
dma_poll_mask |= (1<<TX_DMA_STOP_HIPRIORITY_SHIFT);
dma_poll_mask |= (1<<TX_DMA_STOP_NORMPRIORITY_SHIFT);
dma_poll_mask |= (1<<TX_DMA_STOP_BEACON_SHIFT);
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
write_nic_byte(dev,TX_DMA_POLLING,dma_poll_mask);
rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
}
#endif
void rtl8180_data_hard_stop(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
#ifdef CONFIG_RTL8185B
priv->dma_poll_stop_mask |= TPPOLLSTOP_AC_VIQ;
write_nic_byte(dev,TPPollStop, priv->dma_poll_stop_mask);
#else
priv->dma_poll_mask |= (1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
#endif
rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
}
void rtl8180_data_hard_resume(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
#ifdef CONFIG_RTL8185B
priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_AC_VIQ);
write_nic_byte(dev,TPPollStop, priv->dma_poll_stop_mask);
#else
priv->dma_poll_mask &= ~(1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
#endif
rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
}
/* 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 rtl8180_hard_data_xmit(struct sk_buff *skb,struct net_device *dev, int
rate)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
int mode;
struct ieee80211_hdr_3addr *h = (struct ieee80211_hdr_3addr *) skb->data;
short morefrag = (h->frame_ctl) & IEEE80211_FCTL_MOREFRAGS;
unsigned long flags;
int priority;
//static int count = 0;
mode = priv->ieee80211->iw_mode;
rate = ieeerate2rtlrate(rate);
/*
* This function doesn't require lock because we make
* sure it's called with the tx_lock already acquired.
* this come from the kernel's hard_xmit callback (trought
* the ieee stack, or from the try_wake_queue (again trought
* the ieee stack.
*/
#ifdef CONFIG_RTL8185B
priority = AC2Q(skb->priority);
#else
priority = LOW_PRIORITY;
#endif
spin_lock_irqsave(&priv->tx_lock,flags);
if(priv->ieee80211->bHwRadioOff)
{
spin_unlock_irqrestore(&priv->tx_lock,flags);
return;
}
//printk(KERN_WARNING "priority = %d@%d\n", priority, count++);
if (!check_nic_enought_desc(dev, priority)){
//DMESG("Error: no descriptor left by previous TX (avail %d) ",
// get_curr_tx_free_desc(dev, priority));
DMESGW("Error: no descriptor left by previous TX (avail %d) ",
get_curr_tx_free_desc(dev, priority));
//printk(KERN_WARNING "==============================================================> \n");
ieee80211_stop_queue(priv->ieee80211);
}
rtl8180_tx(dev, skb->data, skb->len, priority, morefrag,0,rate);
if (!check_nic_enought_desc(dev, priority))
ieee80211_stop_queue(priv->ieee80211);
//dev_kfree_skb_any(skb);
spin_unlock_irqrestore(&priv->tx_lock,flags);
}
/* 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). For this reason it is better
* if the descriptors are larger than the largest management frame
* we intend to TX: i'm unsure what the HW does if it will not found
* the last fragment of a frame because it has been dropped...
* Since queues for Management and Data frames are different we
* might use a different lock than tx_lock (for example mgmt_tx_lock)
*/
/* these function may loops if invoked with 0 descriptors or 0 len buffer*/
int rtl8180_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
unsigned long flags;
int priority;
#ifdef CONFIG_RTL8185B
priority = MANAGE_PRIORITY;
#else
priority = NORM_PRIORITY;
#endif
spin_lock_irqsave(&priv->tx_lock,flags);
if(priv->ieee80211->bHwRadioOff)
{
spin_unlock_irqrestore(&priv->tx_lock,flags);
dev_kfree_skb_any(skb);
return 0;
}
rtl8180_tx(dev, skb->data, skb->len, priority,
0, 0,ieeerate2rtlrate(priv->ieee80211->basic_rate));
priv->ieee80211->stats.tx_bytes+=skb->len;
priv->ieee80211->stats.tx_packets++;
spin_unlock_irqrestore(&priv->tx_lock,flags);
dev_kfree_skb_any(skb);
return 0;
}
// longpre 144+48 shortpre 72+24
u16 rtl8180_len2duration(u32 len, short rate,short* ext)
{
u16 duration;
u16 drift;
*ext=0;
switch(rate){
case 0://1mbps
*ext=0;
duration = ((len+4)<<4) /0x2;
drift = ((len+4)<<4) % 0x2;
if(drift ==0 ) break;
duration++;
break;
case 1://2mbps
*ext=0;
duration = ((len+4)<<4) /0x4;
drift = ((len+4)<<4) % 0x4;
if(drift ==0 ) break;
duration++;
break;
case 2: //5.5mbps
*ext=0;
duration = ((len+4)<<4) /0xb;
drift = ((len+4)<<4) % 0xb;
if(drift ==0 )
break;
duration++;
break;
default:
case 3://11mbps
*ext=0;
duration = ((len+4)<<4) /0x16;
drift = ((len+4)<<4) % 0x16;
if(drift ==0 )
break;
duration++;
if(drift > 6)
break;
*ext=1;
break;
}
return duration;
}
void rtl8180_prepare_beacon(struct net_device *dev)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct sk_buff *skb;
u16 word = read_nic_word(dev, BcnItv);
word &= ~BcnItv_BcnItv; // clear Bcn_Itv
word |= cpu_to_le16(priv->ieee80211->current_network.beacon_interval);//0x64;
write_nic_word(dev, BcnItv, word);
skb = ieee80211_get_beacon(priv->ieee80211);
if(skb){
rtl8180_tx(dev,skb->data,skb->len,BEACON_PRIORITY,
0,0,ieeerate2rtlrate(priv->ieee80211->basic_rate));
dev_kfree_skb_any(skb);
}
#if 0
//DMESG("size %x",len);
if(*tail & (1<<31)){
//DMESG("No more beacon TX desc");
return ;
}
//while(! (*tail & (1<<31))){
*tail= 0; // zeroes header
*tail = *tail| (1<<29) ; //fist segment of the packet
*tail = (*tail) | (1<<28); // last segment
// *tail = *tail | (1<<18); // this is a beacon frame
*(tail+3)=*(tail+3) &~ 0xfff;
*(tail+3)=*(tail+3) | len; // buffer lenght
*tail = *tail |len;
// zeroes the second 32-bits dword of the descriptor
*(tail+1)= 0;
*tail = *tail | (rate << 24);
duration = rtl8180_len2duration(len,rate,&ext);
*(tail+1) = *(tail+1) | ((duration & 0x7fff)<<16);
*tail = *tail | (1<<31);
//^ descriptor ready to be txed
if((tail - begin)/8 == priv->txbeaconcount-1)
tail=begin;
else
tail=tail+8;
//}
#endif
}
/* This function do the real dirty work: it enqueues a TX command
* descriptor in the ring buffer, copyes the frame in a TX buffer
* and kicks the NIC to ensure it does the DMA transfer.
*/
short rtl8180_tx(struct net_device *dev, u8* txbuf, int len, int priority,
short morefrag, short descfrag, int rate)
{
struct r8180_priv *priv = ieee80211_priv(dev);
u32 *tail,*temp_tail;
u32 *begin;
u32 *buf;
int i;
int remain;
int buflen;
int count;
//u16 AckCtsTime;
//u16 FrameTime;
u16 duration;
short ext;
struct buffer* buflist;
//unsigned long flags;
#ifdef CONFIG_RTL8185B
struct ieee80211_hdr_3addr *frag_hdr = (struct ieee80211_hdr_3addr *)txbuf;
u8 dest[ETH_ALEN];
u8 bUseShortPreamble = 0;
u8 bCTSEnable = 0;
u8 bRTSEnable = 0;
//u16 RTSRate = 22;
//u8 RetryLimit = 0;
u16 Duration = 0;
u16 RtsDur = 0;
u16 ThisFrameTime = 0;
u16 TxDescDuration = 0;
u8 ownbit_flag = false; //added by david woo for sync Tx, 2007.12.14
#endif
switch(priority) {
case MANAGE_PRIORITY:
tail=priv->txmapringtail;
begin=priv->txmapring;
buflist = priv->txmapbufstail;
count = priv->txringcount;
break;
case BK_PRIORITY:
tail=priv->txbkpringtail;
begin=priv->txbkpring;
buflist = priv->txbkpbufstail;
count = priv->txringcount;
break;
case BE_PRIORITY:
tail=priv->txbepringtail;
begin=priv->txbepring;
buflist = priv->txbepbufstail;
count = priv->txringcount;
break;
case VI_PRIORITY:
tail=priv->txvipringtail;
begin=priv->txvipring;
buflist = priv->txvipbufstail;
count = priv->txringcount;
break;
case VO_PRIORITY:
tail=priv->txvopringtail;
begin=priv->txvopring;
buflist = priv->txvopbufstail;
count = priv->txringcount;
break;
case HI_PRIORITY:
tail=priv->txhpringtail;
begin=priv->txhpring;
buflist = priv->txhpbufstail;
count = priv->txringcount;
break;
case BEACON_PRIORITY:
tail=priv->txbeaconringtail;
begin=priv->txbeaconring;
buflist = priv->txbeaconbufstail;
count = priv->txbeaconcount;
break;
default:
return -1;
break;
}
//printk("in rtl8180_tx(): rate is %d\n",priv->ieee80211->rate);
#if 1
memcpy(&dest, frag_hdr->addr1, ETH_ALEN);
if (is_multicast_ether_addr(dest) ||
is_broadcast_ether_addr(dest))
{
Duration = 0;
RtsDur = 0;
bRTSEnable = 0;
bCTSEnable = 0;
ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate), 0, bUseShortPreamble);
TxDescDuration = ThisFrameTime;
} else {// Unicast packet
//u8 AckRate;
u16 AckTime;
//YJ,add,080828,for Keep alive
priv->NumTxUnicast++;
// Figure out ACK rate according to BSS basic rate and Tx rate, 2006.03.08 by rcnjko.
//AckRate = ComputeAckRate( pMgntInfo->mBrates, (u1Byte)(pTcb->DataRate) );
// Figure out ACK time according to the AckRate and assume long preamble is used on receiver, 2006.03.08, by rcnjko.
//AckTime = ComputeTxTime( sAckCtsLng/8, AckRate, FALSE, FALSE);
//For simplicity, just use the 1M basic rate
//AckTime = ComputeTxTime(14, 540,0, 0); // AckCTSLng = 14 use 1M bps send
AckTime = ComputeTxTime(14, 10,0, 0); // AckCTSLng = 14 use 1M bps send
//AckTime = ComputeTxTime(14, 2,false, false); // AckCTSLng = 14 use 1M bps send
if ( ((len + sCrcLng) > priv->rts) && priv->rts )
{ // RTS/CTS.
u16 RtsTime, CtsTime;
//u16 CtsRate;
bRTSEnable = 1;
bCTSEnable = 0;
// Rate and time required for RTS.
RtsTime = ComputeTxTime( sAckCtsLng/8,priv->ieee80211->basic_rate, 0, 0);
// Rate and time required for CTS.
CtsTime = ComputeTxTime(14, 10,0, 0); // AckCTSLng = 14 use 1M bps send
// Figure out time required to transmit this frame.
ThisFrameTime = ComputeTxTime(len + sCrcLng,
rtl8180_rate2rate(rate),
0,
bUseShortPreamble);
// RTS-CTS-ThisFrame-ACK.
RtsDur = CtsTime + ThisFrameTime + AckTime + 3*aSifsTime;
TxDescDuration = RtsTime + RtsDur;
}
else {// Normal case.
bCTSEnable = 0;
bRTSEnable = 0;
RtsDur = 0;
ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate), 0, bUseShortPreamble);
TxDescDuration = ThisFrameTime + aSifsTime + AckTime;
}
if(!(frag_hdr->frame_ctl & IEEE80211_FCTL_MOREFRAGS)) { //no more fragment
// ThisFrame-ACK.
Duration = aSifsTime + AckTime;
} else { // One or more fragments remained.
u16 NextFragTime;
NextFragTime = ComputeTxTime( len + sCrcLng, //pretend following packet length equal current packet
rtl8180_rate2rate(rate),
0,
bUseShortPreamble );
//ThisFrag-ACk-NextFrag-ACK.
Duration = NextFragTime + 3*aSifsTime + 2*AckTime;
}
} // End of Unicast packet
frag_hdr->duration_id = Duration;
#endif
buflen=priv->txbuffsize;
remain=len;
temp_tail = tail;
//printk("================================>buflen = %d, remain = %d!\n", buflen,remain);
while(remain!=0){
#ifdef DEBUG_TX_FRAG
DMESG("TX iteration");
#endif
#ifdef DEBUG_TX
DMESG("TX: filling descriptor %x",(u32)tail);
#endif
mb();
if(!buflist){
DMESGE("TX buffer error, cannot TX frames. pri %d.", priority);
//spin_unlock_irqrestore(&priv->tx_lock,flags);
return -1;
}
buf=buflist->buf;
if( (*tail & (1<<31)) && (priority != BEACON_PRIORITY)){
DMESGW("No more TX desc, returning %x of %x",
remain,len);
priv->stats.txrdu++;
#ifdef DEBUG_TX_DESC
check_tx_ring(dev,priority);
// netif_stop_queue(dev);
// netif_carrier_off(dev);
#endif
// spin_unlock_irqrestore(&priv->tx_lock,flags);
return remain;
}
*tail= 0; // zeroes header
*(tail+1) = 0;
*(tail+3) = 0;
*(tail+5) = 0;
*(tail+6) = 0;
*(tail+7) = 0;
if(priv->card_8185){
//FIXME: this should be triggered by HW encryption parameters.
*tail |= (1<<15); //no encrypt
// *tail |= (1<<30); //raise int when completed
}
// *tail = *tail | (1<<16);
if(remain==len && !descfrag) {
ownbit_flag = false; //added by david woo,2007.12.14
#ifdef DEBUG_TX_FRAG
DMESG("First descriptor");
#endif
*tail = *tail| (1<<29) ; //fist segment of the packet
*tail = *tail |(len);
} else {
ownbit_flag = true;
}
for(i=0;i<buflen&& remain >0;i++,remain--){
((u8*)buf)[i]=txbuf[i]; //copy data into descriptor pointed DMAble buffer
if(remain == 4 && i+4 >= buflen) break;
/* ensure the last desc has at least 4 bytes payload */
}
txbuf = txbuf + i;
*(tail+3)=*(tail+3) &~ 0xfff;
*(tail+3)=*(tail+3) | i; // buffer lenght
// Use short preamble or not
if (priv->ieee80211->current_network.capability&WLAN_CAPABILITY_SHORT_PREAMBLE)
if (priv->plcp_preamble_mode==1 && rate!=0) // short mode now, not long!
// *tail |= (1<<16); // enable short preamble mode.
#ifdef CONFIG_RTL8185B
if(bCTSEnable) {
*tail |= (1<<18);
}
if(bRTSEnable) //rts enable
{
*tail |= ((ieeerate2rtlrate(priv->ieee80211->basic_rate))<<19);//RTS RATE
*tail |= (1<<23);//rts enable
*(tail+1) |=(RtsDur&0xffff);//RTS Duration
}
*(tail+3) |= ((TxDescDuration&0xffff)<<16); //DURATION
// *(tail+3) |= (0xe6<<16);
*(tail+5) |= (11<<8);//(priv->retry_data<<8); //retry lim ;
#else
//Use RTS or not
#ifdef CONFIG_RTL8187B
if ( (len>priv->rts) && priv->rts && priority!=MANAGE_PRIORITY){
#else
if ( (len>priv->rts) && priv->rts && priority==LOW_PRIORITY){
#endif
*tail |= (1<<23); //enalbe RTS function
*tail |= (0<<19); //use 1M bps send RTS packet
AckCtsTime = ComputeTxTime(14, 10,0, 0); // AckCTSLng = 14 use 1M bps send
FrameTime = ComputeTxTime(len + 4, rtl8180_rate2rate(rate), 0, *tail&(1<<16));
// RTS/CTS time is calculate as follow
duration = FrameTime + 3*10 + 2*AckCtsTime; //10us is the SifsTime;
*(tail+1) |= duration; //Need to edit here! ----hikaru
}else{
*(tail+1)= 0; // zeroes the second 32-bits dword of the descriptor
}
#endif
*tail = *tail | ((rate&0xf) << 24);
//DMESG("rate %d",rate);
if(priv->card_8185){
#if 0
*(tail+5)&= ~(1<<24); /* tx ant 0 */
*(tail+5) &= ~(1<<23); /* random tx agc 23-16 */
*(tail+5) |= (1<<22)|(1<<21)|(1<<20)|(1<<19)|(1<<18)|(1<<17)|(1<<16);
*(tail+5) &=
~((1<<15)|(1<<14)|(1<<13)|(1<<12)|(1<<11)|(1<<10)|(1<<9)|(1<<8));
*(tail+5) |= (7<<8); // Max retry limit
*(tail+5) &= ~((1<<7)|(1<<6)|(1<<5)|(1<<4)|(1<<3)|(1<<2)|(1<<1)|(1<<0));
*(tail+5) |= (8<<4); // Max contention window
*(tail+6) |= 4; // Min contention window
#endif
// *(tail+5) = 0;
}
/* hw_plcp_len is not used for rtl8180 chip */
/* FIXME */
if(priv->card_8185 == 0 || !priv->hw_plcp_len){
duration = rtl8180_len2duration(len,
rate,&ext);
#ifdef DEBUG_TX
DMESG("PLCP duration %d",duration );
//DMESG("drift %d",drift);
DMESG("extension %s", (ext==1) ? "on":"off");
#endif
*(tail+1) = *(tail+1) | ((duration & 0x7fff)<<16);
if(ext) *(tail+1) = *(tail+1) |(1<<31); //plcp length extension
}
if(morefrag) *tail = (*tail) | (1<<17); // more fragment
if(!remain) *tail = (*tail) | (1<<28); // last segment of frame
#ifdef DEBUG_TX_FRAG
if(!remain)DMESG("Last descriptor");
if(morefrag)DMESG("More frag");
#endif
*(tail+5) = *(tail+5)|(2<<27);
*(tail+7) = *(tail+7)|(1<<4);
wmb();
if(ownbit_flag)
{
*tail = *tail | (1<<31); // descriptor ready to be txed
}
#ifdef DEBUG_TX_DESC2
printk("tx desc is:\n");
DMESG("%8x %8x %8x %8x %8x %8x %8x %8x", tail[0], tail[1], tail[2], tail[3],
tail[4], tail[5], tail[6], tail[7]);
#endif
if((tail - begin)/8 == count-1)
tail=begin;
else
tail=tail+8;
buflist=buflist->next;
mb();
switch(priority) {
case MANAGE_PRIORITY:
priv->txmapringtail=tail;
priv->txmapbufstail=buflist;
break;
case BK_PRIORITY:
priv->txbkpringtail=tail;
priv->txbkpbufstail=buflist;
break;
case BE_PRIORITY:
priv->txbepringtail=tail;
priv->txbepbufstail=buflist;
break;
case VI_PRIORITY:
priv->txvipringtail=tail;
priv->txvipbufstail=buflist;
break;
case VO_PRIORITY:
priv->txvopringtail=tail;
priv->txvopbufstail=buflist;
break;
case HI_PRIORITY:
priv->txhpringtail=tail;
priv->txhpbufstail = buflist;
break;
case BEACON_PRIORITY:
/* the HW seems to be happy with the 1st
* descriptor filled and the 2nd empty...
* So always update descriptor 1 and never
* touch 2nd
*/
// priv->txbeaconringtail=tail;
// priv->txbeaconbufstail=buflist;
break;
}
//rtl8180_dma_kick(dev,priority);
}
*temp_tail = *temp_tail | (1<<31); // descriptor ready to be txed
rtl8180_dma_kick(dev,priority);
//spin_unlock_irqrestore(&priv->tx_lock,flags);
return 0;
}
void rtl8180_irq_rx_tasklet(struct r8180_priv * priv);
void rtl8180_link_change(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
u16 beacon_interval;
struct ieee80211_network *net = &priv->ieee80211->current_network;
// rtl8180_adapter_start(dev);
rtl8180_update_msr(dev);
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
write_nic_dword(dev,BSSID,((u32*)net->bssid)[0]);
write_nic_word(dev,BSSID+4,((u16*)net->bssid)[2]);
beacon_interval = read_nic_dword(dev,BEACON_INTERVAL);
beacon_interval &= ~ BEACON_INTERVAL_MASK;
beacon_interval |= net->beacon_interval;
write_nic_dword(dev, BEACON_INTERVAL, beacon_interval);
rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
/*
u16 atim = read_nic_dword(dev,ATIM);
u16 = u16 &~ ATIM_MASK;
u16 = u16 | beacon->atim;
*/
#if 0
if (net->capability & WLAN_CAPABILITY_PRIVACY) {
if (priv->hw_wep) {
DMESG("Enabling hardware WEP support");
rtl8180_set_hw_wep(dev);
priv->ieee80211->host_encrypt=0;
priv->ieee80211->host_decrypt=0;
}
#ifndef CONFIG_IEEE80211_NOWEP
else {
priv->ieee80211->host_encrypt=1;
priv->ieee80211->host_decrypt=1;
}
#endif
}
#ifndef CONFIG_IEEE80211_NOWEP
else{
priv->ieee80211->host_encrypt=0;
priv->ieee80211->host_decrypt=0;
}
#endif
#endif
if(priv->card_8185)
rtl8180_set_chan(dev, priv->chan);
}
void rtl8180_rq_tx_ack(struct net_device *dev){
struct r8180_priv *priv = ieee80211_priv(dev);
// printk("====================>%s\n",__func__);
write_nic_byte(dev,CONFIG4,read_nic_byte(dev,CONFIG4)|CONFIG4_PWRMGT);
priv->ack_tx_to_ieee = 1;
}
short rtl8180_is_tx_queue_empty(struct net_device *dev){
struct r8180_priv *priv = ieee80211_priv(dev);
u32* d;
for (d = priv->txmapring;
d < priv->txmapring + priv->txringcount;d+=8)
if(*d & (1<<31)) return 0;
for (d = priv->txbkpring;
d < priv->txbkpring + priv->txringcount;d+=8)
if(*d & (1<<31)) return 0;
for (d = priv->txbepring;
d < priv->txbepring + priv->txringcount;d+=8)
if(*d & (1<<31)) return 0;
for (d = priv->txvipring;
d < priv->txvipring + priv->txringcount;d+=8)
if(*d & (1<<31)) return 0;
for (d = priv->txvopring;
d < priv->txvopring + priv->txringcount;d+=8)
if(*d & (1<<31)) return 0;
for (d = priv->txhpring;
d < priv->txhpring + priv->txringcount;d+=8)
if(*d & (1<<31)) return 0;
return 1;
}
/* FIXME FIXME 5msecs is random */
#define HW_WAKE_DELAY 5
void rtl8180_hw_wakeup(struct net_device *dev)
{
unsigned long flags;
struct r8180_priv *priv = ieee80211_priv(dev);
spin_lock_irqsave(&priv->ps_lock,flags);
//DMESG("Waken up!");
write_nic_byte(dev,CONFIG4,read_nic_byte(dev,CONFIG4)&~CONFIG4_PWRMGT);
if(priv->rf_wakeup)
priv->rf_wakeup(dev);
// mdelay(HW_WAKE_DELAY);
spin_unlock_irqrestore(&priv->ps_lock,flags);
}
void rtl8180_hw_sleep_down(struct net_device *dev)
{
unsigned long flags;
struct r8180_priv *priv = ieee80211_priv(dev);
spin_lock_irqsave(&priv->ps_lock,flags);
//DMESG("Sleep!");
if(priv->rf_sleep)
priv->rf_sleep(dev);
spin_unlock_irqrestore(&priv->ps_lock,flags);
}
void rtl8180_hw_sleep(struct net_device *dev, u32 th, u32 tl)
{
struct r8180_priv *priv = ieee80211_priv(dev);
u32 rb = jiffies;
unsigned long flags;
spin_lock_irqsave(&priv->ps_lock,flags);
/* Writing HW register with 0 equals to disable
* the timer, that is not really what we want
*/
tl -= MSECS(4+16+7);
//if(tl == 0) tl = 1;
/* FIXME HACK FIXME HACK */
// force_pci_posting(dev);
//mdelay(1);
// rb = read_nic_dword(dev, TSFTR);
/* If the interval in witch we are requested to sleep is too
* short then give up and remain awake
*/
if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
spin_unlock_irqrestore(&priv->ps_lock,flags);
printk("too short to sleep\n");
return;
}
// write_nic_dword(dev, TimerInt, tl);
// rb = read_nic_dword(dev, TSFTR);
{
u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
// if (tl<rb)
//lzm,add,080828
priv->DozePeriodInPast2Sec += jiffies_to_msecs(tmp);
queue_delayed_work(priv->ieee80211->wq, &priv->ieee80211->hw_wakeup_wq, tmp); //as tl may be less than rb
}
/* if we suspect the TimerInt is gone beyond tl
* while setting it, then give up
*/
#if 1
if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
((tl < rb) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))) {
spin_unlock_irqrestore(&priv->ps_lock,flags);
return;
}
#endif
// if(priv->rf_sleep)
// priv->rf_sleep(dev);
queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_sleep_wq);
spin_unlock_irqrestore(&priv->ps_lock,flags);
}
//void rtl8180_wmm_param_update(struct net_device *dev,u8 *ac_param)
#if LINUX_VERSION_CODE >=KERNEL_VERSION(2,6,20)
void rtl8180_wmm_param_update(struct work_struct * work)
{
struct ieee80211_device * ieee = container_of(work, struct ieee80211_device,wmm_param_update_wq);
//struct r8180_priv *priv = (struct r8180_priv*)(ieee->priv);
struct net_device *dev = ieee->dev;
#else
void rtl8180_wmm_param_update(struct ieee80211_device *ieee)
{
struct net_device *dev = ieee->dev;
struct r8180_priv *priv = ieee80211_priv(dev);
#endif
u8 *ac_param = (u8 *)(ieee->current_network.wmm_param);
u8 mode = ieee->current_network.mode;
AC_CODING eACI;
AC_PARAM AcParam;
PAC_PARAM pAcParam;
u8 i;
#ifndef CONFIG_RTL8185B
//for legacy 8185 keep the PARAM unchange.
return;
#else
if(!ieee->current_network.QoS_Enable){
//legacy ac_xx_param update
AcParam.longData = 0;
AcParam.f.AciAifsn.f.AIFSN = 2; // Follow 802.11 DIFS.
AcParam.f.AciAifsn.f.ACM = 0;
AcParam.f.Ecw.f.ECWmin = 3; // Follow 802.11 CWmin.
AcParam.f.Ecw.f.ECWmax = 7; // Follow 802.11 CWmax.
AcParam.f.TXOPLimit = 0;
for(eACI = 0; eACI < AC_MAX; eACI++){
AcParam.f.AciAifsn.f.ACI = (u8)eACI;
{
u8 u1bAIFS;
u32 u4bAcParam;
pAcParam = (PAC_PARAM)(&AcParam);
// Retrive paramters to udpate.
u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN *(((mode&IEEE_G) == IEEE_G)?9:20) + aSifsTime;
u4bAcParam = ((((u32)(pAcParam->f.TXOPLimit))<<AC_PARAM_TXOP_LIMIT_OFFSET)|
(((u32)(pAcParam->f.Ecw.f.ECWmax))<<AC_PARAM_ECW_MAX_OFFSET)|
(((u32)(pAcParam->f.Ecw.f.ECWmin))<<AC_PARAM_ECW_MIN_OFFSET)|
(((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
switch(eACI){
case AC1_BK:
write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
break;
case AC0_BE:
write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
break;
case AC2_VI:
write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
break;
case AC3_VO:
write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
break;
default:
printk(KERN_WARNING "SetHwReg8185():invalid ACI: %d!\n", eACI);
break;
}
}
}
return;
}
for(i = 0; i < AC_MAX; i++){
//AcParam.longData = 0;
pAcParam = (AC_PARAM * )ac_param;
{
AC_CODING eACI;
u8 u1bAIFS;
u32 u4bAcParam;
// Retrive paramters to udpate.
eACI = pAcParam->f.AciAifsn.f.ACI;
//Mode G/A: slotTimeTimer = 9; Mode B: 20
u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN * (((mode&IEEE_G) == IEEE_G)?9:20) + aSifsTime;
u4bAcParam = ( (((u32)(pAcParam->f.TXOPLimit)) << AC_PARAM_TXOP_LIMIT_OFFSET) |
(((u32)(pAcParam->f.Ecw.f.ECWmax)) << AC_PARAM_ECW_MAX_OFFSET) |
(((u32)(pAcParam->f.Ecw.f.ECWmin)) << AC_PARAM_ECW_MIN_OFFSET) |
(((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
switch(eACI){
case AC1_BK:
write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
break;
case AC0_BE:
write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
break;
case AC2_VI:
write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
break;
case AC3_VO:
write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
break;
default:
printk(KERN_WARNING "SetHwReg8185(): invalid ACI: %d !\n", eACI);
break;
}
}
ac_param += (sizeof(AC_PARAM));
}
#endif
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_tx_irq_wq(struct work_struct *work);
#else
void rtl8180_tx_irq_wq(struct net_device *dev);
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_restart_wq(struct work_struct *work);
//void rtl8180_rq_tx_ack(struct work_struct *work);
#else
void rtl8180_restart_wq(struct net_device *dev);
//void rtl8180_rq_tx_ack(struct net_device *dev);
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_watch_dog_wq(struct work_struct *work);
#else
void rtl8180_watch_dog_wq(struct net_device *dev);
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_hw_wakeup_wq(struct work_struct *work);
#else
void rtl8180_hw_wakeup_wq(struct net_device *dev);
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_hw_sleep_wq(struct work_struct *work);
#else
void rtl8180_hw_sleep_wq(struct net_device *dev);
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_sw_antenna_wq(struct work_struct *work);
#else
void rtl8180_sw_antenna_wq(struct net_device *dev);
#endif
void rtl8180_watch_dog(struct net_device *dev);
void watch_dog_adaptive(unsigned long data)
{
struct r8180_priv* priv = ieee80211_priv((struct net_device *)data);
// DMESG("---->watch_dog_adaptive()\n");
if(!priv->up)
{
DMESG("<----watch_dog_adaptive():driver is not up!\n");
return;
}
// queue_work(priv->ieee80211->wq,&priv->ieee80211->watch_dog_wq);
//{by amy 080312
#if 1
// Tx High Power Mechanism.
#ifdef HIGH_POWER
if(CheckHighPower((struct net_device *)data))
{
queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->tx_pw_wq);
}
#endif
#ifdef CONFIG_RTL818X_S
// Tx Power Tracking on 87SE.
#ifdef TX_TRACK
//if( priv->bTxPowerTrack ) //lzm mod 080826
if( CheckTxPwrTracking((struct net_device *)data));
TxPwrTracking87SE((struct net_device *)data);
#endif
#endif
// Perform DIG immediately.
#ifdef SW_DIG
if(CheckDig((struct net_device *)data) == true)
{
queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_dig_wq);
}
#endif
#endif
//by amy 080312}
rtl8180_watch_dog((struct net_device *)data);
queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->GPIOChangeRFWorkItem);
priv->watch_dog_timer.expires = jiffies + MSECS(IEEE80211_WATCH_DOG_TIME);
add_timer(&priv->watch_dog_timer);
// DMESG("<----watch_dog_adaptive()\n");
}
#ifdef ENABLE_DOT11D
static CHANNEL_LIST ChannelPlan[] = {
{{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64},19}, //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,36,40,44,48,52,56,60,64},21}, //Spain. Change to ETSI.
{{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //France. Change to ETSI.
{{14,36,40,44,48,52,56,60,64},9}, //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,36,40,44,48,52,56,60,64},21}, //Israel.
{{1,2,3,4,5,6,7,8,9,10,11,12,13,34,38,42,46},17}, // For 11a , TELEC
{{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
{{1,2,3,4,5,6,7,8,9,10,11,12,13},13} //world wide 13: ch1~ch11 active scan, ch12~13 passive //lzm add 080826
};
static void rtl8180_set_channel_map(u8 channel_plan, struct ieee80211_device *ieee)
{
int i;
//lzm add 080826
ieee->MinPassiveChnlNum=MAX_CHANNEL_NUMBER+1;
ieee->IbssStartChnl=0;
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:
{
Dot11d_Init(ieee);
ieee->bGlobalDomain = false;
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] <= 14)
GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
}
}
break;
}
case COUNTRY_CODE_GLOBAL_DOMAIN:
{
GET_DOT11D_INFO(ieee)->bEnabled = 0;
Dot11d_Reset(ieee);
ieee->bGlobalDomain = true;
break;
}
case COUNTRY_CODE_WORLD_WIDE_13_INDEX://lzm add 080826
{
ieee->MinPassiveChnlNum=12;
ieee->IbssStartChnl= 10;
break;
}
default:
{
Dot11d_Init(ieee);
ieee->bGlobalDomain = false;
memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
for (i=1;i<=14;i++)
{
GET_DOT11D_INFO(ieee)->channel_map[i] = 1;
}
break;
}
}
}
#endif
//Add for RF power on power off by lizhaoming 080512
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void GPIOChangeRFWorkItemCallBack(struct work_struct *work);
#else
void GPIOChangeRFWorkItemCallBack(struct ieee80211_device *ieee);
#endif
//YJ,add,080828
static void rtl8180_statistics_init(struct Stats *pstats)
{
memset(pstats, 0, sizeof(struct Stats));
}
static void rtl8180_link_detect_init(plink_detect_t plink_detect)
{
memset(plink_detect, 0, sizeof(link_detect_t));
plink_detect->SlotNum = DEFAULT_SLOT_NUM;
}
//YJ,add,080828,end
short rtl8180_init(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
u16 word;
u16 version;
u8 hw_version;
//u8 config3;
u32 usValue;
u16 tmpu16;
int i, j;
#ifdef ENABLE_DOT11D
#if 0
for(i=0;i<0xFF;i++) {
if(i%16 == 0)
printk("\n[%x]: ", i/16);
printk("\t%4.4x", eprom_read(dev,i));
}
#endif
priv->channel_plan = eprom_read(dev, EEPROM_COUNTRY_CODE>>1) & 0xFF;
if(priv->channel_plan > COUNTRY_CODE_GLOBAL_DOMAIN){
printk("rtl8180_init:Error channel plan! Set to default.\n");
priv->channel_plan = 0;
}
//priv->channel_plan = 9; //Global Domain
DMESG("Channel plan is %d\n",priv->channel_plan);
rtl8180_set_channel_map(priv->channel_plan, priv->ieee80211);
#else
int ch;
//Set Default Channel Plan
if(!channels){
DMESG("No channels, aborting");
return -1;
}
ch=channels;
priv->channel_plan = 0;//hikaru
// set channels 1..14 allowed in given locale
for (i=1; i<=14; i++) {
(priv->ieee80211->channel_map)[i] = (u8)(ch & 0x01);
ch >>= 1;
}
#endif
//memcpy(priv->stats,0,sizeof(struct Stats));
//FIXME: these constants are placed in a bad pleace.
priv->txbuffsize = 2048;//1024;
priv->txringcount = 32;//32;
priv->rxbuffersize = 2048;//1024;
priv->rxringcount = 64;//32;
priv->txbeaconcount = 2;
priv->rx_skb_complete = 1;
//priv->txnp_pending.ispending=0;
/* ^^ the SKB does not containt a partial RXed
* packet (is empty)
*/
#ifdef CONFIG_RTL8185B
#ifdef CONFIG_RTL818X_S
priv->RegThreeWireMode = HW_THREE_WIRE_SI;
#else
priv->RegThreeWireMode = SW_THREE_WIRE;
#endif
#endif
//Add for RF power on power off by lizhaoming 080512
priv->RFChangeInProgress = false;
priv->SetRFPowerStateInProgress = false;
priv->RFProgType = 0;
priv->bInHctTest = false;
priv->irq_enabled=0;
//YJ,modified,080828
#if 0
priv->stats.rxdmafail=0;
priv->stats.txrdu=0;
priv->stats.rxrdu=0;
priv->stats.rxnolast=0;
priv->stats.rxnodata=0;
//priv->stats.rxreset=0;
//priv->stats.rxwrkaround=0;
priv->stats.rxnopointer=0;
priv->stats.txnperr=0;
priv->stats.txresumed=0;
priv->stats.rxerr=0;
priv->stats.rxoverflow=0;
priv->stats.rxint=0;
priv->stats.txnpokint=0;
priv->stats.txhpokint=0;
priv->stats.txhperr=0;
priv->stats.ints=0;
priv->stats.shints=0;
priv->stats.txoverflow=0;
priv->stats.txbeacon=0;
priv->stats.txbeaconerr=0;
priv->stats.txlperr=0;
priv->stats.txlpokint=0;
priv->stats.txretry=0;//tony 20060601
priv->stats.rxcrcerrmin=0;
priv->stats.rxcrcerrmid=0;
priv->stats.rxcrcerrmax=0;
priv->stats.rxicverr=0;
#else
rtl8180_statistics_init(&priv->stats);
rtl8180_link_detect_init(&priv->link_detect);
#endif
//YJ,modified,080828,end
priv->ack_tx_to_ieee = 0;
priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
priv->ieee80211->iw_mode = IW_MODE_INFRA;
priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;
priv->ieee80211->active_scan = 1;
priv->ieee80211->rate = 110; //11 mbps
priv->ieee80211->modulation = IEEE80211_CCK_MODULATION;
priv->ieee80211->host_encrypt = 1;
priv->ieee80211->host_decrypt = 1;
priv->ieee80211->sta_wake_up = rtl8180_hw_wakeup;
priv->ieee80211->ps_request_tx_ack = rtl8180_rq_tx_ack;
priv->ieee80211->enter_sleep_state = rtl8180_hw_sleep;
priv->ieee80211->ps_is_queue_empty = rtl8180_is_tx_queue_empty;
priv->hw_wep = hwwep;
priv->prism_hdr=0;
priv->dev=dev;
priv->retry_rts = DEFAULT_RETRY_RTS;
priv->retry_data = DEFAULT_RETRY_DATA;
priv->RFChangeInProgress = false;
priv->SetRFPowerStateInProgress = false;
priv->RFProgType = 0;
priv->bInHctTest = false;
priv->bInactivePs = true;//false;
priv->ieee80211->bInactivePs = priv->bInactivePs;
priv->bSwRfProcessing = false;
priv->eRFPowerState = eRfOff;
priv->RfOffReason = 0;
priv->LedStrategy = SW_LED_MODE0;
//priv->NumRxOkInPeriod = 0; //YJ,del,080828
//priv->NumTxOkInPeriod = 0; //YJ,del,080828
priv->TxPollingTimes = 0;//lzm add 080826
priv->bLeisurePs = true;
priv->dot11PowerSaveMode = eActive;
//by amy for antenna
priv->AdMinCheckPeriod = 5;
priv->AdMaxCheckPeriod = 10;
// Lower signal strength threshold to fit the HW participation in antenna diversity. +by amy 080312
priv->AdMaxRxSsThreshold = 30;//60->30
priv->AdRxSsThreshold = 20;//50->20
priv->AdCheckPeriod = priv->AdMinCheckPeriod;
priv->AdTickCount = 0;
priv->AdRxSignalStrength = -1;
priv->RegSwAntennaDiversityMechanism = 0;
priv->RegDefaultAntenna = 0;
priv->SignalStrength = 0;
priv->AdRxOkCnt = 0;
priv->CurrAntennaIndex = 0;
priv->AdRxSsBeforeSwitched = 0;
init_timer(&priv->SwAntennaDiversityTimer);
priv->SwAntennaDiversityTimer.data = (unsigned long)dev;
priv->SwAntennaDiversityTimer.function = (void *)SwAntennaDiversityTimerCallback;
//by amy for antenna
//{by amy 080312
priv->bDigMechanism = 1;
priv->InitialGain = 6;
priv->bXtalCalibration = false;
priv->XtalCal_Xin = 0;
priv->XtalCal_Xout = 0;
priv->bTxPowerTrack = false;
priv->ThermalMeter = 0;
priv->FalseAlarmRegValue = 0;
priv->RegDigOfdmFaUpTh = 0xc; // Upper threhold of OFDM false alarm, which is used in DIG.
priv->DIG_NumberFallbackVote = 0;
priv->DIG_NumberUpgradeVote = 0;
priv->LastSignalStrengthInPercent = 0;
priv->Stats_SignalStrength = 0;
priv->LastRxPktAntenna = 0;
priv->SignalQuality = 0; // in 0-100 index.
priv->Stats_SignalQuality = 0;
priv->RecvSignalPower = 0; // in dBm.
priv->Stats_RecvSignalPower = 0;
priv->AdMainAntennaRxOkCnt = 0;
priv->AdAuxAntennaRxOkCnt = 0;
priv->bHWAdSwitched = false;
priv->bRegHighPowerMechanism = true;
priv->RegHiPwrUpperTh = 77;
priv->RegHiPwrLowerTh = 75;
priv->RegRSSIHiPwrUpperTh = 70;
priv->RegRSSIHiPwrLowerTh = 20;
priv->bCurCCKPkt = false;
priv->UndecoratedSmoothedSS = -1;
priv->bToUpdateTxPwr = false;
priv->CurCCKRSSI = 0;
priv->RxPower = 0;
priv->RSSI = 0;
//YJ,add,080828
priv->NumTxOkTotal = 0;
priv->NumTxUnicast = 0;
priv->keepAliveLevel = DEFAULT_KEEP_ALIVE_LEVEL;
priv->PowerProfile = POWER_PROFILE_AC;
//YJ,add,080828,end
//by amy for rate adaptive
priv->CurrRetryCnt=0;
priv->LastRetryCnt=0;
priv->LastTxokCnt=0;
priv->LastRxokCnt=0;
priv->LastRetryRate=0;
priv->bTryuping=0;
priv->CurrTxRate=0;
priv->CurrRetryRate=0;
priv->TryupingCount=0;
priv->TryupingCountNoData=0;
priv->TryDownCountLowData=0;
priv->LastTxOKBytes=0;
priv->LastFailTxRate=0;
priv->LastFailTxRateSS=0;
priv->FailTxRateCount=0;
priv->LastTxThroughput=0;
priv->NumTxOkBytesTotal=0;
priv->ForcedDataRate = 0;
priv->RegBModeGainStage = 1;
//by amy for rate adaptive
//by amy 080312}
priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
spin_lock_init(&priv->irq_lock);
spin_lock_init(&priv->irq_th_lock);
spin_lock_init(&priv->tx_lock);
spin_lock_init(&priv->ps_lock);
spin_lock_init(&priv->rf_ps_lock);
sema_init(&priv->wx_sem,1);
sema_init(&priv->rf_state,1);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
INIT_WORK(&priv->reset_wq,(void*) rtl8180_restart_wq);
INIT_WORK(&priv->tx_irq_wq,(void*) rtl8180_tx_irq_wq);
INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8180_hw_wakeup_wq);
INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8180_hw_sleep_wq);
//INIT_DELAYED_WORK(&priv->ieee80211->watch_dog_wq,(void*) rtl8180_watch_dog_wq);
//INIT_DELAYED_WORK(&priv->ieee80211->sw_antenna_wq,(void*) rtl8180_sw_antenna_wq);
INIT_WORK(&priv->ieee80211->wmm_param_update_wq,(void*) rtl8180_wmm_param_update);
INIT_DELAYED_WORK(&priv->ieee80211->rate_adapter_wq,(void*)rtl8180_rate_adapter);//+by amy 080312
INIT_DELAYED_WORK(&priv->ieee80211->hw_dig_wq,(void*)rtl8180_hw_dig_wq);//+by amy 080312
INIT_DELAYED_WORK(&priv->ieee80211->tx_pw_wq,(void*)rtl8180_tx_pw_wq);//+by amy 080312
//add for RF power on power off by lizhaoming 080512
INIT_DELAYED_WORK(&priv->ieee80211->GPIOChangeRFWorkItem,(void*) GPIOChangeRFWorkItemCallBack);
#else
INIT_WORK(&priv->reset_wq,(void*) rtl8180_restart_wq,dev);
INIT_WORK(&priv->tx_irq_wq,(void*) rtl8180_tx_irq_wq,dev);
//INIT_WORK(&priv->ieee80211->watch_dog_wq,(void*) rtl8180_watch_dog_wq,dev);
INIT_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8180_hw_wakeup_wq,dev);
INIT_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8180_hw_sleep_wq,dev);
//INIT_WORK(&priv->ieee80211->sw_antenna_wq,(void*) rtl8180_sw_antenna_wq,dev);
INIT_WORK(&priv->ieee80211->wmm_param_update_wq,(void*) rtl8180_wmm_param_update,priv->ieee80211);
INIT_WORK(&priv->ieee80211->rate_adapter_wq,(void*)rtl8180_rate_adapter,dev);//+by amy 080312
INIT_WORK(&priv->ieee80211->hw_dig_wq,(void*)rtl8180_hw_dig_wq,dev);//+by amy 080312
INIT_WORK(&priv->ieee80211->tx_pw_wq,(void*)rtl8180_tx_pw_wq,dev);//+by amy 080312
//add for RF power on power off by lizhaoming 080512
INIT_WORK(&priv->ieee80211->GPIOChangeRFWorkItem,(void*) GPIOChangeRFWorkItemCallBack, priv->ieee80211);
#endif
//INIT_WORK(&priv->reset_wq,(void*) rtl8180_restart_wq,dev);
tasklet_init(&priv->irq_rx_tasklet,
(void(*)(unsigned long)) rtl8180_irq_rx_tasklet,
(unsigned long)priv);
//by amy
init_timer(&priv->watch_dog_timer);
priv->watch_dog_timer.data = (unsigned long)dev;
priv->watch_dog_timer.function = watch_dog_adaptive;
//by amy
//{by amy 080312
//by amy for rate adaptive
init_timer(&priv->rateadapter_timer);
priv->rateadapter_timer.data = (unsigned long)dev;
priv->rateadapter_timer.function = timer_rate_adaptive;
priv->RateAdaptivePeriod= RATE_ADAPTIVE_TIMER_PERIOD;
priv->bEnhanceTxPwr=false;
//by amy for rate adaptive
//by amy 080312}
//priv->ieee80211->func =
// kmalloc(sizeof(struct ieee80211_helper_functions),GFP_KERNEL);
//memset(priv->ieee80211->func, 0,
// sizeof(struct ieee80211_helper_functions));
priv->ieee80211->softmac_hard_start_xmit = rtl8180_hard_start_xmit;
priv->ieee80211->set_chan = rtl8180_set_chan;
priv->ieee80211->link_change = rtl8180_link_change;
priv->ieee80211->softmac_data_hard_start_xmit = rtl8180_hard_data_xmit;
priv->ieee80211->data_hard_stop = rtl8180_data_hard_stop;
priv->ieee80211->data_hard_resume = rtl8180_data_hard_resume;
priv->ieee80211->init_wmmparam_flag = 0;
priv->ieee80211->start_send_beacons = rtl8180_start_tx_beacon;
priv->ieee80211->stop_send_beacons = rtl8180_beacon_tx_disable;
priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
#ifdef CONFIG_RTL8185B
priv->MWIEnable = 0;
priv->ShortRetryLimit = 7;
priv->LongRetryLimit = 7;
priv->EarlyRxThreshold = 7;
priv->CSMethod = (0x01 << 29);
priv->TransmitConfig =
1<<TCR_DurProcMode_OFFSET | //for RTL8185B, duration setting by HW
(7<<TCR_MXDMA_OFFSET) | // Max DMA Burst Size per Tx DMA Burst, 7: reservied.
(priv->ShortRetryLimit<<TCR_SRL_OFFSET) | // Short retry limit
(priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
(0 ? TCR_SAT : 0); // FALSE: HW provies PLCP length and LENGEXT, TURE: SW proiveds them
priv->ReceiveConfig =
#ifdef CONFIG_RTL818X_S
#else
priv->CSMethod |
#endif
// RCR_ENMARP |
RCR_AMF | RCR_ADF | //accept management/data
RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
//RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
(7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
(priv->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
(priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT:0);
priv->IntrMask = IMR_TMGDOK | IMR_TBDER | IMR_THPDER |
IMR_THPDER | IMR_THPDOK |
IMR_TVODER | IMR_TVODOK |
IMR_TVIDER | IMR_TVIDOK |
IMR_TBEDER | IMR_TBEDOK |
IMR_TBKDER | IMR_TBKDOK |
IMR_RDU | // To handle the defragmentation not enough Rx descriptors case. Annie, 2006-03-27.
IMR_RER | IMR_ROK |
IMR_RQoSOK; // <NOTE> ROK and RQoSOK are mutually exclusive, so, we must handle RQoSOK interrupt to receive QoS frames, 2005.12.09, by rcnjko.
priv->InitialGain = 6;
#endif
hw_version =( read_nic_dword(dev, TCR) & TCR_HWVERID_MASK)>>TCR_HWVERID_SHIFT;
switch (hw_version){
#ifdef CONFIG_RTL8185B
case HW_VERID_R8185B_B:
#ifdef CONFIG_RTL818X_S
priv->card_8185 = VERSION_8187S_C;
DMESG("MAC controller is a RTL8187SE b/g");
priv->phy_ver = 2;
break;
#else
DMESG("MAC controller is a RTL8185B b/g");
priv->card_8185 = 3;
priv->phy_ver = 2;
break;
#endif
#endif
case HW_VERID_R8185_ABC:
DMESG("MAC controller is a RTL8185 b/g");
priv->card_8185 = 1;
/* you should not find a card with 8225 PHY ver < C*/
priv->phy_ver = 2;
break;
case HW_VERID_R8185_D:
DMESG("MAC controller is a RTL8185 b/g (V. D)");
priv->card_8185 = 2;
/* you should not find a card with 8225 PHY ver < C*/
priv->phy_ver = 2;
break;
case HW_VERID_R8180_ABCD:
DMESG("MAC controller is a RTL8180");
priv->card_8185 = 0;
break;
case HW_VERID_R8180_F:
DMESG("MAC controller is a RTL8180 (v. F)");
priv->card_8185 = 0;
break;
default:
DMESGW("MAC chip not recognized: version %x. Assuming RTL8180",hw_version);
priv->card_8185 = 0;
break;
}
if(priv->card_8185){
priv->ieee80211->modulation |= IEEE80211_OFDM_MODULATION;
priv->ieee80211->short_slot = 1;
}
/* you should not found any 8185 Ver B Card */
priv->card_8185_Bversion = 0;
#ifdef CONFIG_RTL8185B
#ifdef CONFIG_RTL818X_S
// just for sync 85
priv->card_type = PCI;
DMESG("This is a PCI NIC");
#else
config3 = read_nic_byte(dev, CONFIG3);
if(config3 & 0x8){
priv->card_type = CARDBUS;
DMESG("This is a CARDBUS NIC");
}
else if( config3 & 0x4){
priv->card_type = MINIPCI;
DMESG("This is a MINI-PCI NIC");
}else{
priv->card_type = PCI;
DMESG("This is a PCI NIC");
}
#endif
#endif
priv->enable_gpio0 = 0;
//by amy for antenna
#ifdef CONFIG_RTL8185B
usValue = eprom_read(dev, EEPROM_SW_REVD_OFFSET);
DMESG("usValue is 0x%x\n",usValue);
#ifdef CONFIG_RTL818X_S
//3Read AntennaDiversity
// SW Antenna Diversity.
if( (usValue & EEPROM_SW_AD_MASK) != EEPROM_SW_AD_ENABLE )
{
priv->EEPROMSwAntennaDiversity = false;
//printk("EEPROM Disable SW Antenna Diversity\n");
}
else
{
priv->EEPROMSwAntennaDiversity = true;
//printk("EEPROM Enable SW Antenna Diversity\n");
}
// Default Antenna to use.
if( (usValue & EEPROM_DEF_ANT_MASK) != EEPROM_DEF_ANT_1 )
{
priv->EEPROMDefaultAntenna1 = false;
//printk("EEPROM Default Antenna 0\n");
}
else
{
priv->EEPROMDefaultAntenna1 = true;
//printk("EEPROM Default Antenna 1\n");
}
//
// Antenna diversity mechanism. Added by Roger, 2007.11.05.
//
if( priv->RegSwAntennaDiversityMechanism == 0 ) // Auto
{// 0: default from EEPROM.
priv->bSwAntennaDiverity = priv->EEPROMSwAntennaDiversity;
}
else
{// 1:disable antenna diversity, 2: enable antenna diversity.
priv->bSwAntennaDiverity = ((priv->RegSwAntennaDiversityMechanism == 1)? false : true);
}
//printk("bSwAntennaDiverity = %d\n", priv->bSwAntennaDiverity);
//
// Default antenna settings. Added by Roger, 2007.11.05.
//
if( priv->RegDefaultAntenna == 0)
{// 0: default from EEPROM.
priv->bDefaultAntenna1 = priv->EEPROMDefaultAntenna1;
}
else
{// 1: main, 2: aux.
priv->bDefaultAntenna1 = ((priv->RegDefaultAntenna== 2) ? true : false);
}
//printk("bDefaultAntenna1 = %d\n", priv->bDefaultAntenna1);
#endif
#endif
//by amy for antenna
/* rtl8185 can calc plcp len in HW.*/
priv->hw_plcp_len = 1;
priv->plcp_preamble_mode = 2;
/*the eeprom type is stored in RCR register bit #6 */
if (RCR_9356SEL & read_nic_dword(dev, RCR)){
priv->epromtype=EPROM_93c56;
//DMESG("Reported EEPROM chip is a 93c56 (2Kbit)");
}else{
priv->epromtype=EPROM_93c46;
//DMESG("Reported EEPROM chip is a 93c46 (1Kbit)");
}
dev->dev_addr[0]=eprom_read(dev,MAC_ADR) & 0xff;
dev->dev_addr[1]=(eprom_read(dev,MAC_ADR) & 0xff00)>>8;
dev->dev_addr[2]=eprom_read(dev,MAC_ADR+1) & 0xff;
dev->dev_addr[3]=(eprom_read(dev,MAC_ADR+1) & 0xff00)>>8;
dev->dev_addr[4]=eprom_read(dev,MAC_ADR+2) & 0xff;
dev->dev_addr[5]=(eprom_read(dev,MAC_ADR+2) & 0xff00)>>8;
//DMESG("Card MAC address is "MAC_FMT, MAC_ARG(dev->dev_addr));
for(i=1,j=0; i<14; i+=2,j++){
word = eprom_read(dev,EPROM_TXPW_CH1_2 + j);
priv->chtxpwr[i]=word & 0xff;
priv->chtxpwr[i+1]=(word & 0xff00)>>8;
#ifdef DEBUG_EPROM
DMESG("tx word %x:%x",j,word);
DMESG("ch %d pwr %x",i,priv->chtxpwr[i]);
DMESG("ch %d pwr %x",i+1,priv->chtxpwr[i+1]);
#endif
}
if(priv->card_8185){
for(i=1,j=0; i<14; i+=2,j++){
word = eprom_read(dev,EPROM_TXPW_OFDM_CH1_2 + j);
priv->chtxpwr_ofdm[i]=word & 0xff;
priv->chtxpwr_ofdm[i+1]=(word & 0xff00)>>8;
#ifdef DEBUG_EPROM
DMESG("ofdm tx word %x:%x",j,word);
DMESG("ofdm ch %d pwr %x",i,priv->chtxpwr_ofdm[i]);
DMESG("ofdm ch %d pwr %x",i+1,priv->chtxpwr_ofdm[i+1]);
#endif
}
}
//{by amy 080312
//3Read crystal calibtration and thermal meter indication on 87SE.
// By SD3 SY's request. Added by Roger, 2007.12.11.
tmpu16 = eprom_read(dev, EEPROM_RSV>>1);
//printk("ReadAdapterInfo8185(): EEPROM_RSV(%04x)\n", tmpu16);
// Crystal calibration for Xin and Xout resp.
priv->XtalCal_Xout = tmpu16 & EEPROM_XTAL_CAL_XOUT_MASK; // 0~7.5pF
priv->XtalCal_Xin = (tmpu16 & EEPROM_XTAL_CAL_XIN_MASK)>>4; // 0~7.5pF
if((tmpu16 & EEPROM_XTAL_CAL_ENABLE)>>12)
priv->bXtalCalibration = true;
// Thermal meter reference indication.
priv->ThermalMeter = (u8)((tmpu16 & EEPROM_THERMAL_METER_MASK)>>8);
if((tmpu16 & EEPROM_THERMAL_METER_ENABLE)>>13)
priv->bTxPowerTrack = true;
//by amy 080312}
#ifdef CONFIG_RTL8185B
word = eprom_read(dev,EPROM_TXPW_BASE);
priv->cck_txpwr_base = word & 0xf;
priv->ofdm_txpwr_base = (word>>4) & 0xf;
#endif
version = eprom_read(dev,EPROM_VERSION);
DMESG("EEPROM version %x",version);
if( (!priv->card_8185) && version < 0x0101){
DMESG ("EEPROM version too old, assuming defaults");
DMESG ("If you see this message *plase* send your \
DMESG output to andreamrl@tiscali.it THANKS");
priv->digphy=1;
priv->antb=0;
priv->diversity=1;
priv->cs_treshold=0xc;
priv->rcr_csense=1;
priv->rf_chip=RFCHIPID_PHILIPS;
}else{
if(!priv->card_8185){
u8 rfparam = eprom_read(dev,RF_PARAM);
DMESG("RfParam: %x",rfparam);
priv->digphy = rfparam & (1<<RF_PARAM_DIGPHY_SHIFT) ? 0:1;
priv->antb = rfparam & (1<<RF_PARAM_ANTBDEFAULT_SHIFT) ? 1:0;
priv->rcr_csense = (rfparam & RF_PARAM_CARRIERSENSE_MASK) >>
RF_PARAM_CARRIERSENSE_SHIFT;
priv->diversity =
(read_nic_byte(dev,CONFIG2)&(1<<CONFIG2_ANTENNA_SHIFT)) ? 1:0;
}else{
priv->rcr_csense = 3;
}
priv->cs_treshold = (eprom_read(dev,ENERGY_TRESHOLD)&0xff00) >>8;
priv->rf_chip = 0xff & eprom_read(dev,RFCHIPID);
}
#ifdef CONFIG_RTL8185B
#ifdef CONFIG_RTL818X_S
priv->rf_chip = RF_ZEBRA4;
priv->rf_sleep = rtl8225z4_rf_sleep;
priv->rf_wakeup = rtl8225z4_rf_wakeup;
#else
priv->rf_chip = RF_ZEBRA2;
#endif
//DMESG("Card reports RF frontend Realtek 8225z2");
//DMESGW("This driver has EXPERIMENTAL support for this chipset.");
//DMESGW("use it with care and at your own risk and");
DMESGW("**PLEASE** REPORT SUCCESSFUL/UNSUCCESSFUL TO Realtek!");
priv->rf_close = rtl8225z2_rf_close;
priv->rf_init = rtl8225z2_rf_init;
priv->rf_set_chan = rtl8225z2_rf_set_chan;
priv->rf_set_sens = NULL;
//priv->rf_sleep = rtl8225_rf_sleep;
//priv->rf_wakeup = rtl8225_rf_wakeup;
#else
/* check RF frontend chipset */
switch (priv->rf_chip) {
case RFCHIPID_RTL8225:
if(priv->card_8185){
DMESG("Card reports RF frontend Realtek 8225");
DMESGW("This driver has EXPERIMENTAL support for this chipset.");
DMESGW("use it with care and at your own risk and");
DMESGW("**PLEASE** REPORT SUCCESS/INSUCCESS TO andreamrl@tiscali.it");
priv->rf_close = rtl8225_rf_close;
priv->rf_init = rtl8225_rf_init;
priv->rf_set_chan = rtl8225_rf_set_chan;
priv->rf_set_sens = NULL;
priv->rf_sleep = rtl8225_rf_sleep;
priv->rf_wakeup = rtl8225_rf_wakeup;
}else{
DMESGW("Detected RTL8225 radio on a card recognized as RTL8180");
DMESGW("This could not be... something went wrong....");
return -ENODEV;
}
break;
case RFCHIPID_RTL8255:
if(priv->card_8185){
DMESG("Card reports RF frontend Realtek 8255");
DMESGW("This driver has EXPERIMENTAL support for this chipset.");
DMESGW("use it with care and at your own risk and");
DMESGW("**PLEASE** REPORT SUCCESS/INSUCCESS TO andreamrl@tiscali.it");
priv->rf_close = rtl8255_rf_close;
priv->rf_init = rtl8255_rf_init;
priv->rf_set_chan = rtl8255_rf_set_chan;
priv->rf_set_sens = NULL;
priv->rf_sleep = NULL;
priv->rf_wakeup = NULL;
}else{
DMESGW("Detected RTL8255 radio on a card recognized as RTL8180");
DMESGW("This could not be... something went wrong....");
return -ENODEV;
}
break;
case RFCHIPID_INTERSIL:
DMESGW("Card reports RF frontend by Intersil.");
DMESGW("This driver has NO support for this chipset.");
return -ENODEV;
break;
case RFCHIPID_RFMD:
DMESGW("Card reports RF frontend by RFMD.");
DMESGW("This driver has NO support for this chipset.");
return -ENODEV;
break;
case RFCHIPID_GCT:
DMESGW("Card reports RF frontend by GCT.");
DMESGW("This driver has EXPERIMENTAL support for this chipset.");
DMESGW("use it with care and at your own risk and");
DMESGW("**PLEASE** REPORT SUCCESS/INSUCCESS TO andreamrl@tiscali.it");
priv->rf_close = gct_rf_close;
priv->rf_init = gct_rf_init;
priv->rf_set_chan = gct_rf_set_chan;
priv->rf_set_sens = NULL;
priv->rf_sleep = NULL;
priv->rf_wakeup = NULL;
break;
case RFCHIPID_MAXIM:
DMESGW("Card reports RF frontend by MAXIM.");
DMESGW("This driver has EXPERIMENTAL support for this chipset.");
DMESGW("use it with care and at your own risk and");
DMESGW("**PLEASE** REPORT SUCCESS/INSUCCESS TO andreamrl@tiscali.it");
priv->rf_close = maxim_rf_close;
priv->rf_init = maxim_rf_init;
priv->rf_set_chan = maxim_rf_set_chan;
priv->rf_set_sens = NULL;
priv->rf_sleep = NULL;
priv->rf_wakeup = NULL;
break;
case RFCHIPID_PHILIPS:
DMESG("Card reports RF frontend by Philips.");
DMESG("OK! Philips SA2400 radio chipset is supported.");
priv->rf_close = sa2400_rf_close;
priv->rf_init = sa2400_rf_init;
priv->rf_set_chan = sa2400_rf_set_chan;
priv->rf_set_sens = sa2400_rf_set_sens;
priv->sens = SA2400_RF_DEF_SENS; /* default sensitivity */
priv->max_sens = SA2400_RF_MAX_SENS; /* maximum sensitivity */
priv->rf_sleep = NULL;
priv->rf_wakeup = NULL;
if(priv->digphy){
DMESGW("Digital PHY found");
DMESGW("Philips DIGITAL PHY is untested! *Please*\
report success/failure to <andreamrl@tiscali.it>");
}else{
DMESG ("Analog PHY found");
}
break;
default:
DMESGW("Unknown RF module %x",priv->rf_chip);
DMESGW("Exiting...");
return -1;
}
#endif
if(!priv->card_8185){
if(priv->antb)
DMESG ("Antenna B is default antenna");
else
DMESG ("Antenna A is default antenna");
if(priv->diversity)
DMESG ("Antenna diversity is enabled");
else
DMESG("Antenna diversity is disabled");
DMESG("Carrier sense %d",priv->rcr_csense);
}
if (0!=alloc_rx_desc_ring(dev, priv->rxbuffersize, priv->rxringcount))
return -ENOMEM;
if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
TX_MANAGEPRIORITY_RING_ADDR))
return -ENOMEM;
if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
TX_BKPRIORITY_RING_ADDR))
return -ENOMEM;
if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
TX_BEPRIORITY_RING_ADDR))
return -ENOMEM;
if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
TX_VIPRIORITY_RING_ADDR))
return -ENOMEM;
if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
TX_VOPRIORITY_RING_ADDR))
return -ENOMEM;
if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
TX_HIGHPRIORITY_RING_ADDR))
return -ENOMEM;
if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txbeaconcount,
TX_BEACON_RING_ADDR))
return -ENOMEM;
//priv->beacon_buf=NULL;
if(!priv->card_8185){
if(read_nic_byte(dev, CONFIG0) & (1<<CONFIG0_WEP40_SHIFT))
DMESG ("40-bit WEP is supported in hardware");
else
DMESG ("40-bit WEP is NOT supported in hardware");
if(read_nic_byte(dev,CONFIG0) & (1<<CONFIG0_WEP104_SHIFT))
DMESG ("104-bit WEP is supported in hardware");
else
DMESG ("104-bit WEP is NOT supported in hardware");
}
#if !defined(SA_SHIRQ)
if(request_irq(dev->irq, (void *)rtl8180_interrupt, IRQF_SHARED, dev->name, dev)){
#else
if(request_irq(dev->irq, (void *)rtl8180_interrupt, SA_SHIRQ, dev->name, dev)){
#endif
DMESGE("Error allocating IRQ %d",dev->irq);
return -1;
}else{
priv->irq=dev->irq;
DMESG("IRQ %d",dev->irq);
}
#ifdef DEBUG_EPROM
dump_eprom(dev);
#endif
return 0;
}
void rtl8180_no_hw_wep(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
if(!priv->card_8185)
{
u8 security;
security = read_nic_byte(dev, SECURITY);
security &=~(1<<SECURITY_WEP_TX_ENABLE_SHIFT);
security &=~(1<<SECURITY_WEP_RX_ENABLE_SHIFT);
write_nic_byte(dev, SECURITY, security);
}else{
//FIXME!!!
}
/*
write_nic_dword(dev,TX_CONF,read_nic_dword(dev,TX_CONF) |
(1<<TX_NOICV_SHIFT) );
*/
// priv->ieee80211->hw_wep=0;
}
void rtl8180_set_hw_wep(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
u8 pgreg;
u8 security;
u32 key0_word4;
pgreg=read_nic_byte(dev, PGSELECT);
write_nic_byte(dev, PGSELECT, pgreg &~ (1<<PGSELECT_PG_SHIFT));
key0_word4 = read_nic_dword(dev, KEY0+4+4+4);
key0_word4 &= ~ 0xff;
key0_word4 |= priv->key0[3]& 0xff;
write_nic_dword(dev,KEY0,(priv->key0[0]));
write_nic_dword(dev,KEY0+4,(priv->key0[1]));
write_nic_dword(dev,KEY0+4+4,(priv->key0[2]));
write_nic_dword(dev,KEY0+4+4+4,(key0_word4));
/*
TX_CONF,read_nic_dword(dev,TX_CONF) &~(1<<TX_NOICV_SHIFT));
*/
security = read_nic_byte(dev,SECURITY);
security |= (1<<SECURITY_WEP_TX_ENABLE_SHIFT);
security |= (1<<SECURITY_WEP_RX_ENABLE_SHIFT);
security &= ~ SECURITY_ENCRYP_MASK;
security |= (SECURITY_ENCRYP_104<<SECURITY_ENCRYP_SHIFT);
write_nic_byte(dev, SECURITY, security);
DMESG("key %x %x %x %x",read_nic_dword(dev,KEY0+4+4+4),
read_nic_dword(dev,KEY0+4+4),read_nic_dword(dev,KEY0+4),
read_nic_dword(dev,KEY0));
//priv->ieee80211->hw_wep=1;
}
void rtl8185_rf_pins_enable(struct net_device *dev)
{
// u16 tmp;
// tmp = read_nic_word(dev, RFPinsEnable);
write_nic_word(dev, RFPinsEnable, 0x1fff);// | tmp);
// write_nic_word(dev, RFPinsEnable,7 | tmp);
}
void rtl8185_set_anaparam2(struct net_device *dev, u32 a)
{
u8 conf3;
rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
conf3 = read_nic_byte(dev, CONFIG3);
write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
write_nic_dword(dev, ANAPARAM2, a);
conf3 = read_nic_byte(dev, CONFIG3);
write_nic_byte(dev, CONFIG3, conf3 &~(1<<CONFIG3_ANAPARAM_W_SHIFT));
rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
}
void rtl8180_set_anaparam(struct net_device *dev, u32 a)
{
u8 conf3;
rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
conf3 = read_nic_byte(dev, CONFIG3);
write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
write_nic_dword(dev, ANAPARAM, a);
conf3 = read_nic_byte(dev, CONFIG3);
write_nic_byte(dev, CONFIG3, conf3 &~(1<<CONFIG3_ANAPARAM_W_SHIFT));
rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
}
void rtl8185_tx_antenna(struct net_device *dev, u8 ant)
{
write_nic_byte(dev, TX_ANTENNA, ant);
force_pci_posting(dev);
mdelay(1);
}
void rtl8185_write_phy(struct net_device *dev, u8 adr, u32 data)
{
//u8 phyr;
u32 phyw;
//int i;
adr |= 0x80;
phyw= ((data<<8) | adr);
#if 0
write_nic_dword(dev, PHY_ADR, phyw);
//read_nic_dword(dev, PHY_ADR);
for(i=0;i<10;i++){
write_nic_dword(dev, PHY_ADR, 0xffffff7f & phyw);
phyr = read_nic_byte(dev, PHY_READ);
if(phyr == (data&0xff)) break;
}
#else
// Note that, we must write 0xff7c after 0x7d-0x7f to write BB register.
write_nic_byte(dev, 0x7f, ((phyw & 0xff000000) >> 24));
write_nic_byte(dev, 0x7e, ((phyw & 0x00ff0000) >> 16));
write_nic_byte(dev, 0x7d, ((phyw & 0x0000ff00) >> 8));
write_nic_byte(dev, 0x7c, ((phyw & 0x000000ff) ));
#endif
/* this is ok to fail when we write AGC table. check for AGC table might be
* done by masking with 0x7f instead of 0xff
*/
//if(phyr != (data&0xff)) DMESGW("Phy write timeout %x %x %x", phyr, data,adr);
}
inline void write_phy_ofdm (struct net_device *dev, u8 adr, u32 data)
{
data = data & 0xff;
rtl8185_write_phy(dev, adr, data);
}
void write_phy_cck (struct net_device *dev, u8 adr, u32 data)
{
data = data & 0xff;
rtl8185_write_phy(dev, adr, data | 0x10000);
}
/* 70*3 = 210 ms
* I hope this is enougth
*/
#define MAX_PHY 70
void write_phy(struct net_device *dev, u8 adr, u8 data)
{
u32 phy;
int i;
phy = 0xff0000;
phy |= adr;
phy |= 0x80; /* this should enable writing */
phy |= (data<<8);
//PHY_ADR, PHY_R and PHY_W are contig and treated as one dword
write_nic_dword(dev,PHY_ADR, phy);
phy= 0xffff00;
phy |= adr;
write_nic_dword(dev,PHY_ADR, phy);
for(i=0;i<MAX_PHY;i++){
phy=read_nic_dword(dev,PHY_ADR);
phy= phy & 0xff0000;
phy= phy >> 16;
if(phy == data){ //SUCCESS!
force_pci_posting(dev);
mdelay(3); //random value
#ifdef DEBUG_BB
DMESG("Phy wr %x,%x",adr,data);
#endif
return;
}else{
force_pci_posting(dev);
mdelay(3); //random value
}
}
DMESGW ("Phy writing %x %x failed!", adr,data);
}
void rtl8185_set_rate(struct net_device *dev)
{
int i;
u16 word;
int basic_rate,min_rr_rate,max_rr_rate;
// struct r8180_priv *priv = ieee80211_priv(dev);
//if (ieee80211_is_54g(priv->ieee80211->current_network) &&
// priv->ieee80211->state == IEEE80211_LINKED){
basic_rate = ieeerate2rtlrate(240);
min_rr_rate = ieeerate2rtlrate(60);
max_rr_rate = ieeerate2rtlrate(240);
//
// }else{
// basic_rate = ieeerate2rtlrate(20);
// min_rr_rate = ieeerate2rtlrate(10);
// max_rr_rate = ieeerate2rtlrate(110);
// }
write_nic_byte(dev, RESP_RATE,
max_rr_rate<<MAX_RESP_RATE_SHIFT| min_rr_rate<<MIN_RESP_RATE_SHIFT);
word = read_nic_word(dev, BRSR);
word &= ~BRSR_MBR_8185;
for(i=0;i<=basic_rate;i++)
word |= (1<<i);
write_nic_word(dev, BRSR, word);
//DMESG("RR:%x BRSR: %x", read_nic_byte(dev,RESP_RATE),read_nic_word(dev,BRSR));
}
void rtl8180_adapter_start(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
u32 anaparam;
u16 word;
u8 config3;
// int i;
rtl8180_rtx_disable(dev);
rtl8180_reset(dev);
/* seems that 0xffff or 0xafff will cause
* HW interrupt line crash
*/
//priv->irq_mask = 0xafff;
// priv->irq_mask = 0x4fcf;
/* enable beacon timeout, beacon TX ok and err
* LP tx ok and err, HP TX ok and err, NP TX ok and err,
* RX ok and ERR, and GP timer */
priv->irq_mask = 0x6fcf;
priv->dma_poll_mask = 0;
rtl8180_beacon_tx_disable(dev);
if(priv->card_type == CARDBUS ){
config3=read_nic_byte(dev, CONFIG3);
write_nic_byte(dev,CONFIG3,config3 | CONFIG3_FuncRegEn);
write_nic_word(dev,FEMR, FEMR_INTR | FEMR_WKUP | FEMR_GWAKE |
read_nic_word(dev, FEMR));
}
rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
write_nic_word(dev, MAC4, ((u32*)dev->dev_addr)[1] & 0xffff );
rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
rtl8180_update_msr(dev);
if(!priv->card_8185){
anaparam = eprom_read(dev,EPROM_ANAPARAM_ADDRLWORD);
anaparam |= eprom_read(dev,EPROM_ANAPARAM_ADDRHWORD)<<16;
rtl8180_set_anaparam(dev,anaparam);
}
/* These might be unnecessary since we do in rx_enable / tx_enable */
fix_rx_fifo(dev);
fix_tx_fifo(dev);
/*set_nic_rxring(dev);
set_nic_txring(dev);*/
rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
/*
The following is very strange. seems to be that 1 means test mode,
but we need to acknolwledges the nic when a packet is ready
altought we set it to 0
*/
write_nic_byte(dev,
CONFIG2, read_nic_byte(dev,CONFIG2) &~\
(1<<CONFIG2_DMA_POLLING_MODE_SHIFT));
//^the nic isn't in test mode
if(priv->card_8185)
write_nic_byte(dev,
CONFIG2, read_nic_byte(dev,CONFIG2)|(1<<4));
rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
write_nic_dword(dev,INT_TIMEOUT,0);
#ifdef DEBUG_REGISTERS
rtl8180_dump_reg(dev);
#endif
if(!priv->card_8185)
{
/*
experimental - this might be needed to calibrate AGC,
anyway it shouldn't hurt
*/
write_nic_byte(dev, CONFIG5,
read_nic_byte(dev, CONFIG5) | (1<<AGCRESET_SHIFT));
read_nic_byte(dev, CONFIG5);
udelay(15);
write_nic_byte(dev, CONFIG5,
read_nic_byte(dev, CONFIG5) &~ (1<<AGCRESET_SHIFT));
}else{
write_nic_byte(dev, WPA_CONFIG, 0);
//write_nic_byte(dev, TESTR, 0xd);
}
rtl8180_no_hw_wep(dev);
if(priv->card_8185){
rtl8185_set_rate(dev);
write_nic_byte(dev, RATE_FALLBACK, 0x81);
// write_nic_byte(dev, 0xdf, 0x15);
}else{
word = read_nic_word(dev, BRSR);
word &= ~BRSR_MBR;
word &= ~BRSR_BPLCP;
word |= ieeerate2rtlrate(priv->ieee80211->basic_rate);
//by amy
word |= 0x0f;
//by amy
write_nic_word(dev, BRSR, word);
}
if(priv->card_8185){
write_nic_byte(dev, GP_ENABLE,read_nic_byte(dev, GP_ENABLE) & ~(1<<6));
//FIXME cfg 3 ClkRun enable - isn't it ReadOnly ?
rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
write_nic_byte(dev,CONFIG3, read_nic_byte(dev, CONFIG3)
|(1<<CONFIG3_CLKRUN_SHIFT));
rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
}
priv->rf_init(dev);
if(priv->rf_set_sens != NULL)
priv->rf_set_sens(dev,priv->sens);
rtl8180_irq_enable(dev);
netif_start_queue(dev);
/*DMESG ("lfree %d",get_curr_tx_free_desc(dev,LOW_PRIORITY));
DMESG ("nfree %d",get_curr_tx_free_desc(dev,NORM_PRIORITY));
DMESG ("hfree %d",get_curr_tx_free_desc(dev,HI_PRIORITY));
if(check_nic_enought_desc(dev,NORM_PRIORITY)) DMESG("NORM OK");
if(check_nic_enought_desc(dev,HI_PRIORITY)) DMESG("HI OK");
if(check_nic_enought_desc(dev,LOW_PRIORITY)) DMESG("LOW OK");*/
}
/* this configures registers for beacon tx and enables it via
* rtl8180_beacon_tx_enable(). rtl8180_beacon_tx_disable() might
* be used to stop beacon transmission
*/
void rtl8180_start_tx_beacon(struct net_device *dev)
{
// struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
u16 word;
// DMESG("ring %x %x", priv->txlpringdma,read_nic_dword(dev,TLPDA));
DMESG("Enabling beacon TX");
//write_nic_byte(dev, 0x42,0xe6);// TCR
// set_nic_txring(dev);
// fix_tx_fifo(dev);
rtl8180_prepare_beacon(dev);
rtl8180_irq_disable(dev);
rtl8180_beacon_tx_enable(dev);
#if 0
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
//write_nic_byte(dev,0x9d,0x20); //DMA Poll
//write_nic_word(dev,0x7a,0);
//write_nic_word(dev,0x7a,0x8000);
#if 0
word = read_nic_word(dev, BcnItv);
word &= ~BcnItv_BcnItv; // clear Bcn_Itv
word |= priv->ieee80211->current_network.beacon_interval;//0x64;
write_nic_word(dev, BcnItv, word);
#endif
#endif
word = read_nic_word(dev, AtimWnd) &~ AtimWnd_AtimWnd;
write_nic_word(dev, AtimWnd,word);// word |=
//priv->ieee80211->current_network.atim_window);
word = read_nic_word(dev, BintrItv);
word &= ~BintrItv_BintrItv;
word |= 1000;/*priv->ieee80211->current_network.beacon_interval *
((priv->txbeaconcount > 1)?(priv->txbeaconcount-1):1);
// FIXME: check if correct ^^ worked with 0x3e8;
*/
write_nic_word(dev, BintrItv, word);
rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
// rtl8180_beacon_tx_enable(dev);
#ifdef CONFIG_RTL8185B
rtl8185b_irq_enable(dev);
#else
rtl8180_irq_enable(dev);
#endif
/* VV !!!!!!!!!! VV*/
/*
rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
write_nic_byte(dev,0x9d,0x00);
rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
*/
// DMESG("ring %x %x", priv->txlpringdma,read_nic_dword(dev,TLPDA));
}
/***************************************************************************
-------------------------------NET STUFF---------------------------
***************************************************************************/
static struct net_device_stats *rtl8180_stats(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
return &priv->ieee80211->stats;
}
//
// Change current and default preamble mode.
// 2005.01.06, by rcnjko.
//
bool
MgntActSet_802_11_PowerSaveMode(
struct r8180_priv *priv,
RT_PS_MODE rtPsMode
)
{
// Currently, we do not change power save mode on IBSS mode.
if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
{
return false;
}
//
// <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
// some AP will not response to our mgnt frames with PwrMgt bit set,
// e.g. cannot associate the AP.
// So I commented out it. 2005.02.16, by rcnjko.
//
// // Change device's power save mode.
// Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
// Update power save mode configured.
// priv->dot11PowerSaveMode = rtPsMode;
priv->ieee80211->ps = rtPsMode;
// Determine ListenInterval.
#if 0
if(priv->dot11PowerSaveMode == eMaxPs)
{
priv->ieee80211->ListenInterval = 10;
}
else
{
priv->ieee80211->ListenInterval = 2;
}
#endif
return true;
}
//================================================================================
// Leisure Power Save in linked state.
//================================================================================
//
// Description:
// Enter the leisure power save mode.
//
void
LeisurePSEnter(
struct r8180_priv *priv
)
{
if (priv->bLeisurePs)
{
if (priv->ieee80211->ps == IEEE80211_PS_DISABLED)
{
//printk("----Enter PS\n");
MgntActSet_802_11_PowerSaveMode(priv, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST);//IEEE80211_PS_ENABLE
}
}
}
//
// Description:
// Leave the leisure power save mode.
//
void
LeisurePSLeave(
struct r8180_priv *priv
)
{
if (priv->bLeisurePs)
{
if (priv->ieee80211->ps != IEEE80211_PS_DISABLED)
{
//printk("----Leave PS\n");
MgntActSet_802_11_PowerSaveMode(priv, IEEE80211_PS_DISABLED);
}
}
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_hw_wakeup_wq (struct work_struct *work)
{
// struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
// struct ieee80211_device * ieee = (struct ieee80211_device*)
// container_of(work, struct ieee80211_device, watch_dog_wq);
struct delayed_work *dwork = to_delayed_work(work);
struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
struct net_device *dev = ieee->dev;
#else
void rtl8180_hw_wakeup_wq(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
#endif
// printk("dev is %d\n",dev);
// printk("&*&(^*(&(&=========>%s()\n", __func__);
rtl8180_hw_wakeup(dev);
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_hw_sleep_wq (struct work_struct *work)
{
// struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
// struct ieee80211_device * ieee = (struct ieee80211_device*)
// container_of(work, struct ieee80211_device, watch_dog_wq);
struct delayed_work *dwork = to_delayed_work(work);
struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
struct net_device *dev = ieee->dev;
#else
void rtl8180_hw_sleep_wq(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
#endif
rtl8180_hw_sleep_down(dev);
}
//YJ,add,080828,for KeepAlive
static void MgntLinkKeepAlive(struct r8180_priv *priv )
{
if (priv->keepAliveLevel == 0)
return;
if(priv->ieee80211->state == IEEE80211_LINKED)
{
//
// Keep-Alive.
//
//printk("LastTx:%d Tx:%d LastRx:%d Rx:%ld Idle:%d\n",priv->link_detect.LastNumTxUnicast,priv->NumTxUnicast, priv->link_detect.LastNumRxUnicast, priv->ieee80211->NumRxUnicast, priv->link_detect.IdleCount);
if ( (priv->keepAliveLevel== 2) ||
(priv->link_detect.LastNumTxUnicast == priv->NumTxUnicast &&
priv->link_detect.LastNumRxUnicast == priv->ieee80211->NumRxUnicast )
)
{
priv->link_detect.IdleCount++;
//
// Send a Keep-Alive packet packet to AP if we had been idle for a while.
//
if(priv->link_detect.IdleCount >= ((KEEP_ALIVE_INTERVAL / CHECK_FOR_HANG_PERIOD)-1) )
{
priv->link_detect.IdleCount = 0;
ieee80211_sta_ps_send_null_frame(priv->ieee80211, false);
}
}
else
{
priv->link_detect.IdleCount = 0;
}
priv->link_detect.LastNumTxUnicast = priv->NumTxUnicast;
priv->link_detect.LastNumRxUnicast = priv->ieee80211->NumRxUnicast;
}
}
//YJ,add,080828,for KeepAlive,end
static u8 read_acadapter_file(char *filename);
void rtl8180_watch_dog(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
bool bEnterPS = false;
bool bBusyTraffic = false;
u32 TotalRxNum = 0;
u16 SlotIndex = 0;
u16 i = 0;
#ifdef ENABLE_IPS
if(priv->ieee80211->actscanning == false){
if((priv->ieee80211->iw_mode != IW_MODE_ADHOC) && (priv->ieee80211->state == IEEE80211_NOLINK) && (priv->ieee80211->beinretry == false) && (priv->eRFPowerState == eRfOn)){
IPSEnter(dev);
}
}
#endif
//YJ,add,080828,for link state check
if((priv->ieee80211->state == IEEE80211_LINKED) && (priv->ieee80211->iw_mode == IW_MODE_INFRA)){
SlotIndex = (priv->link_detect.SlotIndex++) % priv->link_detect.SlotNum;
priv->link_detect.RxFrameNum[SlotIndex] = priv->ieee80211->NumRxDataInPeriod + priv->ieee80211->NumRxBcnInPeriod;
for( i=0; i<priv->link_detect.SlotNum; i++ )
TotalRxNum+= priv->link_detect.RxFrameNum[i];
//printk("&&&&&=== TotalRxNum = %d\n", TotalRxNum);
if(TotalRxNum == 0){
priv->ieee80211->state = IEEE80211_ASSOCIATING;
queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
}
}
//YJ,add,080828,for KeepAlive
MgntLinkKeepAlive(priv);
//YJ,add,080828,for LPS
#ifdef ENABLE_LPS
if(priv->PowerProfile == POWER_PROFILE_BATTERY )
{
//Turn on LeisurePS on battery power
//printk("!!!!!On battery power\n");
priv->bLeisurePs = true;
}
else if(priv->PowerProfile == POWER_PROFILE_AC )
{
// Turn off LeisurePS on AC power
//printk("----On AC power\n");
LeisurePSLeave(priv);
priv->bLeisurePs= false;
}
#endif
#if 0
#ifndef ENABLE_LPS
if(priv->ieee80211->state == IEEE80211_LINKED){
if( priv->NumRxOkInPeriod> 666 ||
priv->NumTxOkInPeriod > 666 ) {
bBusyTraffic = true;
}
if((priv->ieee80211->NumRxData + priv->NumTxOkInPeriod)<8) {
bEnterPS= true;
}
if(bEnterPS) {
LeisurePSEnter(priv);
}
else {
LeisurePSLeave(priv);
}
}
else {
LeisurePSLeave(priv);
}
#endif
priv->NumRxOkInPeriod = 0;
priv->NumTxOkInPeriod = 0;
priv->ieee80211->NumRxData = 0;
#else
#ifdef ENABLE_LPS
if(priv->ieee80211->state == IEEE80211_LINKED){
priv->link_detect.NumRxOkInPeriod = priv->ieee80211->NumRxDataInPeriod;
//printk("TxOk=%d RxOk=%d\n", priv->link_detect.NumTxOkInPeriod, priv->link_detect.NumRxOkInPeriod);
if( priv->link_detect.NumRxOkInPeriod> 666 ||
priv->link_detect.NumTxOkInPeriod> 666 ) {
bBusyTraffic = true;
}
if(((priv->link_detect.NumRxOkInPeriod + priv->link_detect.NumTxOkInPeriod) > 8)
|| (priv->link_detect.NumRxOkInPeriod > 2)) {
bEnterPS= false;
}
else {
bEnterPS= true;
}
if(bEnterPS) {
LeisurePSEnter(priv);
}
else {
LeisurePSLeave(priv);
}
}
else{
LeisurePSLeave(priv);
}
#endif
priv->link_detect.bBusyTraffic = bBusyTraffic;
priv->link_detect.NumRxOkInPeriod = 0;
priv->link_detect.NumTxOkInPeriod = 0;
priv->ieee80211->NumRxDataInPeriod = 0;
priv->ieee80211->NumRxBcnInPeriod = 0;
#endif
}
int _rtl8180_up(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
//int i;
priv->up=1;
DMESG("Bringing up iface");
#ifdef CONFIG_RTL8185B
rtl8185b_adapter_start(dev);
rtl8185b_rx_enable(dev);
rtl8185b_tx_enable(dev);
#else
rtl8180_adapter_start(dev);
rtl8180_rx_enable(dev);
rtl8180_tx_enable(dev);
#endif
#ifdef ENABLE_IPS
if(priv->bInactivePs){
if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
IPSLeave(dev);
}
#endif
//by amy 080312
#ifdef RATE_ADAPT
timer_rate_adaptive((unsigned long)dev);
#endif
//by amy 080312
watch_dog_adaptive((unsigned long)dev);
#ifdef SW_ANTE
if(priv->bSwAntennaDiverity)
SwAntennaDiversityTimerCallback(dev);
#endif
// IPSEnter(dev);
ieee80211_softmac_start_protocol(priv->ieee80211);
//Add for RF power on power off by lizhaoming 080512
// priv->eRFPowerState = eRfOn;
// printk("\n--------Start queue_work:GPIOChangeRFWorkItem");
// queue_delayed_work(priv->ieee80211->wq,&priv->ieee80211->GPIOChangeRFWorkItem,1000);
return 0;
}
int rtl8180_open(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
int ret;
down(&priv->wx_sem);
ret = rtl8180_up(dev);
up(&priv->wx_sem);
return ret;
}
int rtl8180_up(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
if (priv->up == 1) return -1;
return _rtl8180_up(dev);
}
int rtl8180_close(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
int ret;
down(&priv->wx_sem);
ret = rtl8180_down(dev);
up(&priv->wx_sem);
return ret;
}
int rtl8180_down(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
if (priv->up == 0) return -1;
priv->up=0;
ieee80211_softmac_stop_protocol(priv->ieee80211);
/* FIXME */
if (!netif_queue_stopped(dev))
netif_stop_queue(dev);
rtl8180_rtx_disable(dev);
rtl8180_irq_disable(dev);
del_timer_sync(&priv->watch_dog_timer);
//cancel_delayed_work(&priv->ieee80211->watch_dog_wq);
//{by amy 080312
del_timer_sync(&priv->rateadapter_timer);
cancel_delayed_work(&priv->ieee80211->rate_adapter_wq);
//by amy 080312}
cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
cancel_delayed_work(&priv->ieee80211->hw_dig_wq);
cancel_delayed_work(&priv->ieee80211->tx_pw_wq);
del_timer_sync(&priv->SwAntennaDiversityTimer);
SetZebraRFPowerState8185(dev,eRfOff);
//ieee80211_softmac_stop_protocol(priv->ieee80211);
memset(&(priv->ieee80211->current_network),0,sizeof(struct ieee80211_network));
priv->ieee80211->state = IEEE80211_NOLINK;
return 0;
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_restart_wq(struct work_struct *work)
{
struct r8180_priv *priv = container_of(work, struct r8180_priv, reset_wq);
struct net_device *dev = priv->dev;
#else
void rtl8180_restart_wq(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
#endif
down(&priv->wx_sem);
rtl8180_commit(dev);
up(&priv->wx_sem);
}
void rtl8180_restart(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
//rtl8180_commit(dev);
schedule_work(&priv->reset_wq);
//DMESG("TXTIMEOUT");
}
void rtl8180_commit(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
if (priv->up == 0) return ;
//+by amy 080312
del_timer_sync(&priv->watch_dog_timer);
//cancel_delayed_work(&priv->ieee80211->watch_dog_wq);
//{by amy 080312
//by amy for rate adaptive
del_timer_sync(&priv->rateadapter_timer);
cancel_delayed_work(&priv->ieee80211->rate_adapter_wq);
//by amy for rate adaptive
//by amy 080312}
cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
cancel_delayed_work(&priv->ieee80211->hw_dig_wq);
cancel_delayed_work(&priv->ieee80211->tx_pw_wq);
del_timer_sync(&priv->SwAntennaDiversityTimer);
ieee80211_softmac_stop_protocol(priv->ieee80211);
rtl8180_irq_disable(dev);
rtl8180_rtx_disable(dev);
_rtl8180_up(dev);
}
static void r8180_set_multicast(struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
short promisc;
//down(&priv->wx_sem);
promisc = (dev->flags & IFF_PROMISC) ? 1:0;
if (promisc != priv->promisc)
rtl8180_restart(dev);
priv->promisc = promisc;
//up(&priv->wx_sem);
}
#if 0
/* this is called by the kernel when it needs to TX a 802.3 encapsulated frame*/
int rtl8180_8023_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct r8180_priv *priv = ieee80211_priv(dev);
int ret;
unsigned long flags;
spin_lock_irqsave(&priv->tx_lock,flags);
ret = ieee80211_r8180_8023_hardstartxmit(skb,priv->ieee80211);
spin_unlock_irqrestore(&priv->tx_lock,flags);
return ret;
}
#endif
int r8180_set_mac_adr(struct net_device *dev, void *mac)
{
struct r8180_priv *priv = ieee80211_priv(dev);
struct sockaddr *addr = mac;
down(&priv->wx_sem);
memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
if(priv->ieee80211->iw_mode == IW_MODE_MASTER)
memcpy(priv->ieee80211->current_network.bssid, dev->dev_addr, ETH_ALEN);
if (priv->up) {
rtl8180_down(dev);
rtl8180_up(dev);
}
up(&priv->wx_sem);
return 0;
}
/* based on ipw2200 driver */
int rtl8180_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
struct iwreq *wrq = (struct iwreq *) rq;
int ret=-1;
switch (cmd) {
case RTL_IOCTL_WPA_SUPPLICANT:
ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
return ret;
default:
return -EOPNOTSUPP;
}
return -EOPNOTSUPP;
}
/****************************************************************************
-----------------------------PCI STUFF---------------------------
*****************************************************************************/
static const struct net_device_ops rtl8180_netdev_ops = {
.ndo_open = rtl8180_open,
.ndo_stop = rtl8180_close,
.ndo_get_stats = rtl8180_stats,
.ndo_tx_timeout = rtl8180_restart,
.ndo_do_ioctl = rtl8180_ioctl,
.ndo_set_multicast_list = r8180_set_multicast,
.ndo_set_mac_address = r8180_set_mac_adr,
.ndo_validate_addr = eth_validate_addr,
.ndo_change_mtu = eth_change_mtu,
.ndo_start_xmit = ieee80211_xmit,
};
static int __devinit rtl8180_pci_probe(struct pci_dev *pdev,
const struct pci_device_id *id)
{
unsigned long ioaddr = 0;
struct net_device *dev = NULL;
struct r8180_priv *priv= NULL;
//u8 *ptr;
u8 unit = 0;
#ifdef CONFIG_RTL8180_IO_MAP
unsigned long pio_start, pio_len, pio_flags;
#else
unsigned long pmem_start, pmem_len, pmem_flags;
#endif //end #ifdef RTL_IO_MAP
DMESG("Configuring chip resources");
if( pci_enable_device (pdev) ){
DMESG("Failed to enable PCI device");
return -EIO;
}
pci_set_master(pdev);
//pci_set_wmi(pdev);
pci_set_dma_mask(pdev, 0xffffff00ULL);
pci_set_consistent_dma_mask(pdev,0xffffff00ULL);
dev = alloc_ieee80211(sizeof(struct r8180_priv));
if (!dev)
return -ENOMEM;
priv = ieee80211_priv(dev);
priv->ieee80211 = netdev_priv(dev);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
SET_MODULE_OWNER(dev);
#endif
pci_set_drvdata(pdev, dev);
SET_NETDEV_DEV(dev, &pdev->dev);
priv = ieee80211_priv(dev);
// memset(priv,0,sizeof(struct r8180_priv));
priv->pdev=pdev;
#ifdef CONFIG_RTL8180_IO_MAP
pio_start = (unsigned long)pci_resource_start (pdev, 0);
pio_len = (unsigned long)pci_resource_len (pdev, 0);
pio_flags = (unsigned long)pci_resource_flags (pdev, 0);
if (!(pio_flags & IORESOURCE_IO)) {
DMESG("region #0 not a PIO resource, aborting");
goto fail;
}
//DMESG("IO space @ 0x%08lx", pio_start );
if( ! request_region( pio_start, pio_len, RTL8180_MODULE_NAME ) ){
DMESG("request_region failed!");
goto fail;
}
ioaddr = pio_start;
dev->base_addr = ioaddr; // device I/O address
#else
pmem_start = pci_resource_start(pdev, 1);
pmem_len = pci_resource_len(pdev, 1);
pmem_flags = pci_resource_flags (pdev, 1);
if (!(pmem_flags & IORESOURCE_MEM)) {
DMESG("region #1 not a MMIO resource, aborting");
goto fail;
}
//DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
if( ! request_mem_region(pmem_start, pmem_len, RTL8180_MODULE_NAME)) {
DMESG("request_mem_region failed!");
goto fail;
}
ioaddr = (unsigned long)ioremap_nocache( pmem_start, pmem_len);
if( ioaddr == (unsigned long)NULL ){
DMESG("ioremap failed!");
// release_mem_region( pmem_start, pmem_len );
goto fail1;
}
dev->mem_start = ioaddr; // shared mem start
dev->mem_end = ioaddr + pci_resource_len(pdev, 0); // shared mem end
#endif //end #ifdef RTL_IO_MAP
#ifdef CONFIG_RTL8185B
//pci_read_config_byte(pdev, 0x05, ptr);
//pci_write_config_byte(pdev, 0x05, (*ptr) & (~0x04));
pci_read_config_byte(pdev, 0x05, &unit);
pci_write_config_byte(pdev, 0x05, unit & (~0x04));
#endif
dev->irq = pdev->irq;
priv->irq = 0;
dev->netdev_ops = &rtl8180_netdev_ops;
dev->wireless_handlers = &r8180_wx_handlers_def;
#if WIRELESS_EXT >= 12
#if WIRELESS_EXT < 17
dev->get_wireless_stats = r8180_get_wireless_stats;
#endif
dev->wireless_handlers = (struct iw_handler_def *) &r8180_wx_handlers_def;
#endif
dev->type=ARPHRD_ETHER;
dev->watchdog_timeo = HZ*3; //added by david woo, 2007.12.13
if (dev_alloc_name(dev, ifname) < 0){
DMESG("Oops: devname already taken! Trying wlan%%d...\n");
ifname = "wlan%d";
// ifname = "ath%d";
dev_alloc_name(dev, ifname);
}
if(rtl8180_init(dev)!=0){
DMESG("Initialization failed");
goto fail1;
}
netif_carrier_off(dev);
register_netdev(dev);
rtl8180_proc_init_one(dev);
DMESG("Driver probe completed\n");
return 0;
fail1:
#ifdef CONFIG_RTL8180_IO_MAP
if( dev->base_addr != 0 ){
release_region(dev->base_addr,
pci_resource_len(pdev, 0) );
}
#else
if( dev->mem_start != (unsigned long)NULL ){
iounmap( (void *)dev->mem_start );
release_mem_region( pci_resource_start(pdev, 1),
pci_resource_len(pdev, 1) );
}
#endif //end #ifdef RTL_IO_MAP
fail:
if(dev){
if (priv->irq) {
free_irq(dev->irq, dev);
dev->irq=0;
}
free_ieee80211(dev);
}
pci_disable_device(pdev);
DMESG("wlan driver load failed\n");
pci_set_drvdata(pdev, NULL);
return -ENODEV;
}
static void __devexit rtl8180_pci_remove(struct pci_dev *pdev)
{
struct r8180_priv *priv;
struct net_device *dev = pci_get_drvdata(pdev);
if(dev){
unregister_netdev(dev);
priv=ieee80211_priv(dev);
rtl8180_proc_remove_one(dev);
rtl8180_down(dev);
priv->rf_close(dev);
rtl8180_reset(dev);
//rtl8180_rtx_disable(dev);
//rtl8180_irq_disable(dev);
mdelay(10);
//write_nic_word(dev,INTA,read_nic_word(dev,INTA));
//force_pci_posting(dev);
//mdelay(10);
if(priv->irq){
DMESG("Freeing irq %d",dev->irq);
free_irq(dev->irq, dev);
priv->irq=0;
}
free_rx_desc_ring(dev);
free_tx_desc_rings(dev);
// free_beacon_desc_ring(dev,priv->txbeaconcount);
#ifdef CONFIG_RTL8180_IO_MAP
if( dev->base_addr != 0 ){
release_region(dev->base_addr,
pci_resource_len(pdev, 0) );
}
#else
if( dev->mem_start != (unsigned long)NULL ){
iounmap( (void *)dev->mem_start );
release_mem_region( pci_resource_start(pdev, 1),
pci_resource_len(pdev, 1) );
}
#endif /*end #ifdef RTL_IO_MAP*/
free_ieee80211(dev);
}
pci_disable_device(pdev);
DMESG("wlan driver removed\n");
}
/* fun with the built-in ieee80211 stack... */
extern int ieee80211_crypto_init(void);
extern void ieee80211_crypto_deinit(void);
extern int ieee80211_crypto_tkip_init(void);
extern void ieee80211_crypto_tkip_exit(void);
extern int ieee80211_crypto_ccmp_init(void);
extern void ieee80211_crypto_ccmp_exit(void);
extern int ieee80211_crypto_wep_init(void);
extern void ieee80211_crypto_wep_exit(void);
static int __init rtl8180_pci_module_init(void)
{
int ret;
ret = ieee80211_crypto_init();
if (ret) {
printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
return ret;
}
ret = ieee80211_crypto_tkip_init();
if (ret) {
printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n", ret);
return ret;
}
ret = ieee80211_crypto_ccmp_init();
if (ret) {
printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n", ret);
return ret;
}
ret = ieee80211_crypto_wep_init();
if (ret) {
printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
return ret;
}
printk(KERN_INFO "\nLinux kernel driver for RTL8180 \
/ RTL8185 based WLAN cards\n");
printk(KERN_INFO "Copyright (c) 2004-2005, Andrea Merello\n");
DMESG("Initializing module");
DMESG("Wireless extensions version %d", WIRELESS_EXT);
rtl8180_proc_module_init();
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
if(0!=pci_module_init(&rtl8180_pci_driver))
#else
if(0!=pci_register_driver(&rtl8180_pci_driver))
#endif
//if(0!=pci_module_init(&rtl8180_pci_driver))
{
DMESG("No device found");
/*pci_unregister_driver (&rtl8180_pci_driver);*/
return -ENODEV;
}
return 0;
}
static void __exit rtl8180_pci_module_exit(void)
{
pci_unregister_driver (&rtl8180_pci_driver);
rtl8180_proc_module_remove();
ieee80211_crypto_tkip_exit();
ieee80211_crypto_ccmp_exit();
ieee80211_crypto_wep_exit();
ieee80211_crypto_deinit();
DMESG("Exiting");
}
void rtl8180_try_wake_queue(struct net_device *dev, int pri)
{
unsigned long flags;
short enough_desc;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
spin_lock_irqsave(&priv->tx_lock,flags);
enough_desc = check_nic_enought_desc(dev,pri);
spin_unlock_irqrestore(&priv->tx_lock,flags);
if(enough_desc)
ieee80211_wake_queue(priv->ieee80211);
}
/*****************************************************************************
-----------------------------IRQ STUFF---------------------------
******************************************************************************/
void rtl8180_tx_isr(struct net_device *dev, int pri,short error)
{
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
u32 *tail; //tail virtual addr
u32 *head; //head virtual addr
u32 *begin;//start of ring virtual addr
u32 *nicv; //nic pointer virtual addr
// u32 *txdv; //packet just TXed
u32 nic; //nic pointer physical addr
u32 nicbegin;// start of ring physical addr
// short txed;
unsigned long flag;
/* physical addr are ok on 32 bits since we set DMA mask*/
int offs;
int j,i;
int hd;
if (error) priv->stats.txretry++; //tony 20060601
spin_lock_irqsave(&priv->tx_lock,flag);
switch(pri) {
case MANAGE_PRIORITY:
tail = priv->txmapringtail;
begin = priv->txmapring;
head = priv->txmapringhead;
nic = read_nic_dword(dev,TX_MANAGEPRIORITY_RING_ADDR);
nicbegin = priv->txmapringdma;
break;
case BK_PRIORITY:
tail = priv->txbkpringtail;
begin = priv->txbkpring;
head = priv->txbkpringhead;
nic = read_nic_dword(dev,TX_BKPRIORITY_RING_ADDR);
nicbegin = priv->txbkpringdma;
break;
case BE_PRIORITY:
tail = priv->txbepringtail;
begin = priv->txbepring;
head = priv->txbepringhead;
nic = read_nic_dword(dev,TX_BEPRIORITY_RING_ADDR);
nicbegin = priv->txbepringdma;
break;
case VI_PRIORITY:
tail = priv->txvipringtail;
begin = priv->txvipring;
head = priv->txvipringhead;
nic = read_nic_dword(dev,TX_VIPRIORITY_RING_ADDR);
nicbegin = priv->txvipringdma;
break;
case VO_PRIORITY:
tail = priv->txvopringtail;
begin = priv->txvopring;
head = priv->txvopringhead;
nic = read_nic_dword(dev,TX_VOPRIORITY_RING_ADDR);
nicbegin = priv->txvopringdma;
break;
case HI_PRIORITY:
tail = priv->txhpringtail;
begin = priv->txhpring;
head = priv->txhpringhead;
nic = read_nic_dword(dev,TX_HIGHPRIORITY_RING_ADDR);
nicbegin = priv->txhpringdma;
break;
default:
spin_unlock_irqrestore(&priv->tx_lock,flag);
return ;
}
/* DMESG("%x %s %x %x",((int)nic & 0xfff)/8/4,
*(priv->txnpring + ((int)nic&0xfff)/4/8) & (1<<31) ? "filled" : "empty",
(priv->txnpringtail - priv->txnpring)/8,(priv->txnpringhead -
priv->txnpring)/8);
*/
//nicv = (u32*) ((nic - nicbegin) + (int)begin);
nicv = (u32*) ((nic - nicbegin) + (u8*)begin);
if((head <= tail && (nicv > tail || nicv < head)) ||
(head > tail && (nicv > tail && nicv < head))){
DMESGW("nic has lost pointer");
#ifdef DEBUG_TX_DESC
//check_tx_ring(dev,NORM_PRIORITY);
check_tx_ring(dev,pri);
#endif
spin_unlock_irqrestore(&priv->tx_lock,flag);
rtl8180_restart(dev);
return;
}
/* we check all the descriptors between the head and the nic,
* but not the currenly pointed by the nic (the next to be txed)
* and the previous of the pointed (might be in process ??)
*/
//if (head == nic) return;
//DMESG("%x %x",head,nic);
offs = (nic - nicbegin);
//DMESG("%x %x %x",nic ,(u32)nicbegin, (int)nic -nicbegin);
offs = offs / 8 /4;
hd = (head - begin) /8;
if(offs >= hd)
j = offs - hd;
else
j = offs + (priv->txringcount -1 -hd);
// j= priv->txringcount -1- (hd - offs);
j-=2;
if(j<0) j=0;
for(i=0;i<j;i++)
{
// printk("+++++++++++++check status desc\n");
if((*head) & (1<<31))
break;
if(((*head)&(0x10000000)) != 0){
// printk("++++++++++++++last desc,retry count is %d\n",((*head) & (0x000000ff)));
priv->CurrRetryCnt += (u16)((*head) & (0x000000ff));
#if 1
if(!error)
{
priv->NumTxOkTotal++;
// printk("NumTxOkTotal is %d\n",priv->NumTxOkTotal++);
}
#endif
// printk("in function %s:curr_retry_count is %d\n",__func__,((*head) & (0x000000ff)));
}
if(!error){
priv->NumTxOkBytesTotal += (*(head+3)) & (0x00000fff);
}
// printk("in function %s:curr_txokbyte_count is %d\n",__func__,(*(head+3)) & (0x00000fff));
*head = *head &~ (1<<31);
if((head - begin)/8 == priv->txringcount-1)
head=begin;
else
head+=8;
}
#if 0
if(nicv == begin)
txdv = begin + (priv->txringcount -1)*8;
else
txdv = nicv - 8;
txed = !(txdv[0] &(1<<31));
if(txed){
if(!(txdv[0] & (1<<15))) error = 1;
//if(!(txdv[0] & (1<<30))) error = 1;
if(error)DMESG("%x",txdv[0]);
}
#endif
//DMESG("%x",txdv[0]);
/* the head has been moved to the last certainly TXed
* (or at least processed by the nic) packet.
* The driver take forcefully owning of all these packets
* If the packet previous of the nic pointer has been
* processed this doesn't matter: it will be checked
* here at the next round. Anyway if no more packet are
* TXed no memory leak occour at all.
*/
switch(pri) {
case MANAGE_PRIORITY:
priv->txmapringhead = head;
//printk("1==========================================> priority check!\n");
if(priv->ack_tx_to_ieee){
// try to implement power-save mode 2008.1.22
// printk("2==========================================> priority check!\n");
#if 1
if(rtl8180_is_tx_queue_empty(dev)){
// printk("tx queue empty, after send null sleep packet, try to sleep !\n");
priv->ack_tx_to_ieee = 0;
ieee80211_ps_tx_ack(priv->ieee80211,!error);
}
#endif
}
break;
case BK_PRIORITY:
priv->txbkpringhead = head;
break;
case BE_PRIORITY:
priv->txbepringhead = head;
break;
case VI_PRIORITY:
priv->txvipringhead = head;
break;
case VO_PRIORITY:
priv->txvopringhead = head;
break;
case HI_PRIORITY:
priv->txhpringhead = head;
break;
}
/*DMESG("%x %x %x", (priv->txnpringhead - priv->txnpring) /8 ,
(priv->txnpringtail - priv->txnpring) /8,
offs );
*/
spin_unlock_irqrestore(&priv->tx_lock,flag);
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void rtl8180_tx_irq_wq(struct work_struct *work)
{
//struct r8180_priv *priv = container_of(work, struct r8180_priv, reset_wq);
struct delayed_work *dwork = to_delayed_work(work);
struct ieee80211_device * ieee = (struct ieee80211_device*)
container_of(dwork, struct ieee80211_device, watch_dog_wq);
struct net_device *dev = ieee->dev;
#else
void rtl8180_tx_irq_wq(struct net_device *dev)
{
//struct r8180_priv *priv = ieee80211_priv(dev);
#endif
rtl8180_tx_isr(dev,MANAGE_PRIORITY,0);
}
irqreturn_t rtl8180_interrupt(int irq, void *netdev, struct pt_regs *regs)
{
struct net_device *dev = (struct net_device *) netdev;
struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
unsigned long flags;
u32 inta;
/* We should return IRQ_NONE, but for now let me keep this */
if(priv->irq_enabled == 0) return IRQ_HANDLED;
spin_lock_irqsave(&priv->irq_th_lock,flags);
#ifdef CONFIG_RTL8185B
//ISR: 4bytes
inta = read_nic_dword(dev, ISR);// & priv->IntrMask;
write_nic_dword(dev,ISR,inta); // reset int situation
#else
inta = read_nic_word(dev,INTA) & priv->irq_mask;
write_nic_word(dev,INTA,inta); // reset int situation
#endif
priv->stats.shints++;
//DMESG("Enter interrupt, ISR value = 0x%08x", inta);
if(!inta){
spin_unlock_irqrestore(&priv->irq_th_lock,flags);
return IRQ_HANDLED;
/*
most probably we can safely return IRQ_NONE,
but for now is better to avoid problems
*/
}
if(inta == 0xffff){
/* HW disappared */
spin_unlock_irqrestore(&priv->irq_th_lock,flags);
return IRQ_HANDLED;
}
priv->stats.ints++;
#ifdef DEBUG_IRQ
DMESG("NIC irq %x",inta);
#endif
//priv->irqpending = inta;
if(!netif_running(dev)) {
spin_unlock_irqrestore(&priv->irq_th_lock,flags);
return IRQ_HANDLED;
}
if(inta & ISR_TimeOut){
write_nic_dword(dev, TimerInt, 0);
//DMESG("=================>waking up");
// rtl8180_hw_wakeup(dev);
}
if(inta & ISR_TBDOK){
priv->stats.txbeacon++;
}
if(inta & ISR_TBDER){
priv->stats.txbeaconerr++;
}
if(inta & IMR_TMGDOK ) {
// priv->NumTxOkTotal++;
rtl8180_tx_isr(dev,MANAGE_PRIORITY,0);
// schedule_work(&priv->tx_irq_wq);
}
if(inta & ISR_THPDER){
#ifdef DEBUG_TX
DMESG ("TX high priority ERR");
#endif
priv->stats.txhperr++;
rtl8180_tx_isr(dev,HI_PRIORITY,1);
priv->ieee80211->stats.tx_errors++;
}
if(inta & ISR_THPDOK){ //High priority tx ok
#ifdef DEBUG_TX
DMESG ("TX high priority OK");
#endif
// priv->NumTxOkTotal++;
//priv->NumTxOkInPeriod++; //YJ,del,080828
priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
priv->stats.txhpokint++;
rtl8180_tx_isr(dev,HI_PRIORITY,0);
}
if(inta & ISR_RER) {
priv->stats.rxerr++;
#ifdef DEBUG_RX
DMESGW("RX error int");
#endif
}
#ifdef CONFIG_RTL8185B
if(inta & ISR_TBKDER){ //corresponding to BK_PRIORITY
priv->stats.txbkperr++;
priv->ieee80211->stats.tx_errors++;
#ifdef DEBUG_TX
DMESGW("TX bkp error int");
#endif
//tasklet_schedule(&priv->irq_tx_tasklet);
rtl8180_tx_isr(dev,BK_PRIORITY,1);
rtl8180_try_wake_queue(dev, BE_PRIORITY);
}
if(inta & ISR_TBEDER){ //corresponding to BE_PRIORITY
priv->stats.txbeperr++;
priv->ieee80211->stats.tx_errors++;
#ifdef DEBUG_TX
DMESGW("TX bep error int");
#endif
rtl8180_tx_isr(dev,BE_PRIORITY,1);
//tasklet_schedule(&priv->irq_tx_tasklet);
rtl8180_try_wake_queue(dev, BE_PRIORITY);
}
#endif
if(inta & ISR_TNPDER){ //corresponding to VO_PRIORITY
priv->stats.txnperr++;
priv->ieee80211->stats.tx_errors++;
#ifdef DEBUG_TX
DMESGW("TX np error int");
#endif
//tasklet_schedule(&priv->irq_tx_tasklet);
rtl8180_tx_isr(dev,NORM_PRIORITY,1);
#ifdef CONFIG_RTL8185B
rtl8180_try_wake_queue(dev, NORM_PRIORITY);
#endif
}
if(inta & ISR_TLPDER){ //corresponding to VI_PRIORITY
priv->stats.txlperr++;
priv->ieee80211->stats.tx_errors++;
#ifdef DEBUG_TX
DMESGW("TX lp error int");
#endif
rtl8180_tx_isr(dev,LOW_PRIORITY,1);
//tasklet_schedule(&priv->irq_tx_tasklet);
rtl8180_try_wake_queue(dev, LOW_PRIORITY);
}
if(inta & ISR_ROK){
#ifdef DEBUG_RX
DMESG("Frame arrived !");
#endif
//priv->NumRxOkInPeriod++; //YJ,del,080828
priv->stats.rxint++;
tasklet_schedule(&priv->irq_rx_tasklet);
}
if(inta & ISR_RQoSOK ){
#ifdef DEBUG_RX
DMESG("QoS Frame arrived !");
#endif
//priv->NumRxOkInPeriod++; //YJ,del,080828
priv->stats.rxint++;
tasklet_schedule(&priv->irq_rx_tasklet);
}
if(inta & ISR_BcnInt) {
//DMESG("Preparing Beacons");
rtl8180_prepare_beacon(dev);
}
if(inta & ISR_RDU){
//#ifdef DEBUG_RX
DMESGW("No RX descriptor available");
priv->stats.rxrdu++;
//#endif
tasklet_schedule(&priv->irq_rx_tasklet);
/*queue_work(priv->workqueue ,&priv->restart_work);*/
}
if(inta & ISR_RXFOVW){
#ifdef DEBUG_RX
DMESGW("RX fifo overflow");
#endif
priv->stats.rxoverflow++;
tasklet_schedule(&priv->irq_rx_tasklet);
//queue_work(priv->workqueue ,&priv->restart_work);
}
if(inta & ISR_TXFOVW) priv->stats.txoverflow++;
if(inta & ISR_TNPDOK){ //Normal priority tx ok
#ifdef DEBUG_TX
DMESG ("TX normal priority OK");
#endif
// priv->NumTxOkTotal++;
//priv->NumTxOkInPeriod++; //YJ,del,080828
priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
// priv->ieee80211->stats.tx_packets++;
priv->stats.txnpokint++;
rtl8180_tx_isr(dev,NORM_PRIORITY,0);
}
if(inta & ISR_TLPDOK){ //Low priority tx ok
#ifdef DEBUG_TX
DMESG ("TX low priority OK");
#endif
// priv->NumTxOkTotal++;
//priv->NumTxOkInPeriod++; //YJ,del,080828
priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
// priv->ieee80211->stats.tx_packets++;
priv->stats.txlpokint++;
rtl8180_tx_isr(dev,LOW_PRIORITY,0);
rtl8180_try_wake_queue(dev, LOW_PRIORITY);
}
#ifdef CONFIG_RTL8185B
if(inta & ISR_TBKDOK){ //corresponding to BK_PRIORITY
priv->stats.txbkpokint++;
#ifdef DEBUG_TX
DMESGW("TX bk priority ok");
#endif
// priv->NumTxOkTotal++;
//priv->NumTxOkInPeriod++; //YJ,del,080828
priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
rtl8180_tx_isr(dev,BK_PRIORITY,0);
rtl8180_try_wake_queue(dev, BE_PRIORITY);
}
if(inta & ISR_TBEDOK){ //corresponding to BE_PRIORITY
priv->stats.txbeperr++;
#ifdef DEBUG_TX
DMESGW("TX be priority ok");
#endif
// priv->NumTxOkTotal++;
//priv->NumTxOkInPeriod++; //YJ,del,080828
priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
rtl8180_tx_isr(dev,BE_PRIORITY,0);
rtl8180_try_wake_queue(dev, BE_PRIORITY);
}
#endif
force_pci_posting(dev);
spin_unlock_irqrestore(&priv->irq_th_lock,flags);
return IRQ_HANDLED;
}
void rtl8180_irq_rx_tasklet(struct r8180_priv* priv)
{
// unsigned long flags;
/* spin_lock_irqsave(&priv->irq_lock, flags);
priv->irq_mask &=~IMR_ROK;
priv->irq_mask &=~IMR_RDU;
rtl8180_irq_enable(priv->dev);
spin_unlock_irqrestore(&priv->irq_lock, flags);
*/
rtl8180_rx(priv->dev);
/* spin_lock_irqsave(&priv->irq_lock, flags);
priv->irq_mask |= IMR_ROK;
priv->irq_mask |= IMR_RDU;
rtl8180_irq_enable(priv->dev);
spin_unlock_irqrestore(&priv->irq_lock, flags);
*/
}
/****************************************************************************
lizhaoming--------------------------- RF power on/power off -----------------
*****************************************************************************/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
void GPIOChangeRFWorkItemCallBack(struct work_struct *work)
{
//struct delayed_work *dwork = to_delayed_work(work);
struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, GPIOChangeRFWorkItem.work);
struct net_device *dev = ieee->dev;
struct r8180_priv *priv = ieee80211_priv(dev);
#else
void GPIOChangeRFWorkItemCallBack(struct ieee80211_device *ieee)
{
struct net_device *dev = ieee->dev;
struct r8180_priv *priv = ieee80211_priv(dev);
#endif
//u16 tmp2byte;
u8 btPSR;
u8 btConfig0;
RT_RF_POWER_STATE eRfPowerStateToSet;
bool bActuallySet=false;
char *argv[3];
static char *RadioPowerPath = "/etc/acpi/events/RadioPower.sh";
static char *envp[] = {"HOME=/", "TERM=linux", "PATH=/usr/bin:/bin", NULL};
static int readf_count = 0;
//printk("============>%s in \n", __func__);
#ifdef ENABLE_LPS
if(readf_count % 10 == 0)
priv->PowerProfile = read_acadapter_file("/proc/acpi/ac_adapter/AC0/state");
readf_count = (readf_count+1)%0xffff;
#endif
#if 0
if(priv->up == 0)//driver stopped
{
printk("\nDo nothing...");
goto out;
}
else
#endif
{
// We should turn off LED before polling FF51[4].
//Turn off LED.
btPSR = read_nic_byte(dev, PSR);
write_nic_byte(dev, PSR, (btPSR & ~BIT3));
//It need to delay 4us suggested by Jong, 2008-01-16
udelay(4);
//HW radio On/Off according to the value of FF51[4](config0)
btConfig0 = btPSR = read_nic_byte(dev, CONFIG0);
//Turn on LED.
write_nic_byte(dev, PSR, btPSR| BIT3);
eRfPowerStateToSet = (btConfig0 & BIT4) ? eRfOn : eRfOff;
if((priv->ieee80211->bHwRadioOff == true) && (eRfPowerStateToSet == eRfOn))
{
priv->ieee80211->bHwRadioOff = false;
bActuallySet = true;
}
else if((priv->ieee80211->bHwRadioOff == false) && (eRfPowerStateToSet == eRfOff))
{
priv->ieee80211->bHwRadioOff = true;
bActuallySet = true;
}
if(bActuallySet)
{
MgntActSet_RF_State(dev, eRfPowerStateToSet, RF_CHANGE_BY_HW);
/* To update the UI status for Power status changed */
if(priv->ieee80211->bHwRadioOff == true)
argv[1] = "RFOFF";
else{
//if(!priv->RfOffReason)
argv[1] = "RFON";
//else
// argv[1] = "RFOFF";
}
argv[0] = RadioPowerPath;
argv[2] = NULL;
call_usermodehelper(RadioPowerPath,argv,envp,1);
}
}
}
static u8 read_acadapter_file(char *filename)
{
//#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21))
#if 0
int fd;
char buf[1];
char ret[50];
int i = 0;
int n = 0;
mm_segment_t old_fs = get_fs();
set_fs(KERNEL_DS);
fd = sys_open(filename, O_RDONLY, 0);
if (fd >= 0) {
while (sys_read(fd, buf, 1) == 1)
{
i++;
if(i>10)
{
if(buf[0]!=' ')
{
ret[n]=buf[0];
n++;
}
}
}
sys_close(fd);
}
ret[n]='\0';
// printk("%s \n", ret);
set_fs(old_fs);
if(strncmp(ret, "off-line",8) == 0)
{
return 1;
}
#endif
return 0;
}
/***************************************************************************
------------------- module init / exit stubs ----------------
****************************************************************************/
module_init(rtl8180_pci_module_init);
module_exit(rtl8180_pci_module_exit);