2 This is part of rtl818x pci OpenSource driver - v 0.1
3 Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it>
4 Released under the terms of GPL (General Public License)
6 Parts of this driver are based on the GPL part of the official
9 Parts of this driver are based on the rtl8180 driver skeleton
10 from Patric Schenke & Andres Salomon.
12 Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver.
14 Parts of BB/RF code are derived from David Young rtl8180 netbsd driver.
16 RSSI calc function from 'The Deuce'
18 Some ideas borrowed from the 8139too.c driver included in linux kernel.
20 We (I?) want to thanks the Authors of those projecs and also the
21 Ndiswrapper's project Authors.
23 A big big thanks goes also to Realtek corp. for their help in my attempt to
24 add RTL8185 and RTL8225 support, and to David Young also.
26 Power management interface routines.
27 Written by Mariusz Matuszek.
30 #undef RX_DONT_PASS_UL
33 #include <linux/slab.h>
34 #include <linux/syscalls.h>
35 #include <linux/eeprom_93cx6.h>
39 #include "r8180_rtl8225.h" /* RTL8225 Radio frontend */
40 #include "r8180_93cx6.h" /* Card EEPROM */
44 #include "ieee80211/dot11d.h"
46 static struct pci_device_id rtl8180_pci_id_tbl[] __devinitdata = {
48 .vendor = PCI_VENDOR_ID_REALTEK,
50 .subvendor = PCI_ANY_ID,
51 .subdevice = PCI_ANY_ID,
64 static char* ifname = "wlan%d";
65 static int hwseqnum = 0;
67 static int channels = 0x3fff;
69 #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 )
70 #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])
71 MODULE_LICENSE("GPL");
72 MODULE_DEVICE_TABLE(pci, rtl8180_pci_id_tbl);
73 MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
74 MODULE_DESCRIPTION("Linux driver for Realtek RTL8180 / RTL8185 WiFi cards");
77 module_param(ifname, charp, S_IRUGO|S_IWUSR );
78 module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
79 module_param(hwwep,int, S_IRUGO|S_IWUSR);
80 module_param(channels,int, S_IRUGO|S_IWUSR);
82 MODULE_PARM_DESC(devname," Net interface name, wlan%d=default");
83 MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
84 MODULE_PARM_DESC(hwwep," Try to use hardware WEP support. Still broken and not available on all cards");
85 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
88 static int __devinit rtl8180_pci_probe(struct pci_dev *pdev,
89 const struct pci_device_id *id);
91 static void __devexit rtl8180_pci_remove(struct pci_dev *pdev);
93 static void rtl8180_shutdown (struct pci_dev *pdev)
95 struct net_device *dev = pci_get_drvdata(pdev);
96 if (dev->netdev_ops->ndo_stop)
97 dev->netdev_ops->ndo_stop(dev);
98 pci_disable_device(pdev);
101 static int rtl8180_suspend(struct pci_dev *pdev, pm_message_t state)
103 struct net_device *dev = pci_get_drvdata(pdev);
105 if (!netif_running(dev))
106 goto out_pci_suspend;
108 if (dev->netdev_ops->ndo_stop)
109 dev->netdev_ops->ndo_stop(dev);
111 netif_device_detach(dev);
114 pci_save_state(pdev);
115 pci_disable_device(pdev);
116 pci_set_power_state(pdev, pci_choose_state(pdev, state));
120 static int rtl8180_resume(struct pci_dev *pdev)
122 struct net_device *dev = pci_get_drvdata(pdev);
126 pci_set_power_state(pdev, PCI_D0);
128 err = pci_enable_device(pdev);
130 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
136 pci_restore_state(pdev);
139 * Suspend/Resume resets the PCI configuration space, so we have to
140 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
141 * from interfering with C3 CPU state. pci_restore_state won't help
142 * here since it only restores the first 64 bytes pci config header.
144 pci_read_config_dword(pdev, 0x40, &val);
145 if ((val & 0x0000ff00) != 0)
146 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
148 if (!netif_running(dev))
151 if (dev->netdev_ops->ndo_open)
152 dev->netdev_ops->ndo_open(dev);
154 netif_device_attach(dev);
159 static struct pci_driver rtl8180_pci_driver = {
160 .name = RTL8180_MODULE_NAME,
161 .id_table = rtl8180_pci_id_tbl,
162 .probe = rtl8180_pci_probe,
163 .remove = __devexit_p(rtl8180_pci_remove),
164 .suspend = rtl8180_suspend,
165 .resume = rtl8180_resume,
166 .shutdown = rtl8180_shutdown,
169 u8 read_nic_byte(struct net_device *dev, int x)
171 return 0xff&readb((u8*)dev->mem_start +x);
174 u32 read_nic_dword(struct net_device *dev, int x)
176 return readl((u8*)dev->mem_start +x);
179 u16 read_nic_word(struct net_device *dev, int x)
181 return readw((u8*)dev->mem_start +x);
184 void write_nic_byte(struct net_device *dev, int x,u8 y)
186 writeb(y,(u8*)dev->mem_start +x);
190 void write_nic_dword(struct net_device *dev, int x,u32 y)
192 writel(y,(u8*)dev->mem_start +x);
196 void write_nic_word(struct net_device *dev, int x,u16 y)
198 writew(y,(u8*)dev->mem_start +x);
202 inline void force_pci_posting(struct net_device *dev)
204 read_nic_byte(dev,EPROM_CMD);
208 irqreturn_t rtl8180_interrupt(int irq, void *netdev, struct pt_regs *regs);
209 void set_nic_rxring(struct net_device *dev);
210 void set_nic_txring(struct net_device *dev);
211 static struct net_device_stats *rtl8180_stats(struct net_device *dev);
212 void rtl8180_commit(struct net_device *dev);
213 void rtl8180_start_tx_beacon(struct net_device *dev);
215 static struct proc_dir_entry *rtl8180_proc = NULL;
217 static int proc_get_registers(char *page, char **start,
218 off_t offset, int count,
219 int *eof, void *data)
221 struct net_device *dev = data;
226 /* This dump the current register page */
227 for (n = 0; n <= max;) {
228 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
230 for (i = 0; i < 16 && n <= max; i++, n++)
231 len += snprintf(page + len, count - len, "%2x ",
232 read_nic_byte(dev, n));
234 len += snprintf(page + len, count - len,"\n");
240 int get_curr_tx_free_desc(struct net_device *dev, int priority);
242 static int proc_get_stats_hw(char *page, char **start,
243 off_t offset, int count,
244 int *eof, void *data)
252 static int proc_get_stats_rx(char *page, char **start,
253 off_t offset, int count,
254 int *eof, void *data)
256 struct net_device *dev = data;
257 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
261 len += snprintf(page + len, count - len,
264 "RX CRC Error(0-500): %lu\n"
265 "RX CRC Error(500-1000): %lu\n"
266 "RX CRC Error(>1000): %lu\n"
267 "RX ICV Error: %lu\n",
270 priv->stats.rxcrcerrmin,
271 priv->stats.rxcrcerrmid,
272 priv->stats.rxcrcerrmax,
280 static int proc_get_stats_tx(char *page, char **start,
281 off_t offset, int count,
282 int *eof, void *data)
284 struct net_device *dev = data;
285 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
288 unsigned long totalOK;
290 totalOK=priv->stats.txnpokint+priv->stats.txhpokint+priv->stats.txlpokint;
291 len += snprintf(page + len, count - len,
295 "TX beacon OK: %lu\n"
296 "TX beacon error: %lu\n",
298 priv->stats.txnperr+priv->stats.txhperr+priv->stats.txlperr,
300 priv->stats.txbeacon,
301 priv->stats.txbeaconerr
308 void rtl8180_proc_module_init(void)
310 DMESG("Initializing proc filesystem");
311 rtl8180_proc=create_proc_entry(RTL8180_MODULE_NAME, S_IFDIR, init_net.proc_net);
314 void rtl8180_proc_module_remove(void)
316 remove_proc_entry(RTL8180_MODULE_NAME, init_net.proc_net);
319 void rtl8180_proc_remove_one(struct net_device *dev)
321 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
323 remove_proc_entry("stats-hw", priv->dir_dev);
324 remove_proc_entry("stats-tx", priv->dir_dev);
325 remove_proc_entry("stats-rx", priv->dir_dev);
326 remove_proc_entry("registers", priv->dir_dev);
327 remove_proc_entry(dev->name, rtl8180_proc);
328 priv->dir_dev = NULL;
332 void rtl8180_proc_init_one(struct net_device *dev)
334 struct proc_dir_entry *e;
335 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
337 priv->dir_dev = rtl8180_proc;
338 if (!priv->dir_dev) {
339 DMESGE("Unable to initialize /proc/net/r8180/%s\n",
344 e = create_proc_read_entry("stats-hw", S_IFREG | S_IRUGO,
345 priv->dir_dev, proc_get_stats_hw, dev);
347 DMESGE("Unable to initialize "
348 "/proc/net/r8180/%s/stats-hw\n",
352 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
353 priv->dir_dev, proc_get_stats_rx, dev);
355 DMESGE("Unable to initialize "
356 "/proc/net/r8180/%s/stats-rx\n",
361 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
362 priv->dir_dev, proc_get_stats_tx, dev);
364 DMESGE("Unable to initialize "
365 "/proc/net/r8180/%s/stats-tx\n",
369 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
370 priv->dir_dev, proc_get_registers, dev);
372 DMESGE("Unable to initialize "
373 "/proc/net/r8180/%s/registers\n",
379 FIXME: check if we can use some standard already-existent
380 data type+functions in kernel
383 short buffer_add(struct buffer **buffer, u32 *buf, dma_addr_t dma,
384 struct buffer **bufferhead)
390 *buffer = kmalloc(sizeof(struct buffer),GFP_KERNEL);
392 if (*buffer == NULL) {
393 DMESGE("Failed to kmalloc head of TX/RX struct");
396 (*buffer)->next=*buffer;
399 if(bufferhead !=NULL)
400 (*bufferhead) = (*buffer);
405 while(tmp->next!=(*buffer)) tmp=tmp->next;
406 if ((tmp->next= kmalloc(sizeof(struct buffer),GFP_KERNEL)) == NULL){
407 DMESGE("Failed to kmalloc TX/RX struct");
412 tmp->next->next=*buffer;
417 void buffer_free(struct net_device *dev,struct buffer **buffer,int len,short
421 struct buffer *tmp,*next;
422 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
423 struct pci_dev *pdev=priv->pdev;
433 pci_free_consistent(pdev,len,
436 pci_unmap_single(pdev, tmp->dma,
437 len,PCI_DMA_FROMDEVICE);
443 while(next != *buffer);
448 void print_buffer(u32 *buffer, int len)
451 u8 *buf =(u8*)buffer;
453 printk("ASCII BUFFER DUMP (len: %x):\n",len);
458 printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
461 printk("%02x",buf[i]);
466 int get_curr_tx_free_desc(struct net_device *dev, int priority)
468 struct r8180_priv *priv = ieee80211_priv(dev);
474 case MANAGE_PRIORITY:
475 head = priv->txmapringhead;
476 tail = priv->txmapringtail;
479 head = priv->txbkpringhead;
480 tail = priv->txbkpringtail;
483 head = priv->txbepringhead;
484 tail = priv->txbepringtail;
487 head = priv->txvipringhead;
488 tail = priv->txvipringtail;
491 head = priv->txvopringhead;
492 tail = priv->txvopringtail;
495 head = priv->txhpringhead;
496 tail = priv->txhpringtail;
503 ret = priv->txringcount - (tail - head)/8;
505 ret = (head - tail)/8;
507 if (ret > priv->txringcount)
513 short check_nic_enought_desc(struct net_device *dev, int priority)
515 struct r8180_priv *priv = ieee80211_priv(dev);
516 struct ieee80211_device *ieee = netdev_priv(dev);
517 int requiredbyte, required;
519 requiredbyte = priv->ieee80211->fts + sizeof(struct ieee80211_header_data);
521 if (ieee->current_network.QoS_Enable)
524 required = requiredbyte / (priv->txbuffsize-4);
526 if (requiredbyte % priv->txbuffsize)
529 /* for now we keep two free descriptor as a safety boundary
530 * between the tail and the head
533 return (required+2 < get_curr_tx_free_desc(dev,priority));
536 void fix_tx_fifo(struct net_device *dev)
538 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
542 for (tmp=priv->txmapring, i=0;
543 i < priv->txringcount;
545 *tmp = *tmp &~ (1<<31);
548 for (tmp=priv->txbkpring, i=0;
549 i < priv->txringcount;
551 *tmp = *tmp &~ (1<<31);
554 for (tmp=priv->txbepring, i=0;
555 i < priv->txringcount;
557 *tmp = *tmp &~ (1<<31);
559 for (tmp=priv->txvipring, i=0;
560 i < priv->txringcount;
562 *tmp = *tmp &~ (1<<31);
565 for (tmp=priv->txvopring, i=0;
566 i < priv->txringcount;
568 *tmp = *tmp &~ (1<<31);
571 for (tmp=priv->txhpring, i=0;
572 i < priv->txringcount;
574 *tmp = *tmp &~ (1<<31);
577 for (tmp=priv->txbeaconring, i=0;
578 i < priv->txbeaconcount;
580 *tmp = *tmp &~ (1<<31);
583 priv->txmapringtail = priv->txmapring;
584 priv->txmapringhead = priv->txmapring;
585 priv->txmapbufstail = priv->txmapbufs;
587 priv->txbkpringtail = priv->txbkpring;
588 priv->txbkpringhead = priv->txbkpring;
589 priv->txbkpbufstail = priv->txbkpbufs;
591 priv->txbepringtail = priv->txbepring;
592 priv->txbepringhead = priv->txbepring;
593 priv->txbepbufstail = priv->txbepbufs;
595 priv->txvipringtail = priv->txvipring;
596 priv->txvipringhead = priv->txvipring;
597 priv->txvipbufstail = priv->txvipbufs;
599 priv->txvopringtail = priv->txvopring;
600 priv->txvopringhead = priv->txvopring;
601 priv->txvopbufstail = priv->txvopbufs;
603 priv->txhpringtail = priv->txhpring;
604 priv->txhpringhead = priv->txhpring;
605 priv->txhpbufstail = priv->txhpbufs;
607 priv->txbeaconringtail = priv->txbeaconring;
608 priv->txbeaconbufstail = priv->txbeaconbufs;
611 ieee80211_reset_queue(priv->ieee80211);
612 priv->ack_tx_to_ieee = 0;
615 void fix_rx_fifo(struct net_device *dev)
617 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
619 struct buffer *rxbuf;
622 rx_desc_size = 8; // 4*8 = 32 bytes
624 for (tmp=priv->rxring, rxbuf=priv->rxbufferhead;
625 (tmp < (priv->rxring)+(priv->rxringcount)*rx_desc_size);
626 tmp+=rx_desc_size,rxbuf=rxbuf->next){
627 *(tmp+2) = rxbuf->dma;
629 *tmp=*tmp | priv->rxbuffersize;
633 priv->rxringtail=priv->rxring;
634 priv->rxbuffer=priv->rxbufferhead;
635 priv->rx_skb_complete=1;
639 unsigned char QUALITY_MAP[] = {
640 0x64, 0x64, 0x64, 0x63, 0x63, 0x62, 0x62, 0x61,
641 0x61, 0x60, 0x60, 0x5f, 0x5f, 0x5e, 0x5d, 0x5c,
642 0x5b, 0x5a, 0x59, 0x57, 0x56, 0x54, 0x52, 0x4f,
643 0x4c, 0x49, 0x45, 0x41, 0x3c, 0x37, 0x31, 0x29,
644 0x24, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
645 0x22, 0x22, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20,
646 0x20, 0x20, 0x20, 0x1f, 0x1f, 0x1e, 0x1e, 0x1e,
647 0x1d, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a, 0x19, 0x19,
648 0x18, 0x17, 0x16, 0x15, 0x14, 0x12, 0x11, 0x0f,
649 0x0e, 0x0c, 0x0a, 0x08, 0x06, 0x04, 0x01, 0x00
652 unsigned char STRENGTH_MAP[] = {
653 0x64, 0x64, 0x63, 0x62, 0x61, 0x60, 0x5f, 0x5e,
654 0x5d, 0x5c, 0x5b, 0x5a, 0x57, 0x54, 0x52, 0x50,
655 0x4e, 0x4c, 0x4a, 0x48, 0x46, 0x44, 0x41, 0x3f,
656 0x3c, 0x3a, 0x37, 0x36, 0x36, 0x1c, 0x1c, 0x1b,
657 0x1b, 0x1a, 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17,
658 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13,
659 0x13, 0x12, 0x12, 0x11, 0x11, 0x10, 0x10, 0x0f,
660 0x0f, 0x0e, 0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0b,
661 0x0b, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x07,
662 0x07, 0x06, 0x06, 0x05, 0x04, 0x03, 0x02, 0x00
665 void rtl8180_RSSI_calc(struct net_device *dev, u8 *rssi, u8 *qual)
675 _rssi = 0; // avoid gcc complains..
678 temp = QUALITY_MAP[q];
701 void rtl8180_irq_enable(struct net_device *dev)
703 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
705 priv->irq_enabled = 1;
706 write_nic_word(dev,INTA_MASK, priv->irq_mask);
709 void rtl8180_irq_disable(struct net_device *dev)
711 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
713 write_nic_dword(dev,IMR,0);
714 force_pci_posting(dev);
715 priv->irq_enabled = 0;
718 void rtl8180_set_mode(struct net_device *dev,int mode)
722 ecmd=read_nic_byte(dev, EPROM_CMD);
723 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
724 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
725 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
726 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
727 write_nic_byte(dev, EPROM_CMD, ecmd);
730 void rtl8180_adapter_start(struct net_device *dev);
731 void rtl8180_beacon_tx_enable(struct net_device *dev);
733 void rtl8180_update_msr(struct net_device *dev)
735 struct r8180_priv *priv = ieee80211_priv(dev);
739 msr = read_nic_byte(dev, MSR);
740 msr &= ~ MSR_LINK_MASK;
742 rxconf=read_nic_dword(dev,RX_CONF);
744 if(priv->ieee80211->state == IEEE80211_LINKED)
746 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
747 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
748 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
749 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
750 else if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
751 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
753 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
754 rxconf |= (1<<RX_CHECK_BSSID_SHIFT);
757 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
758 rxconf &= ~(1<<RX_CHECK_BSSID_SHIFT);
761 write_nic_byte(dev, MSR, msr);
762 write_nic_dword(dev, RX_CONF, rxconf);
765 void rtl8180_set_chan(struct net_device *dev,short ch)
767 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
769 if ((ch > 14) || (ch < 1)) {
770 printk("In %s: Invalid chnanel %d\n", __func__, ch);
775 priv->rf_set_chan(dev,priv->chan);
778 void rtl8180_rx_enable(struct net_device *dev)
782 /* for now we accept data, management & ctl frame*/
783 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
785 rxconf=read_nic_dword(dev,RX_CONF);
786 rxconf = rxconf &~ MAC_FILTER_MASK;
787 rxconf = rxconf | (1<<ACCEPT_MNG_FRAME_SHIFT);
788 rxconf = rxconf | (1<<ACCEPT_DATA_FRAME_SHIFT);
789 rxconf = rxconf | (1<<ACCEPT_BCAST_FRAME_SHIFT);
790 rxconf = rxconf | (1<<ACCEPT_MCAST_FRAME_SHIFT);
791 if (dev->flags & IFF_PROMISC)
792 DMESG("NIC in promisc mode");
794 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
795 dev->flags & IFF_PROMISC){
796 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
798 rxconf = rxconf | (1<<ACCEPT_NICMAC_FRAME_SHIFT);
801 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
802 rxconf = rxconf | (1<<ACCEPT_CTL_FRAME_SHIFT);
803 rxconf = rxconf | (1<<ACCEPT_ICVERR_FRAME_SHIFT);
804 rxconf = rxconf | (1<<ACCEPT_PWR_FRAME_SHIFT);
807 if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
808 rxconf = rxconf | (1<<ACCEPT_CRCERR_FRAME_SHIFT);
810 rxconf = rxconf & ~RX_FIFO_THRESHOLD_MASK;
811 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE << RX_FIFO_THRESHOLD_SHIFT);
813 rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
814 rxconf = rxconf &~ MAX_RX_DMA_MASK;
815 rxconf = rxconf | (MAX_RX_DMA_2048<<MAX_RX_DMA_SHIFT);
817 rxconf = rxconf | RCR_ONLYERLPKT;
819 rxconf = rxconf &~ RCR_CS_MASK;
821 write_nic_dword(dev, RX_CONF, rxconf);
825 cmd=read_nic_byte(dev,CMD);
826 write_nic_byte(dev,CMD,cmd | (1<<CMD_RX_ENABLE_SHIFT));
829 void set_nic_txring(struct net_device *dev)
831 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
833 write_nic_dword(dev, TX_MANAGEPRIORITY_RING_ADDR, priv->txmapringdma);
834 write_nic_dword(dev, TX_BKPRIORITY_RING_ADDR, priv->txbkpringdma);
835 write_nic_dword(dev, TX_BEPRIORITY_RING_ADDR, priv->txbepringdma);
836 write_nic_dword(dev, TX_VIPRIORITY_RING_ADDR, priv->txvipringdma);
837 write_nic_dword(dev, TX_VOPRIORITY_RING_ADDR, priv->txvopringdma);
838 write_nic_dword(dev, TX_HIGHPRIORITY_RING_ADDR, priv->txhpringdma);
839 write_nic_dword(dev, TX_BEACON_RING_ADDR, priv->txbeaconringdma);
842 void rtl8180_conttx_enable(struct net_device *dev)
846 txconf = read_nic_dword(dev,TX_CONF);
847 txconf = txconf &~ TX_LOOPBACK_MASK;
848 txconf = txconf | (TX_LOOPBACK_CONTINUE <<TX_LOOPBACK_SHIFT);
849 write_nic_dword(dev,TX_CONF,txconf);
852 void rtl8180_conttx_disable(struct net_device *dev)
856 txconf = read_nic_dword(dev,TX_CONF);
857 txconf = txconf &~ TX_LOOPBACK_MASK;
858 txconf = txconf | (TX_LOOPBACK_NONE <<TX_LOOPBACK_SHIFT);
859 write_nic_dword(dev,TX_CONF,txconf);
862 void rtl8180_tx_enable(struct net_device *dev)
868 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
870 txconf = read_nic_dword(dev, TX_CONF);
872 byte = read_nic_byte(dev, CW_CONF);
873 byte &= ~(1<<CW_CONF_PERPACKET_CW_SHIFT);
874 byte &= ~(1<<CW_CONF_PERPACKET_RETRY_SHIFT);
875 write_nic_byte(dev, CW_CONF, byte);
877 tx_agc_ctl = read_nic_byte(dev, TX_AGC_CTL);
878 tx_agc_ctl &= ~(1<<TX_AGC_CTL_PERPACKET_GAIN_SHIFT);
879 tx_agc_ctl &= ~(1<<TX_AGC_CTL_PERPACKET_ANTSEL_SHIFT);
880 tx_agc_ctl |= (1<<TX_AGC_CTL_FEEDBACK_ANT);
881 write_nic_byte(dev, TX_AGC_CTL, tx_agc_ctl);
882 write_nic_byte(dev, 0xec, 0x3f); /* Disable early TX */
884 txconf = txconf & ~(1<<TCR_PROBE_NOTIMESTAMP_SHIFT);
886 txconf = txconf &~ TX_LOOPBACK_MASK;
887 txconf = txconf | (TX_LOOPBACK_NONE <<TX_LOOPBACK_SHIFT);
888 txconf = txconf &~ TCR_DPRETRY_MASK;
889 txconf = txconf &~ TCR_RTSRETRY_MASK;
890 txconf = txconf | (priv->retry_data<<TX_DPRETRY_SHIFT);
891 txconf = txconf | (priv->retry_rts<<TX_RTSRETRY_SHIFT);
892 txconf = txconf &~ (1<<TX_NOCRC_SHIFT);
894 if (priv->hw_plcp_len)
895 txconf = txconf & ~TCR_PLCP_LEN;
897 txconf = txconf | TCR_PLCP_LEN;
899 txconf = txconf &~ TCR_MXDMA_MASK;
900 txconf = txconf | (TCR_MXDMA_2048<<TCR_MXDMA_SHIFT);
901 txconf = txconf | TCR_CWMIN;
902 txconf = txconf | TCR_DISCW;
904 txconf = txconf | (1 << TX_NOICV_SHIFT);
906 write_nic_dword(dev,TX_CONF,txconf);
910 cmd=read_nic_byte(dev,CMD);
911 write_nic_byte(dev,CMD,cmd | (1<<CMD_TX_ENABLE_SHIFT));
913 write_nic_dword(dev,TX_CONF,txconf);
916 void rtl8180_beacon_tx_enable(struct net_device *dev)
918 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
920 rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
921 priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_BQ);
922 write_nic_byte(dev,TPPollStop, priv->dma_poll_mask);
923 rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
926 void rtl8180_beacon_tx_disable(struct net_device *dev)
928 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
930 rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
931 priv->dma_poll_stop_mask |= TPPOLLSTOP_BQ;
932 write_nic_byte(dev,TPPollStop, priv->dma_poll_stop_mask);
933 rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
937 void rtl8180_rtx_disable(struct net_device *dev)
940 struct r8180_priv *priv = ieee80211_priv(dev);
942 cmd=read_nic_byte(dev,CMD);
943 write_nic_byte(dev, CMD, cmd &~ \
944 ((1<<CMD_RX_ENABLE_SHIFT)|(1<<CMD_TX_ENABLE_SHIFT)));
945 force_pci_posting(dev);
948 if(!priv->rx_skb_complete)
949 dev_kfree_skb_any(priv->rx_skb);
952 short alloc_tx_desc_ring(struct net_device *dev, int bufsize, int count,
958 dma_addr_t dma_desc, dma_tmp;
959 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
960 struct pci_dev *pdev = priv->pdev;
963 if((bufsize & 0xfff) != bufsize) {
964 DMESGE ("TX buffer allocation too large");
967 desc = (u32*)pci_alloc_consistent(pdev,
968 sizeof(u32)*8*count+256, &dma_desc);
974 * descriptor's buffer must be 256 byte aligned
975 * we shouldn't be here, since we set DMA mask !
977 WARN(1, "DMA buffer is not aligned\n");
981 for (i = 0; i < count; i++) {
982 buf = (void *)pci_alloc_consistent(pdev, bufsize, &dma_tmp);
987 case TX_MANAGEPRIORITY_RING_ADDR:
988 if(-1 == buffer_add(&(priv->txmapbufs),buf,dma_tmp,NULL)){
989 DMESGE("Unable to allocate mem for buffer NP");
993 case TX_BKPRIORITY_RING_ADDR:
994 if(-1 == buffer_add(&(priv->txbkpbufs),buf,dma_tmp,NULL)){
995 DMESGE("Unable to allocate mem for buffer LP");
999 case TX_BEPRIORITY_RING_ADDR:
1000 if(-1 == buffer_add(&(priv->txbepbufs),buf,dma_tmp,NULL)){
1001 DMESGE("Unable to allocate mem for buffer NP");
1005 case TX_VIPRIORITY_RING_ADDR:
1006 if(-1 == buffer_add(&(priv->txvipbufs),buf,dma_tmp,NULL)){
1007 DMESGE("Unable to allocate mem for buffer LP");
1011 case TX_VOPRIORITY_RING_ADDR:
1012 if(-1 == buffer_add(&(priv->txvopbufs),buf,dma_tmp,NULL)){
1013 DMESGE("Unable to allocate mem for buffer NP");
1017 case TX_HIGHPRIORITY_RING_ADDR:
1018 if(-1 == buffer_add(&(priv->txhpbufs),buf,dma_tmp,NULL)){
1019 DMESGE("Unable to allocate mem for buffer HP");
1023 case TX_BEACON_RING_ADDR:
1024 if(-1 == buffer_add(&(priv->txbeaconbufs),buf,dma_tmp,NULL)){
1025 DMESGE("Unable to allocate mem for buffer BP");
1030 *tmp = *tmp &~ (1<<31); // descriptor empty, owned by the drv
1031 *(tmp+2) = (u32)dma_tmp;
1035 *(tmp+4) = (u32)dma_desc+((i+1)*8*4);
1037 *(tmp+4) = (u32)dma_desc;
1043 case TX_MANAGEPRIORITY_RING_ADDR:
1044 priv->txmapringdma=dma_desc;
1045 priv->txmapring=desc;
1047 case TX_BKPRIORITY_RING_ADDR:
1048 priv->txbkpringdma=dma_desc;
1049 priv->txbkpring=desc;
1051 case TX_BEPRIORITY_RING_ADDR:
1052 priv->txbepringdma=dma_desc;
1053 priv->txbepring=desc;
1055 case TX_VIPRIORITY_RING_ADDR:
1056 priv->txvipringdma=dma_desc;
1057 priv->txvipring=desc;
1059 case TX_VOPRIORITY_RING_ADDR:
1060 priv->txvopringdma=dma_desc;
1061 priv->txvopring=desc;
1063 case TX_HIGHPRIORITY_RING_ADDR:
1064 priv->txhpringdma=dma_desc;
1065 priv->txhpring=desc;
1067 case TX_BEACON_RING_ADDR:
1068 priv->txbeaconringdma=dma_desc;
1069 priv->txbeaconring=desc;
1077 void free_tx_desc_rings(struct net_device *dev)
1079 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1080 struct pci_dev *pdev=priv->pdev;
1081 int count = priv->txringcount;
1083 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1084 priv->txmapring, priv->txmapringdma);
1085 buffer_free(dev,&(priv->txmapbufs),priv->txbuffsize,1);
1087 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1088 priv->txbkpring, priv->txbkpringdma);
1089 buffer_free(dev,&(priv->txbkpbufs),priv->txbuffsize,1);
1091 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1092 priv->txbepring, priv->txbepringdma);
1093 buffer_free(dev,&(priv->txbepbufs),priv->txbuffsize,1);
1095 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1096 priv->txvipring, priv->txvipringdma);
1097 buffer_free(dev,&(priv->txvipbufs),priv->txbuffsize,1);
1099 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1100 priv->txvopring, priv->txvopringdma);
1101 buffer_free(dev,&(priv->txvopbufs),priv->txbuffsize,1);
1103 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1104 priv->txhpring, priv->txhpringdma);
1105 buffer_free(dev,&(priv->txhpbufs),priv->txbuffsize,1);
1107 count = priv->txbeaconcount;
1108 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1109 priv->txbeaconring, priv->txbeaconringdma);
1110 buffer_free(dev,&(priv->txbeaconbufs),priv->txbuffsize,1);
1113 void free_rx_desc_ring(struct net_device *dev)
1115 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1116 struct pci_dev *pdev = priv->pdev;
1117 int count = priv->rxringcount;
1119 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1120 priv->rxring, priv->rxringdma);
1122 buffer_free(dev,&(priv->rxbuffer),priv->rxbuffersize,0);
1125 short alloc_rx_desc_ring(struct net_device *dev, u16 bufsize, int count)
1130 dma_addr_t dma_desc,dma_tmp;
1131 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1132 struct pci_dev *pdev=priv->pdev;
1136 rx_desc_size = 8; // 4*8 = 32 bytes
1138 if((bufsize & 0xfff) != bufsize){
1139 DMESGE ("RX buffer allocation too large");
1143 desc = (u32*)pci_alloc_consistent(pdev,sizeof(u32)*rx_desc_size*count+256,
1146 if (dma_desc & 0xff)
1148 * descriptor's buffer must be 256 byte aligned
1149 * should never happen since we specify the DMA mask
1151 WARN(1, "DMA buffer is not aligned\n");
1154 priv->rxringdma=dma_desc;
1157 for (i = 0; i < count; i++) {
1158 if ((buf= kmalloc(bufsize * sizeof(u8),GFP_ATOMIC)) == NULL){
1159 DMESGE("Failed to kmalloc RX buffer");
1163 dma_tmp = pci_map_single(pdev,buf,bufsize * sizeof(u8),
1164 PCI_DMA_FROMDEVICE);
1166 if(-1 == buffer_add(&(priv->rxbuffer), buf,dma_tmp,
1167 &(priv->rxbufferhead))){
1168 DMESGE("Unable to allocate mem RX buf");
1171 *tmp = 0; //zero pads the header of the descriptor
1172 *tmp = *tmp |( bufsize&0xfff);
1173 *(tmp+2) = (u32)dma_tmp;
1174 *tmp = *tmp |(1<<31); // descriptor void, owned by the NIC
1176 tmp=tmp+rx_desc_size;
1179 *(tmp-rx_desc_size) = *(tmp-rx_desc_size) | (1<<30); // this is the last descriptor
1185 void set_nic_rxring(struct net_device *dev)
1188 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1190 pgreg=read_nic_byte(dev, PGSELECT);
1191 write_nic_byte(dev, PGSELECT, pgreg &~ (1<<PGSELECT_PG_SHIFT));
1193 write_nic_dword(dev, RXRING_ADDR,priv->rxringdma);
1196 void rtl8180_reset(struct net_device *dev)
1200 rtl8180_irq_disable(dev);
1202 cr=read_nic_byte(dev,CMD);
1204 cr = cr | (1<<CMD_RST_SHIFT);
1205 write_nic_byte(dev,CMD,cr);
1207 force_pci_posting(dev);
1211 if(read_nic_byte(dev,CMD) & (1<<CMD_RST_SHIFT))
1212 DMESGW("Card reset timeout!");
1214 DMESG("Card successfully reset");
1216 rtl8180_set_mode(dev,EPROM_CMD_LOAD);
1217 force_pci_posting(dev);
1221 inline u16 ieeerate2rtlrate(int rate)
1253 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540,720};
1255 inline u16 rtl8180_rate2rate(short rate)
1259 return rtl_rate[rate];
1262 inline u8 rtl8180_IsWirelessBMode(u16 rate)
1264 if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
1270 u16 N_DBPSOfRate(u16 DataRate);
1272 u16 ComputeTxTime(u16 FrameLength, u16 DataRate, u8 bManagementFrame,
1279 if (rtl8180_IsWirelessBMode(DataRate)) {
1280 if (bManagementFrame || !bShortPreamble || DataRate == 10)
1282 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1284 /* short preamble */
1285 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1287 if ((FrameLength*8 % (DataRate/10)) != 0) /* get the ceilling */
1289 } else { /* 802.11g DSSS-OFDM PLCP length field calculation. */
1290 N_DBPS = N_DBPSOfRate(DataRate);
1291 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1292 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1293 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1298 u16 N_DBPSOfRate(u16 DataRate)
1336 // For Netgear case, they want good-looking singal strength.
1338 long NetgearSignalStrengthTranslate(long LastSS, long CurrSS)
1342 // Step 1. Scale mapping.
1343 if (CurrSS >= 71 && CurrSS <= 100)
1344 RetSS = 90 + ((CurrSS - 70) / 3);
1345 else if (CurrSS >= 41 && CurrSS <= 70)
1346 RetSS = 78 + ((CurrSS - 40) / 3);
1347 else if (CurrSS >= 31 && CurrSS <= 40)
1348 RetSS = 66 + (CurrSS - 30);
1349 else if (CurrSS >= 21 && CurrSS <= 30)
1350 RetSS = 54 + (CurrSS - 20);
1351 else if (CurrSS >= 5 && CurrSS <= 20)
1352 RetSS = 42 + (((CurrSS - 5) * 2) / 3);
1353 else if (CurrSS == 4)
1355 else if (CurrSS == 3)
1357 else if (CurrSS == 2)
1359 else if (CurrSS == 1)
1364 // Step 2. Smoothing.
1366 RetSS = ((LastSS * 5) + (RetSS)+ 5) / 6;
1373 // Translate 0-100 signal strength index into dBm.
1375 long TranslateToDbm8185(u8 SignalStrengthIndex)
1379 // Translate to dBm (x=0.5y-95).
1380 SignalPower = (long)((SignalStrengthIndex + 1) >> 1);
1388 // Perform signal smoothing for dynamic mechanism.
1389 // This is different with PerformSignalSmoothing8185 in smoothing fomula.
1390 // No dramatic adjustion is apply because dynamic mechanism need some degree
1391 // of correctness. Ported from 8187B.
1393 void PerformUndecoratedSignalSmoothing8185(struct r8180_priv *priv,
1396 // Determin the current packet is CCK rate.
1397 priv->bCurCCKPkt = bCckRate;
1399 if (priv->UndecoratedSmoothedSS >= 0)
1400 priv->UndecoratedSmoothedSS = ( (priv->UndecoratedSmoothedSS * 5) + (priv->SignalStrength * 10) ) / 6;
1402 priv->UndecoratedSmoothedSS = priv->SignalStrength * 10;
1404 priv->UndercorateSmoothedRxPower = ( (priv->UndercorateSmoothedRxPower * 50) + (priv->RxPower* 11)) / 60;
1407 priv->CurCCKRSSI = priv->RSSI;
1409 priv->CurCCKRSSI = 0;
1413 /* This is rough RX isr handling routine*/
1414 void rtl8180_rx(struct net_device *dev)
1416 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1417 struct sk_buff *tmp_skb;
1421 unsigned char quality, signal;
1430 u8 LNA_gain[4]={02, 17, 29, 39};
1432 struct ieee80211_hdr_4addr *hdr;
1434 u8 bHwError = 0,bCRC = 0,bICV = 0;
1435 bool bCckRate = false;
1437 long SignalStrengthIndex = 0;
1438 struct ieee80211_rx_stats stats = {
1442 .freq = IEEE80211_24GHZ_BAND,
1445 stats.nic_type = NIC_8185B;
1448 if ((*(priv->rxringtail)) & (1<<31)) {
1449 /* we have got an RX int, but the descriptor
1450 * we are pointing is empty*/
1452 priv->stats.rxnodata++;
1453 priv->ieee80211->stats.rx_errors++;
1456 tmp = priv->rxringtail;
1458 if(tmp == priv->rxring)
1459 tmp = priv->rxring + (priv->rxringcount - 1)*rx_desc_size;
1461 tmp -= rx_desc_size;
1463 if(! (*tmp & (1<<31)))
1465 }while(tmp != priv->rxring);
1467 if(tmp2) priv->rxringtail = tmp2;
1470 /* while there are filled descriptors */
1471 while(!(*(priv->rxringtail) & (1<<31))){
1472 if(*(priv->rxringtail) & (1<<26))
1473 DMESGW("RX buffer overflow");
1474 if(*(priv->rxringtail) & (1<<12))
1475 priv->stats.rxicverr++;
1477 if(*(priv->rxringtail) & (1<<27)){
1478 priv->stats.rxdmafail++;
1479 //DMESG("EE: RX DMA FAILED at buffer pointed by descriptor %x",(u32)priv->rxringtail);
1483 pci_dma_sync_single_for_cpu(priv->pdev,
1484 priv->rxbuffer->dma,
1485 priv->rxbuffersize * \
1487 PCI_DMA_FROMDEVICE);
1489 first = *(priv->rxringtail) & (1<<29) ? 1:0;
1490 if(first) priv->rx_prevlen=0;
1492 last = *(priv->rxringtail) & (1<<28) ? 1:0;
1494 lastlen=((*priv->rxringtail) &0xfff);
1496 /* if the last descriptor (that should
1497 * tell us the total packet len) tell
1498 * us something less than the descriptors
1499 * len we had until now, then there is some
1501 * workaround to prevent kernel panic
1503 if(lastlen < priv->rx_prevlen)
1506 len=lastlen-priv->rx_prevlen;
1508 if(*(priv->rxringtail) & (1<<13)) {
1509 if ((*(priv->rxringtail) & 0xfff) <500)
1510 priv->stats.rxcrcerrmin++;
1511 else if ((*(priv->rxringtail) & 0x0fff) >1000)
1512 priv->stats.rxcrcerrmax++;
1514 priv->stats.rxcrcerrmid++;
1519 len = priv->rxbuffersize;
1523 padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
1525 padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
1533 priv->rx_prevlen+=len;
1535 if(priv->rx_prevlen > MAX_FRAG_THRESHOLD + 100){
1536 /* HW is probably passing several buggy frames
1537 * without FD or LD flag set.
1538 * Throw this garbage away to prevent skb
1541 if(!priv->rx_skb_complete)
1542 dev_kfree_skb_any(priv->rx_skb);
1543 priv->rx_skb_complete = 1;
1546 signal=(unsigned char)(((*(priv->rxringtail+3))& (0x00ff0000))>>16);
1547 signal = (signal & 0xfe) >> 1;
1549 quality=(unsigned char)((*(priv->rxringtail+3)) & (0xff));
1551 stats.mac_time[0] = *(priv->rxringtail+1);
1552 stats.mac_time[1] = *(priv->rxringtail+2);
1553 rxpower =((char)(((*(priv->rxringtail+4))& (0x00ff0000))>>16))/2 - 42;
1554 RSSI = ((u8)(((*(priv->rxringtail+3)) & (0x0000ff00))>> 8)) & (0x7f);
1556 rate=((*(priv->rxringtail)) &
1557 ((1<<23)|(1<<22)|(1<<21)|(1<<20)))>>20;
1559 stats.rate = rtl8180_rate2rate(rate);
1560 Antenna = (((*(priv->rxringtail +3))& (0x00008000)) == 0 )? 0:1 ;
1561 if(!rtl8180_IsWirelessBMode(stats.rate))
1564 RxAGC_dBm = rxpower+1; //bias
1568 RxAGC_dBm = signal;//bit 0 discard
1570 LNA = (u8) (RxAGC_dBm & 0x60 ) >> 5 ; //bit 6~ bit 5
1571 BB = (u8) (RxAGC_dBm & 0x1F); // bit 4 ~ bit 0
1573 RxAGC_dBm = -( LNA_gain[LNA] + (BB *2) ); //Pin_11b=-(LNA_gain+BB_gain) (dBm)
1575 RxAGC_dBm +=4; //bias
1578 if(RxAGC_dBm & 0x80) //absolute value
1579 RXAGC= ~(RxAGC_dBm)+1;
1580 bCckRate = rtl8180_IsWirelessBMode(stats.rate);
1581 // Translate RXAGC into 1-100.
1582 if(!rtl8180_IsWirelessBMode(stats.rate))
1588 RXAGC=(90-RXAGC)*100/65;
1596 RXAGC=(95-RXAGC)*100/65;
1598 priv->SignalStrength = (u8)RXAGC;
1599 priv->RecvSignalPower = RxAGC_dBm;
1600 priv->RxPower = rxpower;
1602 /* SQ translation formula is provided by SD3 DZ. 2006.06.27 */
1604 quality = 1;//0; //0 will cause epc to show signal zero , walk aroud now;
1605 else if(quality < 27)
1608 quality = 127 - quality;
1609 priv->SignalQuality = quality;
1611 stats.signal = (u8)quality;//priv->wstats.qual.level = priv->SignalStrength;
1612 stats.signalstrength = RXAGC;
1613 if(stats.signalstrength > 100)
1614 stats.signalstrength = 100;
1615 stats.signalstrength = (stats.signalstrength * 70)/100 + 30;
1616 // printk("==========================>rx : RXAGC is %d,signalstrength is %d\n",RXAGC,stats.signalstrength);
1617 stats.rssi = priv->wstats.qual.qual = priv->SignalQuality;
1618 stats.noise = priv->wstats.qual.noise = 100 - priv ->wstats.qual.qual;
1619 bHwError = (((*(priv->rxringtail))& (0x00000fff)) == 4080)| (((*(priv->rxringtail))& (0x04000000)) != 0 )
1620 | (((*(priv->rxringtail))& (0x08000000)) != 0 )| (((~(*(priv->rxringtail)))& (0x10000000)) != 0 )| (((~(*(priv->rxringtail)))& (0x20000000)) != 0 );
1621 bCRC = ((*(priv->rxringtail)) & (0x00002000)) >> 13;
1622 bICV = ((*(priv->rxringtail)) & (0x00001000)) >> 12;
1623 hdr = (struct ieee80211_hdr_4addr *)priv->rxbuffer->buf;
1624 fc = le16_to_cpu(hdr->frame_ctl);
1625 type = WLAN_FC_GET_TYPE(fc);
1627 if((IEEE80211_FTYPE_CTL != type) &&
1628 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
1629 && (!bHwError) && (!bCRC)&& (!bICV))
1631 /* Perform signal smoothing for dynamic
1632 * mechanism on demand. This is different
1633 * with PerformSignalSmoothing8185 in smoothing
1634 * fomula. No dramatic adjustion is apply
1635 * because dynamic mechanism need some degree
1636 * of correctness. */
1637 PerformUndecoratedSignalSmoothing8185(priv,bCckRate);
1639 // For good-looking singal strength.
1641 SignalStrengthIndex = NetgearSignalStrengthTranslate(
1642 priv->LastSignalStrengthInPercent,
1643 priv->SignalStrength);
1645 priv->LastSignalStrengthInPercent = SignalStrengthIndex;
1646 priv->Stats_SignalStrength = TranslateToDbm8185((u8)SignalStrengthIndex);
1648 // We need more correct power of received packets and the "SignalStrength" of RxStats is beautified,
1649 // so we record the correct power here.
1651 priv->Stats_SignalQuality =(long) (priv->Stats_SignalQuality * 5 + (long)priv->SignalQuality + 5) / 6;
1652 priv->Stats_RecvSignalPower = (long)(priv->Stats_RecvSignalPower * 5 + priv->RecvSignalPower -1) / 6;
1654 // Figure out which antenna that received the lasted packet.
1655 priv->LastRxPktAntenna = Antenna ? 1 : 0; // 0: aux, 1: main.
1656 SwAntennaDiversityRxOk8185(dev, priv->SignalStrength);
1660 if(!priv->rx_skb_complete){
1661 /* seems that HW sometimes fails to reiceve and
1662 doesn't provide the last descriptor */
1663 dev_kfree_skb_any(priv->rx_skb);
1664 priv->stats.rxnolast++;
1666 /* support for prism header has been originally added by Christian */
1667 if(priv->prism_hdr && priv->ieee80211->iw_mode == IW_MODE_MONITOR){
1670 priv->rx_skb = dev_alloc_skb(len+2);
1671 if( !priv->rx_skb) goto drop;
1674 priv->rx_skb_complete=0;
1675 priv->rx_skb->dev=dev;
1677 /* if we are here we should have already RXed
1679 * If we get here and the skb is not allocated then
1680 * we have just throw out garbage (skb not allocated)
1681 * and we are still rxing garbage....
1683 if(!priv->rx_skb_complete){
1685 tmp_skb= dev_alloc_skb(priv->rx_skb->len +len+2);
1687 if(!tmp_skb) goto drop;
1691 memcpy(skb_put(tmp_skb,priv->rx_skb->len),
1695 dev_kfree_skb_any(priv->rx_skb);
1697 priv->rx_skb=tmp_skb;
1701 if(!priv->rx_skb_complete) {
1703 memcpy(skb_put(priv->rx_skb,len),
1704 (((unsigned char *)priv->rxbuffer->buf) + 2),len);
1706 memcpy(skb_put(priv->rx_skb,len),
1707 priv->rxbuffer->buf,len);
1711 if(last && !priv->rx_skb_complete){
1712 if(priv->rx_skb->len > 4)
1713 skb_trim(priv->rx_skb,priv->rx_skb->len-4);
1714 if(!ieee80211_rtl_rx(priv->ieee80211,
1715 priv->rx_skb, &stats))
1716 dev_kfree_skb_any(priv->rx_skb);
1717 priv->rx_skb_complete=1;
1720 pci_dma_sync_single_for_device(priv->pdev,
1721 priv->rxbuffer->dma,
1722 priv->rxbuffersize * \
1724 PCI_DMA_FROMDEVICE);
1726 drop: // this is used when we have not enough mem
1727 /* restore the descriptor */
1728 *(priv->rxringtail+2)=priv->rxbuffer->dma;
1729 *(priv->rxringtail)=*(priv->rxringtail) &~ 0xfff;
1730 *(priv->rxringtail)=
1731 *(priv->rxringtail) | priv->rxbuffersize;
1733 *(priv->rxringtail)=
1734 *(priv->rxringtail) | (1<<31);
1736 priv->rxringtail+=rx_desc_size;
1737 if(priv->rxringtail >=
1738 (priv->rxring)+(priv->rxringcount )*rx_desc_size)
1739 priv->rxringtail=priv->rxring;
1741 priv->rxbuffer=(priv->rxbuffer->next);
1746 void rtl8180_dma_kick(struct net_device *dev, int priority)
1748 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1750 rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
1751 write_nic_byte(dev, TX_DMA_POLLING,
1752 (1 << (priority + 1)) | priv->dma_poll_mask);
1753 rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
1755 force_pci_posting(dev);
1758 void rtl8180_data_hard_stop(struct net_device *dev)
1760 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1762 rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
1763 priv->dma_poll_stop_mask |= TPPOLLSTOP_AC_VIQ;
1764 write_nic_byte(dev,TPPollStop, priv->dma_poll_stop_mask);
1765 rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
1768 void rtl8180_data_hard_resume(struct net_device *dev)
1770 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1772 rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
1773 priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_AC_VIQ);
1774 write_nic_byte(dev,TPPollStop, priv->dma_poll_stop_mask);
1775 rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
1778 /* this function TX data frames when the ieee80211 stack requires this.
1779 * It checks also if we need to stop the ieee tx queue, eventually do it
1781 void rtl8180_hard_data_xmit(struct sk_buff *skb,struct net_device *dev, int
1784 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1786 struct ieee80211_hdr_3addr *h = (struct ieee80211_hdr_3addr *) skb->data;
1787 short morefrag = (h->frame_control) & IEEE80211_FCTL_MOREFRAGS;
1788 unsigned long flags;
1791 mode = priv->ieee80211->iw_mode;
1793 rate = ieeerate2rtlrate(rate);
1795 * This function doesn't require lock because we make
1796 * sure it's called with the tx_lock already acquired.
1797 * this come from the kernel's hard_xmit callback (through
1798 * the ieee stack, or from the try_wake_queue (again through
1801 priority = AC2Q(skb->priority);
1802 spin_lock_irqsave(&priv->tx_lock,flags);
1804 if(priv->ieee80211->bHwRadioOff)
1806 spin_unlock_irqrestore(&priv->tx_lock,flags);
1811 if (!check_nic_enought_desc(dev, priority)){
1812 DMESGW("Error: no descriptor left by previous TX (avail %d) ",
1813 get_curr_tx_free_desc(dev, priority));
1814 ieee80211_rtl_stop_queue(priv->ieee80211);
1816 rtl8180_tx(dev, skb->data, skb->len, priority, morefrag,0,rate);
1817 if (!check_nic_enought_desc(dev, priority))
1818 ieee80211_rtl_stop_queue(priv->ieee80211);
1820 spin_unlock_irqrestore(&priv->tx_lock,flags);
1823 /* This is a rough attempt to TX a frame
1824 * This is called by the ieee 80211 stack to TX management frames.
1825 * If the ring is full packet are dropped (for data frame the queue
1826 * is stopped before this can happen). For this reason it is better
1827 * if the descriptors are larger than the largest management frame
1828 * we intend to TX: i'm unsure what the HW does if it will not found
1829 * the last fragment of a frame because it has been dropped...
1830 * Since queues for Management and Data frames are different we
1831 * might use a different lock than tx_lock (for example mgmt_tx_lock)
1833 /* these function may loops if invoked with 0 descriptors or 0 len buffer*/
1834 int rtl8180_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1836 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1837 unsigned long flags;
1840 priority = MANAGE_PRIORITY;
1842 spin_lock_irqsave(&priv->tx_lock,flags);
1844 if (priv->ieee80211->bHwRadioOff) {
1845 spin_unlock_irqrestore(&priv->tx_lock,flags);
1846 dev_kfree_skb_any(skb);
1847 return NETDEV_TX_OK;
1850 rtl8180_tx(dev, skb->data, skb->len, priority,
1851 0, 0,ieeerate2rtlrate(priv->ieee80211->basic_rate));
1853 priv->ieee80211->stats.tx_bytes+=skb->len;
1854 priv->ieee80211->stats.tx_packets++;
1855 spin_unlock_irqrestore(&priv->tx_lock,flags);
1857 dev_kfree_skb_any(skb);
1858 return NETDEV_TX_OK;
1861 // longpre 144+48 shortpre 72+24
1862 u16 rtl8180_len2duration(u32 len, short rate,short* ext)
1871 duration = ((len+4)<<4) /0x2;
1872 drift = ((len+4)<<4) % 0x2;
1873 if(drift ==0 ) break;
1878 duration = ((len+4)<<4) /0x4;
1879 drift = ((len+4)<<4) % 0x4;
1880 if(drift ==0 ) break;
1885 duration = ((len+4)<<4) /0xb;
1886 drift = ((len+4)<<4) % 0xb;
1894 duration = ((len+4)<<4) /0x16;
1895 drift = ((len+4)<<4) % 0x16;
1908 void rtl8180_prepare_beacon(struct net_device *dev)
1910 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1911 struct sk_buff *skb;
1913 u16 word = read_nic_word(dev, BcnItv);
1914 word &= ~BcnItv_BcnItv; // clear Bcn_Itv
1915 word |= cpu_to_le16(priv->ieee80211->current_network.beacon_interval);//0x64;
1916 write_nic_word(dev, BcnItv, word);
1918 skb = ieee80211_get_beacon(priv->ieee80211);
1920 rtl8180_tx(dev,skb->data,skb->len,BEACON_PRIORITY,
1921 0,0,ieeerate2rtlrate(priv->ieee80211->basic_rate));
1922 dev_kfree_skb_any(skb);
1926 /* This function do the real dirty work: it enqueues a TX command
1927 * descriptor in the ring buffer, copyes the frame in a TX buffer
1928 * and kicks the NIC to ensure it does the DMA transfer.
1930 short rtl8180_tx(struct net_device *dev, u8* txbuf, int len, int priority,
1931 short morefrag, short descfrag, int rate)
1933 struct r8180_priv *priv = ieee80211_priv(dev);
1934 u32 *tail,*temp_tail;
1943 struct buffer* buflist;
1944 struct ieee80211_hdr_3addr *frag_hdr = (struct ieee80211_hdr_3addr *)txbuf;
1946 u8 bUseShortPreamble = 0;
1951 u16 ThisFrameTime = 0;
1952 u16 TxDescDuration = 0;
1953 u8 ownbit_flag = false;
1956 case MANAGE_PRIORITY:
1957 tail=priv->txmapringtail;
1958 begin=priv->txmapring;
1959 buflist = priv->txmapbufstail;
1960 count = priv->txringcount;
1963 tail=priv->txbkpringtail;
1964 begin=priv->txbkpring;
1965 buflist = priv->txbkpbufstail;
1966 count = priv->txringcount;
1969 tail=priv->txbepringtail;
1970 begin=priv->txbepring;
1971 buflist = priv->txbepbufstail;
1972 count = priv->txringcount;
1975 tail=priv->txvipringtail;
1976 begin=priv->txvipring;
1977 buflist = priv->txvipbufstail;
1978 count = priv->txringcount;
1981 tail=priv->txvopringtail;
1982 begin=priv->txvopring;
1983 buflist = priv->txvopbufstail;
1984 count = priv->txringcount;
1987 tail=priv->txhpringtail;
1988 begin=priv->txhpring;
1989 buflist = priv->txhpbufstail;
1990 count = priv->txringcount;
1992 case BEACON_PRIORITY:
1993 tail=priv->txbeaconringtail;
1994 begin=priv->txbeaconring;
1995 buflist = priv->txbeaconbufstail;
1996 count = priv->txbeaconcount;
2003 memcpy(&dest, frag_hdr->addr1, ETH_ALEN);
2004 if (is_multicast_ether_addr(dest) ||
2005 is_broadcast_ether_addr(dest))
2012 ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate), 0, bUseShortPreamble);
2013 TxDescDuration = ThisFrameTime;
2014 } else {// Unicast packet
2017 //YJ,add,080828,for Keep alive
2018 priv->NumTxUnicast++;
2020 /* Figure out ACK rate according to BSS basic rate
2022 AckTime = ComputeTxTime(14, 10,0, 0); // AckCTSLng = 14 use 1M bps send
2024 if ( ((len + sCrcLng) > priv->rts) && priv->rts )
2026 u16 RtsTime, CtsTime;
2031 // Rate and time required for RTS.
2032 RtsTime = ComputeTxTime( sAckCtsLng/8,priv->ieee80211->basic_rate, 0, 0);
2033 // Rate and time required for CTS.
2034 CtsTime = ComputeTxTime(14, 10,0, 0); // AckCTSLng = 14 use 1M bps send
2036 // Figure out time required to transmit this frame.
2037 ThisFrameTime = ComputeTxTime(len + sCrcLng,
2038 rtl8180_rate2rate(rate),
2042 // RTS-CTS-ThisFrame-ACK.
2043 RtsDur = CtsTime + ThisFrameTime + AckTime + 3*aSifsTime;
2045 TxDescDuration = RtsTime + RtsDur;
2047 else {// Normal case.
2052 ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate), 0, bUseShortPreamble);
2053 TxDescDuration = ThisFrameTime + aSifsTime + AckTime;
2056 if (!(frag_hdr->frame_control & IEEE80211_FCTL_MOREFRAGS)) {
2058 Duration = aSifsTime + AckTime;
2059 } else { // One or more fragments remained.
2061 NextFragTime = ComputeTxTime( len + sCrcLng, //pretend following packet length equal current packet
2062 rtl8180_rate2rate(rate),
2064 bUseShortPreamble );
2066 //ThisFrag-ACk-NextFrag-ACK.
2067 Duration = NextFragTime + 3*aSifsTime + 2*AckTime;
2070 } // End of Unicast packet
2072 frag_hdr->duration_id = Duration;
2074 buflen=priv->txbuffsize;
2081 DMESGE("TX buffer error, cannot TX frames. pri %d.", priority);
2086 if ((*tail & (1 << 31)) && (priority != BEACON_PRIORITY)) {
2087 DMESGW("No more TX desc, returning %x of %x",
2089 priv->stats.txrdu++;
2093 *tail= 0; // zeroes header
2100 /*FIXME: this should be triggered by HW encryption parameters.*/
2101 *tail |= (1<<15); /* no encrypt */
2103 if(remain==len && !descfrag) {
2104 ownbit_flag = false;
2105 *tail = *tail| (1<<29) ; //fist segment of the packet
2106 *tail = *tail |(len);
2111 for(i=0;i<buflen&& remain >0;i++,remain--){
2112 ((u8*)buf)[i]=txbuf[i]; //copy data into descriptor pointed DMAble buffer
2113 if(remain == 4 && i+4 >= buflen) break;
2114 /* ensure the last desc has at least 4 bytes payload */
2118 *(tail+3)=*(tail+3) &~ 0xfff;
2119 *(tail+3)=*(tail+3) | i; // buffer lenght
2120 // Use short preamble or not
2121 if (priv->ieee80211->current_network.capability&WLAN_CAPABILITY_SHORT_PREAMBLE)
2122 if (priv->plcp_preamble_mode==1 && rate!=0) // short mode now, not long!
2123 ;// *tail |= (1<<16); // enable short preamble mode.
2129 if(bRTSEnable) //rts enable
2131 *tail |= ((ieeerate2rtlrate(priv->ieee80211->basic_rate))<<19);//RTS RATE
2132 *tail |= (1<<23);//rts enable
2133 *(tail+1) |=(RtsDur&0xffff);//RTS Duration
2135 *(tail+3) |= ((TxDescDuration&0xffff)<<16); //DURATION
2136 // *(tail+3) |= (0xe6<<16);
2137 *(tail+5) |= (11<<8);//(priv->retry_data<<8); //retry lim ;
2139 *tail = *tail | ((rate&0xf) << 24);
2141 /* hw_plcp_len is not used for rtl8180 chip */
2143 if (!priv->hw_plcp_len) {
2144 duration = rtl8180_len2duration(len, rate, &ext);
2145 *(tail+1) = *(tail+1) | ((duration & 0x7fff)<<16);
2146 if(ext) *(tail+1) = *(tail+1) |(1<<31); //plcp length extension
2149 if(morefrag) *tail = (*tail) | (1<<17); // more fragment
2150 if(!remain) *tail = (*tail) | (1<<28); // last segment of frame
2152 *(tail+5) = *(tail+5)|(2<<27);
2153 *(tail+7) = *(tail+7)|(1<<4);
2158 *tail = *tail | (1<<31); // descriptor ready to be txed
2161 if((tail - begin)/8 == count-1)
2166 buflist=buflist->next;
2171 case MANAGE_PRIORITY:
2172 priv->txmapringtail=tail;
2173 priv->txmapbufstail=buflist;
2176 priv->txbkpringtail=tail;
2177 priv->txbkpbufstail=buflist;
2180 priv->txbepringtail=tail;
2181 priv->txbepbufstail=buflist;
2184 priv->txvipringtail=tail;
2185 priv->txvipbufstail=buflist;
2188 priv->txvopringtail=tail;
2189 priv->txvopbufstail=buflist;
2192 priv->txhpringtail=tail;
2193 priv->txhpbufstail = buflist;
2195 case BEACON_PRIORITY:
2196 /* the HW seems to be happy with the 1st
2197 * descriptor filled and the 2nd empty...
2198 * So always update descriptor 1 and never
2204 *temp_tail = *temp_tail | (1<<31); // descriptor ready to be txed
2205 rtl8180_dma_kick(dev,priority);
2210 void rtl8180_irq_rx_tasklet(struct r8180_priv * priv);
2212 void rtl8180_link_change(struct net_device *dev)
2214 struct r8180_priv *priv = ieee80211_priv(dev);
2215 u16 beacon_interval;
2216 struct ieee80211_network *net = &priv->ieee80211->current_network;
2218 rtl8180_update_msr(dev);
2220 rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
2222 write_nic_dword(dev,BSSID,((u32*)net->bssid)[0]);
2223 write_nic_word(dev,BSSID+4,((u16*)net->bssid)[2]);
2225 beacon_interval = read_nic_dword(dev,BEACON_INTERVAL);
2226 beacon_interval &= ~ BEACON_INTERVAL_MASK;
2227 beacon_interval |= net->beacon_interval;
2228 write_nic_dword(dev, BEACON_INTERVAL, beacon_interval);
2230 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
2232 rtl8180_set_chan(dev, priv->chan);
2235 void rtl8180_rq_tx_ack(struct net_device *dev){
2237 struct r8180_priv *priv = ieee80211_priv(dev);
2239 write_nic_byte(dev,CONFIG4,read_nic_byte(dev,CONFIG4)|CONFIG4_PWRMGT);
2240 priv->ack_tx_to_ieee = 1;
2243 short rtl8180_is_tx_queue_empty(struct net_device *dev){
2245 struct r8180_priv *priv = ieee80211_priv(dev);
2248 for (d = priv->txmapring;
2249 d < priv->txmapring + priv->txringcount;d+=8)
2250 if(*d & (1<<31)) return 0;
2252 for (d = priv->txbkpring;
2253 d < priv->txbkpring + priv->txringcount;d+=8)
2254 if(*d & (1<<31)) return 0;
2256 for (d = priv->txbepring;
2257 d < priv->txbepring + priv->txringcount;d+=8)
2258 if(*d & (1<<31)) return 0;
2260 for (d = priv->txvipring;
2261 d < priv->txvipring + priv->txringcount;d+=8)
2262 if(*d & (1<<31)) return 0;
2264 for (d = priv->txvopring;
2265 d < priv->txvopring + priv->txringcount;d+=8)
2266 if(*d & (1<<31)) return 0;
2268 for (d = priv->txhpring;
2269 d < priv->txhpring + priv->txringcount;d+=8)
2270 if(*d & (1<<31)) return 0;
2273 /* FIXME FIXME 5msecs is random */
2274 #define HW_WAKE_DELAY 5
2276 void rtl8180_hw_wakeup(struct net_device *dev)
2278 unsigned long flags;
2279 struct r8180_priv *priv = ieee80211_priv(dev);
2281 spin_lock_irqsave(&priv->ps_lock,flags);
2282 write_nic_byte(dev,CONFIG4,read_nic_byte(dev,CONFIG4)&~CONFIG4_PWRMGT);
2283 if (priv->rf_wakeup)
2284 priv->rf_wakeup(dev);
2285 spin_unlock_irqrestore(&priv->ps_lock,flags);
2288 void rtl8180_hw_sleep_down(struct net_device *dev)
2290 unsigned long flags;
2291 struct r8180_priv *priv = ieee80211_priv(dev);
2293 spin_lock_irqsave(&priv->ps_lock,flags);
2295 priv->rf_sleep(dev);
2296 spin_unlock_irqrestore(&priv->ps_lock,flags);
2299 void rtl8180_hw_sleep(struct net_device *dev, u32 th, u32 tl)
2301 struct r8180_priv *priv = ieee80211_priv(dev);
2303 unsigned long flags;
2305 spin_lock_irqsave(&priv->ps_lock,flags);
2307 /* Writing HW register with 0 equals to disable
2308 * the timer, that is not really what we want
2310 tl -= MSECS(4+16+7);
2312 /* If the interval in witch we are requested to sleep is too
2313 * short then give up and remain awake
2315 if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
2316 ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
2317 spin_unlock_irqrestore(&priv->ps_lock,flags);
2318 printk("too short to sleep\n");
2323 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
2325 priv->DozePeriodInPast2Sec += jiffies_to_msecs(tmp);
2327 queue_delayed_work(priv->ieee80211->wq, &priv->ieee80211->hw_wakeup_wq, tmp); //as tl may be less than rb
2329 /* if we suspect the TimerInt is gone beyond tl
2330 * while setting it, then give up
2333 if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
2334 ((tl < rb) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))) {
2335 spin_unlock_irqrestore(&priv->ps_lock,flags);
2339 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_sleep_wq);
2340 spin_unlock_irqrestore(&priv->ps_lock,flags);
2343 void rtl8180_wmm_param_update(struct work_struct * work)
2345 struct ieee80211_device * ieee = container_of(work, struct ieee80211_device,wmm_param_update_wq);
2346 struct net_device *dev = ieee->dev;
2347 u8 *ac_param = (u8 *)(ieee->current_network.wmm_param);
2348 u8 mode = ieee->current_network.mode;
2354 if(!ieee->current_network.QoS_Enable){
2355 //legacy ac_xx_param update
2356 AcParam.longData = 0;
2357 AcParam.f.AciAifsn.f.AIFSN = 2; // Follow 802.11 DIFS.
2358 AcParam.f.AciAifsn.f.ACM = 0;
2359 AcParam.f.Ecw.f.ECWmin = 3; // Follow 802.11 CWmin.
2360 AcParam.f.Ecw.f.ECWmax = 7; // Follow 802.11 CWmax.
2361 AcParam.f.TXOPLimit = 0;
2362 for(eACI = 0; eACI < AC_MAX; eACI++){
2363 AcParam.f.AciAifsn.f.ACI = (u8)eACI;
2367 pAcParam = (PAC_PARAM)(&AcParam);
2368 // Retrive paramters to udpate.
2369 u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN *(((mode&IEEE_G) == IEEE_G)?9:20) + aSifsTime;
2370 u4bAcParam = ((((u32)(pAcParam->f.TXOPLimit))<<AC_PARAM_TXOP_LIMIT_OFFSET)|
2371 (((u32)(pAcParam->f.Ecw.f.ECWmax))<<AC_PARAM_ECW_MAX_OFFSET)|
2372 (((u32)(pAcParam->f.Ecw.f.ECWmin))<<AC_PARAM_ECW_MIN_OFFSET)|
2373 (((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
2376 write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
2379 write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
2382 write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
2385 write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
2388 printk(KERN_WARNING "SetHwReg8185():invalid ACI: %d!\n", eACI);
2396 for(i = 0; i < AC_MAX; i++){
2397 //AcParam.longData = 0;
2398 pAcParam = (AC_PARAM * )ac_param;
2404 // Retrive paramters to udpate.
2405 eACI = pAcParam->f.AciAifsn.f.ACI;
2406 //Mode G/A: slotTimeTimer = 9; Mode B: 20
2407 u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN * (((mode&IEEE_G) == IEEE_G)?9:20) + aSifsTime;
2408 u4bAcParam = ( (((u32)(pAcParam->f.TXOPLimit)) << AC_PARAM_TXOP_LIMIT_OFFSET) |
2409 (((u32)(pAcParam->f.Ecw.f.ECWmax)) << AC_PARAM_ECW_MAX_OFFSET) |
2410 (((u32)(pAcParam->f.Ecw.f.ECWmin)) << AC_PARAM_ECW_MIN_OFFSET) |
2411 (((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
2415 write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
2418 write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
2421 write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
2424 write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
2427 printk(KERN_WARNING "SetHwReg8185(): invalid ACI: %d !\n", eACI);
2431 ac_param += (sizeof(AC_PARAM));
2435 void rtl8180_tx_irq_wq(struct work_struct *work);
2436 void rtl8180_restart_wq(struct work_struct *work);
2437 //void rtl8180_rq_tx_ack(struct work_struct *work);
2438 void rtl8180_watch_dog_wq(struct work_struct *work);
2439 void rtl8180_hw_wakeup_wq(struct work_struct *work);
2440 void rtl8180_hw_sleep_wq(struct work_struct *work);
2441 void rtl8180_sw_antenna_wq(struct work_struct *work);
2442 void rtl8180_watch_dog(struct net_device *dev);
2444 void watch_dog_adaptive(unsigned long data)
2446 struct r8180_priv* priv = ieee80211_priv((struct net_device *)data);
2449 DMESG("<----watch_dog_adaptive():driver is not up!\n");
2453 // Tx High Power Mechanism.
2454 if(CheckHighPower((struct net_device *)data))
2455 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->tx_pw_wq);
2457 // Tx Power Tracking on 87SE.
2458 if (CheckTxPwrTracking((struct net_device *)data))
2459 TxPwrTracking87SE((struct net_device *)data);
2461 // Perform DIG immediately.
2462 if(CheckDig((struct net_device *)data) == true)
2463 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_dig_wq);
2464 rtl8180_watch_dog((struct net_device *)data);
2466 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->GPIOChangeRFWorkItem);
2468 priv->watch_dog_timer.expires = jiffies + MSECS(IEEE80211_WATCH_DOG_TIME);
2469 add_timer(&priv->watch_dog_timer);
2472 static CHANNEL_LIST ChannelPlan[] = {
2473 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64},19}, //FCC
2474 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
2475 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
2476 {{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.
2477 {{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.
2478 {{14,36,40,44,48,52,56,60,64},9}, //MKK
2479 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14, 36,40,44,48,52,56,60,64},22},//MKK1
2480 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //Israel.
2481 {{1,2,3,4,5,6,7,8,9,10,11,12,13,34,38,42,46},17}, // For 11a , TELEC
2482 {{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
2483 {{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
2486 static void rtl8180_set_channel_map(u8 channel_plan, struct ieee80211_device *ieee)
2491 ieee->MinPassiveChnlNum=MAX_CHANNEL_NUMBER+1;
2492 ieee->IbssStartChnl=0;
2494 switch (channel_plan)
2496 case COUNTRY_CODE_FCC:
2497 case COUNTRY_CODE_IC:
2498 case COUNTRY_CODE_ETSI:
2499 case COUNTRY_CODE_SPAIN:
2500 case COUNTRY_CODE_FRANCE:
2501 case COUNTRY_CODE_MKK:
2502 case COUNTRY_CODE_MKK1:
2503 case COUNTRY_CODE_ISRAEL:
2504 case COUNTRY_CODE_TELEC:
2507 ieee->bGlobalDomain = false;
2508 if (ChannelPlan[channel_plan].Len != 0){
2509 // Clear old channel map
2510 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
2511 // Set new channel map
2512 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
2514 if(ChannelPlan[channel_plan].Channel[i] <= 14)
2515 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
2520 case COUNTRY_CODE_GLOBAL_DOMAIN:
2522 GET_DOT11D_INFO(ieee)->bEnabled = 0;
2524 ieee->bGlobalDomain = true;
2527 case COUNTRY_CODE_WORLD_WIDE_13_INDEX://lzm add 080826
2529 ieee->MinPassiveChnlNum=12;
2530 ieee->IbssStartChnl= 10;
2536 ieee->bGlobalDomain = false;
2537 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
2540 GET_DOT11D_INFO(ieee)->channel_map[i] = 1;
2547 void GPIOChangeRFWorkItemCallBack(struct work_struct *work);
2550 static void rtl8180_statistics_init(struct Stats *pstats)
2552 memset(pstats, 0, sizeof(struct Stats));
2555 static void rtl8180_link_detect_init(plink_detect_t plink_detect)
2557 memset(plink_detect, 0, sizeof(link_detect_t));
2558 plink_detect->SlotNum = DEFAULT_SLOT_NUM;
2562 static void rtl8187se_eeprom_register_read(struct eeprom_93cx6 *eeprom)
2564 struct net_device *dev = eeprom->data;
2565 u8 reg = read_nic_byte(dev, EPROM_CMD);
2567 eeprom->reg_data_in = reg & RTL818X_EEPROM_CMD_WRITE;
2568 eeprom->reg_data_out = reg & RTL818X_EEPROM_CMD_READ;
2569 eeprom->reg_data_clock = reg & RTL818X_EEPROM_CMD_CK;
2570 eeprom->reg_chip_select = reg & RTL818X_EEPROM_CMD_CS;
2573 static void rtl8187se_eeprom_register_write(struct eeprom_93cx6 *eeprom)
2575 struct net_device *dev = eeprom->data;
2578 if (eeprom->reg_data_in)
2579 reg |= RTL818X_EEPROM_CMD_WRITE;
2580 if (eeprom->reg_data_out)
2581 reg |= RTL818X_EEPROM_CMD_READ;
2582 if (eeprom->reg_data_clock)
2583 reg |= RTL818X_EEPROM_CMD_CK;
2584 if (eeprom->reg_chip_select)
2585 reg |= RTL818X_EEPROM_CMD_CS;
2587 write_nic_byte(dev, EPROM_CMD, reg);
2588 read_nic_byte(dev, EPROM_CMD);
2592 short rtl8180_init(struct net_device *dev)
2594 struct r8180_priv *priv = ieee80211_priv(dev);
2600 struct eeprom_93cx6 eeprom;
2604 eeprom.register_read = rtl8187se_eeprom_register_read;
2605 eeprom.register_write = rtl8187se_eeprom_register_write;
2606 eeprom.width = PCI_EEPROM_WIDTH_93C46;
2608 eeprom_93cx6_read(&eeprom, EEPROM_COUNTRY_CODE>>1, &eeprom_val);
2609 priv->channel_plan = eeprom_val & 0xFF;
2610 if(priv->channel_plan > COUNTRY_CODE_GLOBAL_DOMAIN){
2611 printk("rtl8180_init:Error channel plan! Set to default.\n");
2612 priv->channel_plan = 0;
2615 DMESG("Channel plan is %d\n",priv->channel_plan);
2616 rtl8180_set_channel_map(priv->channel_plan, priv->ieee80211);
2618 //FIXME: these constants are placed in a bad pleace.
2619 priv->txbuffsize = 2048;//1024;
2620 priv->txringcount = 32;//32;
2621 priv->rxbuffersize = 2048;//1024;
2622 priv->rxringcount = 64;//32;
2623 priv->txbeaconcount = 2;
2624 priv->rx_skb_complete = 1;
2626 priv->RFChangeInProgress = false;
2627 priv->SetRFPowerStateInProgress = false;
2628 priv->RFProgType = 0;
2629 priv->bInHctTest = false;
2631 priv->irq_enabled=0;
2633 rtl8180_statistics_init(&priv->stats);
2634 rtl8180_link_detect_init(&priv->link_detect);
2636 priv->ack_tx_to_ieee = 0;
2637 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2638 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2639 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2640 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2641 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;
2642 priv->ieee80211->active_scan = 1;
2643 priv->ieee80211->rate = 110; //11 mbps
2644 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION;
2645 priv->ieee80211->host_encrypt = 1;
2646 priv->ieee80211->host_decrypt = 1;
2647 priv->ieee80211->sta_wake_up = rtl8180_hw_wakeup;
2648 priv->ieee80211->ps_request_tx_ack = rtl8180_rq_tx_ack;
2649 priv->ieee80211->enter_sleep_state = rtl8180_hw_sleep;
2650 priv->ieee80211->ps_is_queue_empty = rtl8180_is_tx_queue_empty;
2652 priv->hw_wep = hwwep;
2655 priv->retry_rts = DEFAULT_RETRY_RTS;
2656 priv->retry_data = DEFAULT_RETRY_DATA;
2657 priv->RFChangeInProgress = false;
2658 priv->SetRFPowerStateInProgress = false;
2659 priv->RFProgType = 0;
2660 priv->bInHctTest = false;
2661 priv->bInactivePs = true;//false;
2662 priv->ieee80211->bInactivePs = priv->bInactivePs;
2663 priv->bSwRfProcessing = false;
2664 priv->eRFPowerState = eRfOff;
2665 priv->RfOffReason = 0;
2666 priv->LedStrategy = SW_LED_MODE0;
2667 priv->TxPollingTimes = 0;//lzm add 080826
2668 priv->bLeisurePs = true;
2669 priv->dot11PowerSaveMode = eActive;
2670 priv->AdMinCheckPeriod = 5;
2671 priv->AdMaxCheckPeriod = 10;
2672 priv->AdMaxRxSsThreshold = 30;//60->30
2673 priv->AdRxSsThreshold = 20;//50->20
2674 priv->AdCheckPeriod = priv->AdMinCheckPeriod;
2675 priv->AdTickCount = 0;
2676 priv->AdRxSignalStrength = -1;
2677 priv->RegSwAntennaDiversityMechanism = 0;
2678 priv->RegDefaultAntenna = 0;
2679 priv->SignalStrength = 0;
2680 priv->AdRxOkCnt = 0;
2681 priv->CurrAntennaIndex = 0;
2682 priv->AdRxSsBeforeSwitched = 0;
2683 init_timer(&priv->SwAntennaDiversityTimer);
2684 priv->SwAntennaDiversityTimer.data = (unsigned long)dev;
2685 priv->SwAntennaDiversityTimer.function = (void *)SwAntennaDiversityTimerCallback;
2686 priv->bDigMechanism = 1;
2687 priv->InitialGain = 6;
2688 priv->bXtalCalibration = false;
2689 priv->XtalCal_Xin = 0;
2690 priv->XtalCal_Xout = 0;
2691 priv->bTxPowerTrack = false;
2692 priv->ThermalMeter = 0;
2693 priv->FalseAlarmRegValue = 0;
2694 priv->RegDigOfdmFaUpTh = 0xc; // Upper threhold of OFDM false alarm, which is used in DIG.
2695 priv->DIG_NumberFallbackVote = 0;
2696 priv->DIG_NumberUpgradeVote = 0;
2697 priv->LastSignalStrengthInPercent = 0;
2698 priv->Stats_SignalStrength = 0;
2699 priv->LastRxPktAntenna = 0;
2700 priv->SignalQuality = 0; // in 0-100 index.
2701 priv->Stats_SignalQuality = 0;
2702 priv->RecvSignalPower = 0; // in dBm.
2703 priv->Stats_RecvSignalPower = 0;
2704 priv->AdMainAntennaRxOkCnt = 0;
2705 priv->AdAuxAntennaRxOkCnt = 0;
2706 priv->bHWAdSwitched = false;
2707 priv->bRegHighPowerMechanism = true;
2708 priv->RegHiPwrUpperTh = 77;
2709 priv->RegHiPwrLowerTh = 75;
2710 priv->RegRSSIHiPwrUpperTh = 70;
2711 priv->RegRSSIHiPwrLowerTh = 20;
2712 priv->bCurCCKPkt = false;
2713 priv->UndecoratedSmoothedSS = -1;
2714 priv->bToUpdateTxPwr = false;
2715 priv->CurCCKRSSI = 0;
2718 priv->NumTxOkTotal = 0;
2719 priv->NumTxUnicast = 0;
2720 priv->keepAliveLevel = DEFAULT_KEEP_ALIVE_LEVEL;
2721 priv->PowerProfile = POWER_PROFILE_AC;
2722 priv->CurrRetryCnt = 0;
2723 priv->LastRetryCnt = 0;
2724 priv->LastTxokCnt = 0;
2725 priv->LastRxokCnt = 0;
2726 priv->LastRetryRate = 0;
2727 priv->bTryuping = 0;
2728 priv->CurrTxRate = 0;
2729 priv->CurrRetryRate = 0;
2730 priv->TryupingCount = 0;
2731 priv->TryupingCountNoData = 0;
2732 priv->TryDownCountLowData = 0;
2733 priv->LastTxOKBytes = 0;
2734 priv->LastFailTxRate = 0;
2735 priv->LastFailTxRateSS = 0;
2736 priv->FailTxRateCount = 0;
2737 priv->LastTxThroughput = 0;
2738 priv->NumTxOkBytesTotal = 0;
2739 priv->ForcedDataRate = 0;
2740 priv->RegBModeGainStage = 1;
2742 priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
2743 spin_lock_init(&priv->irq_lock);
2744 spin_lock_init(&priv->irq_th_lock);
2745 spin_lock_init(&priv->tx_lock);
2746 spin_lock_init(&priv->ps_lock);
2747 spin_lock_init(&priv->rf_ps_lock);
2748 sema_init(&priv->wx_sem, 1);
2749 sema_init(&priv->rf_state, 1);
2750 INIT_WORK(&priv->reset_wq, (void *)rtl8180_restart_wq);
2751 INIT_WORK(&priv->tx_irq_wq, (void *)rtl8180_tx_irq_wq);
2752 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,
2753 (void *)rtl8180_hw_wakeup_wq);
2754 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,
2755 (void *)rtl8180_hw_sleep_wq);
2756 INIT_WORK(&priv->ieee80211->wmm_param_update_wq,
2757 (void *)rtl8180_wmm_param_update);
2758 INIT_DELAYED_WORK(&priv->ieee80211->rate_adapter_wq,
2759 (void *)rtl8180_rate_adapter);
2760 INIT_DELAYED_WORK(&priv->ieee80211->hw_dig_wq,
2761 (void *)rtl8180_hw_dig_wq);
2762 INIT_DELAYED_WORK(&priv->ieee80211->tx_pw_wq,
2763 (void *)rtl8180_tx_pw_wq);
2764 INIT_DELAYED_WORK(&priv->ieee80211->GPIOChangeRFWorkItem,
2765 (void *) GPIOChangeRFWorkItemCallBack);
2766 tasklet_init(&priv->irq_rx_tasklet,
2767 (void(*)(unsigned long)) rtl8180_irq_rx_tasklet,
2768 (unsigned long)priv);
2770 init_timer(&priv->watch_dog_timer);
2771 priv->watch_dog_timer.data = (unsigned long)dev;
2772 priv->watch_dog_timer.function = watch_dog_adaptive;
2774 init_timer(&priv->rateadapter_timer);
2775 priv->rateadapter_timer.data = (unsigned long)dev;
2776 priv->rateadapter_timer.function = timer_rate_adaptive;
2777 priv->RateAdaptivePeriod = RATE_ADAPTIVE_TIMER_PERIOD;
2778 priv->bEnhanceTxPwr = false;
2780 priv->ieee80211->softmac_hard_start_xmit = rtl8180_hard_start_xmit;
2781 priv->ieee80211->set_chan = rtl8180_set_chan;
2782 priv->ieee80211->link_change = rtl8180_link_change;
2783 priv->ieee80211->softmac_data_hard_start_xmit = rtl8180_hard_data_xmit;
2784 priv->ieee80211->data_hard_stop = rtl8180_data_hard_stop;
2785 priv->ieee80211->data_hard_resume = rtl8180_data_hard_resume;
2787 priv->ieee80211->init_wmmparam_flag = 0;
2789 priv->ieee80211->start_send_beacons = rtl8180_start_tx_beacon;
2790 priv->ieee80211->stop_send_beacons = rtl8180_beacon_tx_disable;
2791 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2793 priv->MWIEnable = 0;
2795 priv->ShortRetryLimit = 7;
2796 priv->LongRetryLimit = 7;
2797 priv->EarlyRxThreshold = 7;
2799 priv->CSMethod = (0x01 << 29);
2801 priv->TransmitConfig = TCR_DurProcMode_OFFSET |
2802 (7<<TCR_MXDMA_OFFSET) |
2803 (priv->ShortRetryLimit<<TCR_SRL_OFFSET) |
2804 (priv->LongRetryLimit<<TCR_LRL_OFFSET) |
2807 priv->ReceiveConfig = RCR_AMF | RCR_ADF | RCR_ACF |
2808 RCR_AB | RCR_AM | RCR_APM |
2809 (7<<RCR_MXDMA_OFFSET) |
2810 (priv->EarlyRxThreshold<<RCR_FIFO_OFFSET) |
2811 (priv->EarlyRxThreshold == 7 ?
2812 RCR_ONLYERLPKT : 0);
2814 priv->IntrMask = IMR_TMGDOK | IMR_TBDER | IMR_THPDER |
2815 IMR_THPDER | IMR_THPDOK |
2816 IMR_TVODER | IMR_TVODOK |
2817 IMR_TVIDER | IMR_TVIDOK |
2818 IMR_TBEDER | IMR_TBEDOK |
2819 IMR_TBKDER | IMR_TBKDOK |
2824 priv->InitialGain = 6;
2826 DMESG("MAC controller is a RTL8187SE b/g");
2829 priv->ieee80211->modulation |= IEEE80211_OFDM_MODULATION;
2830 priv->ieee80211->short_slot = 1;
2833 priv->enable_gpio0 = 0;
2835 eeprom_93cx6_read(&eeprom, EEPROM_SW_REVD_OFFSET, &eeprom_val);
2836 usValue = eeprom_val;
2837 DMESG("usValue is 0x%x\n",usValue);
2838 //3Read AntennaDiversity
2840 // SW Antenna Diversity.
2841 if ((usValue & EEPROM_SW_AD_MASK) != EEPROM_SW_AD_ENABLE)
2842 priv->EEPROMSwAntennaDiversity = false;
2844 priv->EEPROMSwAntennaDiversity = true;
2846 // Default Antenna to use.
2847 if ((usValue & EEPROM_DEF_ANT_MASK) != EEPROM_DEF_ANT_1)
2848 priv->EEPROMDefaultAntenna1 = false;
2850 priv->EEPROMDefaultAntenna1 = true;
2852 if( priv->RegSwAntennaDiversityMechanism == 0 ) // Auto
2853 /* 0: default from EEPROM. */
2854 priv->bSwAntennaDiverity = priv->EEPROMSwAntennaDiversity;
2856 /* 1:disable antenna diversity, 2: enable antenna diversity. */
2857 priv->bSwAntennaDiverity = ((priv->RegSwAntennaDiversityMechanism == 1)? false : true);
2859 if (priv->RegDefaultAntenna == 0)
2860 /* 0: default from EEPROM. */
2861 priv->bDefaultAntenna1 = priv->EEPROMDefaultAntenna1;
2863 /* 1: main, 2: aux. */
2864 priv->bDefaultAntenna1 = ((priv->RegDefaultAntenna== 2) ? true : false);
2866 /* rtl8185 can calc plcp len in HW.*/
2867 priv->hw_plcp_len = 1;
2869 priv->plcp_preamble_mode = 2;
2870 /*the eeprom type is stored in RCR register bit #6 */
2871 if (RCR_9356SEL & read_nic_dword(dev, RCR))
2872 priv->epromtype=EPROM_93c56;
2874 priv->epromtype=EPROM_93c46;
2876 eeprom_93cx6_multiread(&eeprom, 0x7, (__le16 *)
2879 for(i=1,j=0; i<14; i+=2,j++){
2880 eeprom_93cx6_read(&eeprom, EPROM_TXPW_CH1_2 + j, &word);
2881 priv->chtxpwr[i]=word & 0xff;
2882 priv->chtxpwr[i+1]=(word & 0xff00)>>8;
2884 for (i = 1, j = 0; i < 14; i += 2, j++) {
2885 eeprom_93cx6_read(&eeprom, EPROM_TXPW_OFDM_CH1_2 + j, &word);
2886 priv->chtxpwr_ofdm[i] = word & 0xff;
2887 priv->chtxpwr_ofdm[i+1] = (word & 0xff00) >> 8;
2890 /* 3Read crystal calibtration and thermal meter indication on 87SE. */
2891 eeprom_93cx6_read(&eeprom, EEPROM_RSV>>1, &tmpu16);
2893 /* Crystal calibration for Xin and Xout resp. */
2894 priv->XtalCal_Xout = tmpu16 & EEPROM_XTAL_CAL_XOUT_MASK;
2895 priv->XtalCal_Xin = (tmpu16 & EEPROM_XTAL_CAL_XIN_MASK) >> 4;
2896 if ((tmpu16 & EEPROM_XTAL_CAL_ENABLE) >> 12)
2897 priv->bXtalCalibration = true;
2899 /* Thermal meter reference indication. */
2900 priv->ThermalMeter = (u8)((tmpu16 & EEPROM_THERMAL_METER_MASK) >> 8);
2901 if ((tmpu16 & EEPROM_THERMAL_METER_ENABLE) >> 13)
2902 priv->bTxPowerTrack = true;
2904 eeprom_93cx6_read(&eeprom, EPROM_TXPW_BASE, &word);
2905 priv->cck_txpwr_base = word & 0xf;
2906 priv->ofdm_txpwr_base = (word>>4) & 0xf;
2908 eeprom_93cx6_read(&eeprom, EPROM_VERSION, &version);
2909 DMESG("EEPROM version %x",version);
2910 priv->rcr_csense = 3;
2912 eeprom_93cx6_read(&eeprom, ENERGY_TRESHOLD, &eeprom_val);
2913 priv->cs_treshold = (eeprom_val & 0xff00) >> 8;
2915 eeprom_93cx6_read(&eeprom, RFCHIPID, &eeprom_val);
2916 priv->rf_sleep = rtl8225z4_rf_sleep;
2917 priv->rf_wakeup = rtl8225z4_rf_wakeup;
2918 DMESGW("**PLEASE** REPORT SUCCESSFUL/UNSUCCESSFUL TO Realtek!");
2920 priv->rf_close = rtl8225z2_rf_close;
2921 priv->rf_init = rtl8225z2_rf_init;
2922 priv->rf_set_chan = rtl8225z2_rf_set_chan;
2923 priv->rf_set_sens = NULL;
2925 if (0!=alloc_rx_desc_ring(dev, priv->rxbuffersize, priv->rxringcount))
2928 if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2929 TX_MANAGEPRIORITY_RING_ADDR))
2932 if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2933 TX_BKPRIORITY_RING_ADDR))
2936 if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2937 TX_BEPRIORITY_RING_ADDR))
2940 if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2941 TX_VIPRIORITY_RING_ADDR))
2944 if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2945 TX_VOPRIORITY_RING_ADDR))
2948 if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2949 TX_HIGHPRIORITY_RING_ADDR))
2952 if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txbeaconcount,
2953 TX_BEACON_RING_ADDR))
2956 if(request_irq(dev->irq, (void *)rtl8180_interrupt, IRQF_SHARED, dev->name, dev)){
2957 DMESGE("Error allocating IRQ %d",dev->irq);
2961 DMESG("IRQ %d",dev->irq);
2967 void rtl8180_no_hw_wep(struct net_device *dev)
2971 void rtl8180_set_hw_wep(struct net_device *dev)
2973 struct r8180_priv *priv = ieee80211_priv(dev);
2978 pgreg=read_nic_byte(dev, PGSELECT);
2979 write_nic_byte(dev, PGSELECT, pgreg &~ (1<<PGSELECT_PG_SHIFT));
2981 key0_word4 = read_nic_dword(dev, KEY0+4+4+4);
2982 key0_word4 &= ~ 0xff;
2983 key0_word4 |= priv->key0[3]& 0xff;
2984 write_nic_dword(dev,KEY0,(priv->key0[0]));
2985 write_nic_dword(dev,KEY0+4,(priv->key0[1]));
2986 write_nic_dword(dev,KEY0+4+4,(priv->key0[2]));
2987 write_nic_dword(dev,KEY0+4+4+4,(key0_word4));
2989 security = read_nic_byte(dev,SECURITY);
2990 security |= (1<<SECURITY_WEP_TX_ENABLE_SHIFT);
2991 security |= (1<<SECURITY_WEP_RX_ENABLE_SHIFT);
2992 security &= ~ SECURITY_ENCRYP_MASK;
2993 security |= (SECURITY_ENCRYP_104<<SECURITY_ENCRYP_SHIFT);
2995 write_nic_byte(dev, SECURITY, security);
2997 DMESG("key %x %x %x %x",read_nic_dword(dev,KEY0+4+4+4),
2998 read_nic_dword(dev,KEY0+4+4),read_nic_dword(dev,KEY0+4),
2999 read_nic_dword(dev,KEY0));
3003 void rtl8185_rf_pins_enable(struct net_device *dev)
3006 // tmp = read_nic_word(dev, RFPinsEnable);
3007 write_nic_word(dev, RFPinsEnable, 0x1fff);// | tmp);
3010 void rtl8185_set_anaparam2(struct net_device *dev, u32 a)
3014 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3016 conf3 = read_nic_byte(dev, CONFIG3);
3017 write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
3018 write_nic_dword(dev, ANAPARAM2, a);
3020 conf3 = read_nic_byte(dev, CONFIG3);
3021 write_nic_byte(dev, CONFIG3, conf3 &~(1<<CONFIG3_ANAPARAM_W_SHIFT));
3022 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3025 void rtl8180_set_anaparam(struct net_device *dev, u32 a)
3029 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3031 conf3 = read_nic_byte(dev, CONFIG3);
3032 write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
3033 write_nic_dword(dev, ANAPARAM, a);
3035 conf3 = read_nic_byte(dev, CONFIG3);
3036 write_nic_byte(dev, CONFIG3, conf3 &~(1<<CONFIG3_ANAPARAM_W_SHIFT));
3037 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3040 void rtl8185_tx_antenna(struct net_device *dev, u8 ant)
3042 write_nic_byte(dev, TX_ANTENNA, ant);
3043 force_pci_posting(dev);
3047 void rtl8185_write_phy(struct net_device *dev, u8 adr, u32 data)
3053 phyw= ((data<<8) | adr);
3055 // Note that, we must write 0xff7c after 0x7d-0x7f to write BB register.
3056 write_nic_byte(dev, 0x7f, ((phyw & 0xff000000) >> 24));
3057 write_nic_byte(dev, 0x7e, ((phyw & 0x00ff0000) >> 16));
3058 write_nic_byte(dev, 0x7d, ((phyw & 0x0000ff00) >> 8));
3059 write_nic_byte(dev, 0x7c, ((phyw & 0x000000ff) ));
3061 /* this is ok to fail when we write AGC table. check for AGC table might be
3062 * done by masking with 0x7f instead of 0xff
3064 //if(phyr != (data&0xff)) DMESGW("Phy write timeout %x %x %x", phyr, data,adr);
3067 inline void write_phy_ofdm (struct net_device *dev, u8 adr, u32 data)
3070 rtl8185_write_phy(dev, adr, data);
3073 void write_phy_cck (struct net_device *dev, u8 adr, u32 data)
3076 rtl8185_write_phy(dev, adr, data | 0x10000);
3079 void rtl8185_set_rate(struct net_device *dev)
3083 int basic_rate,min_rr_rate,max_rr_rate;
3085 basic_rate = ieeerate2rtlrate(240);
3086 min_rr_rate = ieeerate2rtlrate(60);
3087 max_rr_rate = ieeerate2rtlrate(240);
3089 write_nic_byte(dev, RESP_RATE,
3090 max_rr_rate<<MAX_RESP_RATE_SHIFT| min_rr_rate<<MIN_RESP_RATE_SHIFT);
3092 word = read_nic_word(dev, BRSR);
3093 word &= ~BRSR_MBR_8185;
3095 for(i=0;i<=basic_rate;i++)
3098 write_nic_word(dev, BRSR, word);
3101 void rtl8180_adapter_start(struct net_device *dev)
3103 struct r8180_priv *priv = ieee80211_priv(dev);
3105 rtl8180_rtx_disable(dev);
3108 /* enable beacon timeout, beacon TX ok and err
3109 * LP tx ok and err, HP TX ok and err, NP TX ok and err,
3110 * RX ok and ERR, and GP timer */
3111 priv->irq_mask = 0x6fcf;
3113 priv->dma_poll_mask = 0;
3115 rtl8180_beacon_tx_disable(dev);
3117 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3118 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3119 write_nic_word(dev, MAC4, ((u32*)dev->dev_addr)[1] & 0xffff );
3120 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3122 rtl8180_update_msr(dev);
3124 /* These might be unnecessary since we do in rx_enable / tx_enable */
3128 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3131 The following is very strange. seems to be that 1 means test mode,
3132 but we need to acknolwledges the nic when a packet is ready
3133 although we set it to 0
3137 CONFIG2, read_nic_byte(dev,CONFIG2) &~\
3138 (1<<CONFIG2_DMA_POLLING_MODE_SHIFT));
3139 //^the nic isn't in test mode
3141 CONFIG2, read_nic_byte(dev,CONFIG2)|(1<<4));
3143 rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
3145 write_nic_dword(dev,INT_TIMEOUT,0);
3147 write_nic_byte(dev, WPA_CONFIG, 0);
3149 rtl8180_no_hw_wep(dev);
3151 rtl8185_set_rate(dev);
3152 write_nic_byte(dev, RATE_FALLBACK, 0x81);
3154 write_nic_byte(dev, GP_ENABLE, read_nic_byte(dev, GP_ENABLE) & ~(1<<6));
3156 /*FIXME cfg 3 ClkRun enable - isn't it ReadOnly ? */
3157 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3158 write_nic_byte(dev, CONFIG3, read_nic_byte(dev, CONFIG3)
3159 | (1 << CONFIG3_CLKRUN_SHIFT));
3160 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3164 if(priv->rf_set_sens != NULL)
3165 priv->rf_set_sens(dev,priv->sens);
3166 rtl8180_irq_enable(dev);
3168 netif_start_queue(dev);
3171 /* this configures registers for beacon tx and enables it via
3172 * rtl8180_beacon_tx_enable(). rtl8180_beacon_tx_disable() might
3173 * be used to stop beacon transmission
3175 void rtl8180_start_tx_beacon(struct net_device *dev)
3179 DMESG("Enabling beacon TX");
3180 rtl8180_prepare_beacon(dev);
3181 rtl8180_irq_disable(dev);
3182 rtl8180_beacon_tx_enable(dev);
3184 word = read_nic_word(dev, AtimWnd) &~ AtimWnd_AtimWnd;
3185 write_nic_word(dev, AtimWnd,word);// word |=
3187 word = read_nic_word(dev, BintrItv);
3188 word &= ~BintrItv_BintrItv;
3189 word |= 1000;/*priv->ieee80211->current_network.beacon_interval *
3190 ((priv->txbeaconcount > 1)?(priv->txbeaconcount-1):1);
3191 // FIXME: check if correct ^^ worked with 0x3e8;
3193 write_nic_word(dev, BintrItv, word);
3195 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3197 rtl8185b_irq_enable(dev);
3200 static struct net_device_stats *rtl8180_stats(struct net_device *dev)
3202 struct r8180_priv *priv = ieee80211_priv(dev);
3204 return &priv->ieee80211->stats;
3207 // Change current and default preamble mode.
3210 MgntActSet_802_11_PowerSaveMode(
3211 struct r8180_priv *priv,
3215 // Currently, we do not change power save mode on IBSS mode.
3216 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3219 priv->ieee80211->ps = rtPsMode;
3224 void LeisurePSEnter(struct r8180_priv *priv)
3226 if (priv->bLeisurePs) {
3227 if (priv->ieee80211->ps == IEEE80211_PS_DISABLED)
3228 MgntActSet_802_11_PowerSaveMode(priv, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST);//IEEE80211_PS_ENABLE
3232 void LeisurePSLeave(struct r8180_priv *priv)
3234 if (priv->bLeisurePs) {
3235 if (priv->ieee80211->ps != IEEE80211_PS_DISABLED)
3236 MgntActSet_802_11_PowerSaveMode(priv, IEEE80211_PS_DISABLED);
3240 void rtl8180_hw_wakeup_wq (struct work_struct *work)
3242 struct delayed_work *dwork = to_delayed_work(work);
3243 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
3244 struct net_device *dev = ieee->dev;
3246 rtl8180_hw_wakeup(dev);
3249 void rtl8180_hw_sleep_wq (struct work_struct *work)
3251 struct delayed_work *dwork = to_delayed_work(work);
3252 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
3253 struct net_device *dev = ieee->dev;
3255 rtl8180_hw_sleep_down(dev);
3258 static void MgntLinkKeepAlive(struct r8180_priv *priv )
3260 if (priv->keepAliveLevel == 0)
3263 if(priv->ieee80211->state == IEEE80211_LINKED)
3269 if ( (priv->keepAliveLevel== 2) ||
3270 (priv->link_detect.LastNumTxUnicast == priv->NumTxUnicast &&
3271 priv->link_detect.LastNumRxUnicast == priv->ieee80211->NumRxUnicast )
3274 priv->link_detect.IdleCount++;
3277 // Send a Keep-Alive packet packet to AP if we had been idle for a while.
3279 if(priv->link_detect.IdleCount >= ((KEEP_ALIVE_INTERVAL / CHECK_FOR_HANG_PERIOD)-1) )
3281 priv->link_detect.IdleCount = 0;
3282 ieee80211_sta_ps_send_null_frame(priv->ieee80211, false);
3287 priv->link_detect.IdleCount = 0;
3289 priv->link_detect.LastNumTxUnicast = priv->NumTxUnicast;
3290 priv->link_detect.LastNumRxUnicast = priv->ieee80211->NumRxUnicast;
3294 static u8 read_acadapter_file(char *filename);
3296 void rtl8180_watch_dog(struct net_device *dev)
3298 struct r8180_priv *priv = ieee80211_priv(dev);
3299 bool bEnterPS = false;
3300 bool bBusyTraffic = false;
3304 if(priv->ieee80211->actscanning == false){
3305 if((priv->ieee80211->iw_mode != IW_MODE_ADHOC) && (priv->ieee80211->state == IEEE80211_NOLINK) && (priv->ieee80211->beinretry == false) && (priv->eRFPowerState == eRfOn)){
3309 //YJ,add,080828,for link state check
3310 if((priv->ieee80211->state == IEEE80211_LINKED) && (priv->ieee80211->iw_mode == IW_MODE_INFRA)){
3311 SlotIndex = (priv->link_detect.SlotIndex++) % priv->link_detect.SlotNum;
3312 priv->link_detect.RxFrameNum[SlotIndex] = priv->ieee80211->NumRxDataInPeriod + priv->ieee80211->NumRxBcnInPeriod;
3313 for( i=0; i<priv->link_detect.SlotNum; i++ )
3314 TotalRxNum+= priv->link_detect.RxFrameNum[i];
3316 if(TotalRxNum == 0){
3317 priv->ieee80211->state = IEEE80211_ASSOCIATING;
3318 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
3322 //YJ,add,080828,for KeepAlive
3323 MgntLinkKeepAlive(priv);
3325 //YJ,add,080828,for LPS
3326 if (priv->PowerProfile == POWER_PROFILE_BATTERY)
3327 priv->bLeisurePs = true;
3328 else if (priv->PowerProfile == POWER_PROFILE_AC) {
3329 LeisurePSLeave(priv);
3330 priv->bLeisurePs= false;
3333 if(priv->ieee80211->state == IEEE80211_LINKED){
3334 priv->link_detect.NumRxOkInPeriod = priv->ieee80211->NumRxDataInPeriod;
3335 if( priv->link_detect.NumRxOkInPeriod> 666 ||
3336 priv->link_detect.NumTxOkInPeriod> 666 ) {
3337 bBusyTraffic = true;
3339 if(((priv->link_detect.NumRxOkInPeriod + priv->link_detect.NumTxOkInPeriod) > 8)
3340 || (priv->link_detect.NumRxOkInPeriod > 2)) {
3346 LeisurePSEnter(priv);
3348 LeisurePSLeave(priv);
3350 LeisurePSLeave(priv);
3351 priv->link_detect.bBusyTraffic = bBusyTraffic;
3352 priv->link_detect.NumRxOkInPeriod = 0;
3353 priv->link_detect.NumTxOkInPeriod = 0;
3354 priv->ieee80211->NumRxDataInPeriod = 0;
3355 priv->ieee80211->NumRxBcnInPeriod = 0;
3358 int _rtl8180_up(struct net_device *dev)
3360 struct r8180_priv *priv = ieee80211_priv(dev);
3364 DMESG("Bringing up iface");
3365 rtl8185b_adapter_start(dev);
3366 rtl8185b_rx_enable(dev);
3367 rtl8185b_tx_enable(dev);
3368 if(priv->bInactivePs){
3369 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3372 timer_rate_adaptive((unsigned long)dev);
3373 watch_dog_adaptive((unsigned long)dev);
3374 if(priv->bSwAntennaDiverity)
3375 SwAntennaDiversityTimerCallback(dev);
3376 ieee80211_softmac_start_protocol(priv->ieee80211);
3380 int rtl8180_open(struct net_device *dev)
3382 struct r8180_priv *priv = ieee80211_priv(dev);
3385 down(&priv->wx_sem);
3386 ret = rtl8180_up(dev);
3391 int rtl8180_up(struct net_device *dev)
3393 struct r8180_priv *priv = ieee80211_priv(dev);
3395 if (priv->up == 1) return -1;
3397 return _rtl8180_up(dev);
3400 int rtl8180_close(struct net_device *dev)
3402 struct r8180_priv *priv = ieee80211_priv(dev);
3405 down(&priv->wx_sem);
3406 ret = rtl8180_down(dev);
3412 int rtl8180_down(struct net_device *dev)
3414 struct r8180_priv *priv = ieee80211_priv(dev);
3421 ieee80211_softmac_stop_protocol(priv->ieee80211);
3423 if (!netif_queue_stopped(dev))
3424 netif_stop_queue(dev);
3425 rtl8180_rtx_disable(dev);
3426 rtl8180_irq_disable(dev);
3427 del_timer_sync(&priv->watch_dog_timer);
3428 del_timer_sync(&priv->rateadapter_timer);
3429 cancel_delayed_work(&priv->ieee80211->rate_adapter_wq);
3430 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
3431 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
3432 cancel_delayed_work(&priv->ieee80211->hw_dig_wq);
3433 cancel_delayed_work(&priv->ieee80211->tx_pw_wq);
3434 del_timer_sync(&priv->SwAntennaDiversityTimer);
3435 SetZebraRFPowerState8185(dev,eRfOff);
3436 memset(&(priv->ieee80211->current_network),0,sizeof(struct ieee80211_network));
3437 priv->ieee80211->state = IEEE80211_NOLINK;
3441 void rtl8180_restart_wq(struct work_struct *work)
3443 struct r8180_priv *priv = container_of(work, struct r8180_priv, reset_wq);
3444 struct net_device *dev = priv->dev;
3446 down(&priv->wx_sem);
3448 rtl8180_commit(dev);
3453 void rtl8180_restart(struct net_device *dev)
3455 struct r8180_priv *priv = ieee80211_priv(dev);
3457 schedule_work(&priv->reset_wq);
3460 void rtl8180_commit(struct net_device *dev)
3462 struct r8180_priv *priv = ieee80211_priv(dev);
3467 del_timer_sync(&priv->watch_dog_timer);
3468 del_timer_sync(&priv->rateadapter_timer);
3469 cancel_delayed_work(&priv->ieee80211->rate_adapter_wq);
3470 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
3471 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
3472 cancel_delayed_work(&priv->ieee80211->hw_dig_wq);
3473 cancel_delayed_work(&priv->ieee80211->tx_pw_wq);
3474 del_timer_sync(&priv->SwAntennaDiversityTimer);
3475 ieee80211_softmac_stop_protocol(priv->ieee80211);
3476 rtl8180_irq_disable(dev);
3477 rtl8180_rtx_disable(dev);
3481 static void r8180_set_multicast(struct net_device *dev)
3483 struct r8180_priv *priv = ieee80211_priv(dev);
3486 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
3488 if (promisc != priv->promisc)
3489 rtl8180_restart(dev);
3491 priv->promisc = promisc;
3494 int r8180_set_mac_adr(struct net_device *dev, void *mac)
3496 struct r8180_priv *priv = ieee80211_priv(dev);
3497 struct sockaddr *addr = mac;
3499 down(&priv->wx_sem);
3501 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
3503 if(priv->ieee80211->iw_mode == IW_MODE_MASTER)
3504 memcpy(priv->ieee80211->current_network.bssid, dev->dev_addr, ETH_ALEN);
3516 /* based on ipw2200 driver */
3517 int rtl8180_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3519 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3520 struct iwreq *wrq = (struct iwreq *) rq;
3524 case RTL_IOCTL_WPA_SUPPLICANT:
3525 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
3534 static const struct net_device_ops rtl8180_netdev_ops = {
3535 .ndo_open = rtl8180_open,
3536 .ndo_stop = rtl8180_close,
3537 .ndo_get_stats = rtl8180_stats,
3538 .ndo_tx_timeout = rtl8180_restart,
3539 .ndo_do_ioctl = rtl8180_ioctl,
3540 .ndo_set_multicast_list = r8180_set_multicast,
3541 .ndo_set_mac_address = r8180_set_mac_adr,
3542 .ndo_validate_addr = eth_validate_addr,
3543 .ndo_change_mtu = eth_change_mtu,
3544 .ndo_start_xmit = ieee80211_rtl_xmit,
3547 static int __devinit rtl8180_pci_probe(struct pci_dev *pdev,
3548 const struct pci_device_id *id)
3550 unsigned long ioaddr = 0;
3551 struct net_device *dev = NULL;
3552 struct r8180_priv *priv= NULL;
3555 unsigned long pmem_start, pmem_len, pmem_flags;
3557 DMESG("Configuring chip resources");
3559 if( pci_enable_device (pdev) ){
3560 DMESG("Failed to enable PCI device");
3564 pci_set_master(pdev);
3565 pci_set_dma_mask(pdev, 0xffffff00ULL);
3566 pci_set_consistent_dma_mask(pdev,0xffffff00ULL);
3567 dev = alloc_ieee80211(sizeof(struct r8180_priv));
3570 priv = ieee80211_priv(dev);
3571 priv->ieee80211 = netdev_priv(dev);
3573 pci_set_drvdata(pdev, dev);
3574 SET_NETDEV_DEV(dev, &pdev->dev);
3576 priv = ieee80211_priv(dev);
3579 pmem_start = pci_resource_start(pdev, 1);
3580 pmem_len = pci_resource_len(pdev, 1);
3581 pmem_flags = pci_resource_flags (pdev, 1);
3583 if (!(pmem_flags & IORESOURCE_MEM)) {
3584 DMESG("region #1 not a MMIO resource, aborting");
3588 if( ! request_mem_region(pmem_start, pmem_len, RTL8180_MODULE_NAME)) {
3589 DMESG("request_mem_region failed!");
3593 ioaddr = (unsigned long)ioremap_nocache( pmem_start, pmem_len);
3594 if( ioaddr == (unsigned long)NULL ){
3595 DMESG("ioremap failed!");
3599 dev->mem_start = ioaddr; // shared mem start
3600 dev->mem_end = ioaddr + pci_resource_len(pdev, 0); // shared mem end
3602 pci_read_config_byte(pdev, 0x05, &unit);
3603 pci_write_config_byte(pdev, 0x05, unit & (~0x04));
3605 dev->irq = pdev->irq;
3608 dev->netdev_ops = &rtl8180_netdev_ops;
3609 dev->wireless_handlers = &r8180_wx_handlers_def;
3611 dev->type=ARPHRD_ETHER;
3612 dev->watchdog_timeo = HZ*3;
3614 if (dev_alloc_name(dev, ifname) < 0){
3615 DMESG("Oops: devname already taken! Trying wlan%%d...\n");
3617 dev_alloc_name(dev, ifname);
3620 if(rtl8180_init(dev)!=0){
3621 DMESG("Initialization failed");
3625 netif_carrier_off(dev);
3627 register_netdev(dev);
3629 rtl8180_proc_init_one(dev);
3631 DMESG("Driver probe completed\n");
3634 if( dev->mem_start != (unsigned long)NULL ){
3635 iounmap( (void *)dev->mem_start );
3636 release_mem_region( pci_resource_start(pdev, 1),
3637 pci_resource_len(pdev, 1) );
3642 free_irq(dev->irq, dev);
3645 free_ieee80211(dev);
3648 pci_disable_device(pdev);
3650 DMESG("wlan driver load failed\n");
3651 pci_set_drvdata(pdev, NULL);
3655 static void __devexit rtl8180_pci_remove(struct pci_dev *pdev)
3657 struct r8180_priv *priv;
3658 struct net_device *dev = pci_get_drvdata(pdev);
3661 unregister_netdev(dev);
3663 priv = ieee80211_priv(dev);
3665 rtl8180_proc_remove_one(dev);
3667 priv->rf_close(dev);
3672 DMESG("Freeing irq %d",dev->irq);
3673 free_irq(dev->irq, dev);
3677 free_rx_desc_ring(dev);
3678 free_tx_desc_rings(dev);
3680 if( dev->mem_start != (unsigned long)NULL ){
3681 iounmap( (void *)dev->mem_start );
3682 release_mem_region( pci_resource_start(pdev, 1),
3683 pci_resource_len(pdev, 1) );
3686 free_ieee80211(dev);
3688 pci_disable_device(pdev);
3690 DMESG("wlan driver removed\n");
3693 /* fun with the built-in ieee80211 stack... */
3694 extern int ieee80211_crypto_init(void);
3695 extern void ieee80211_crypto_deinit(void);
3696 extern int ieee80211_crypto_tkip_init(void);
3697 extern void ieee80211_crypto_tkip_exit(void);
3698 extern int ieee80211_crypto_ccmp_init(void);
3699 extern void ieee80211_crypto_ccmp_exit(void);
3700 extern int ieee80211_crypto_wep_init(void);
3701 extern void ieee80211_crypto_wep_exit(void);
3703 static int __init rtl8180_pci_module_init(void)
3707 ret = ieee80211_crypto_init();
3709 printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
3712 ret = ieee80211_crypto_tkip_init();
3714 printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n", ret);
3717 ret = ieee80211_crypto_ccmp_init();
3719 printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n", ret);
3722 ret = ieee80211_crypto_wep_init();
3724 printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
3728 printk(KERN_INFO "\nLinux kernel driver for RTL8180 / RTL8185 based WLAN cards\n");
3729 printk(KERN_INFO "Copyright (c) 2004-2005, Andrea Merello\n");
3730 DMESG("Initializing module");
3731 DMESG("Wireless extensions version %d", WIRELESS_EXT);
3732 rtl8180_proc_module_init();
3734 if (pci_register_driver(&rtl8180_pci_driver)) {
3735 DMESG("No device found");
3741 static void __exit rtl8180_pci_module_exit(void)
3743 pci_unregister_driver (&rtl8180_pci_driver);
3744 rtl8180_proc_module_remove();
3745 ieee80211_crypto_tkip_exit();
3746 ieee80211_crypto_ccmp_exit();
3747 ieee80211_crypto_wep_exit();
3748 ieee80211_crypto_deinit();
3752 void rtl8180_try_wake_queue(struct net_device *dev, int pri)
3754 unsigned long flags;
3756 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3758 spin_lock_irqsave(&priv->tx_lock,flags);
3759 enough_desc = check_nic_enought_desc(dev,pri);
3760 spin_unlock_irqrestore(&priv->tx_lock,flags);
3763 ieee80211_rtl_wake_queue(priv->ieee80211);
3766 void rtl8180_tx_isr(struct net_device *dev, int pri,short error)
3768 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3769 u32 *tail; //tail virtual addr
3770 u32 *head; //head virtual addr
3771 u32 *begin;//start of ring virtual addr
3772 u32 *nicv; //nic pointer virtual addr
3773 u32 nic; //nic pointer physical addr
3774 u32 nicbegin;// start of ring physical addr
3776 /* physical addr are ok on 32 bits since we set DMA mask*/
3780 if (error) priv->stats.txretry++; //tony 20060601
3781 spin_lock_irqsave(&priv->tx_lock,flag);
3783 case MANAGE_PRIORITY:
3784 tail = priv->txmapringtail;
3785 begin = priv->txmapring;
3786 head = priv->txmapringhead;
3787 nic = read_nic_dword(dev,TX_MANAGEPRIORITY_RING_ADDR);
3788 nicbegin = priv->txmapringdma;
3791 tail = priv->txbkpringtail;
3792 begin = priv->txbkpring;
3793 head = priv->txbkpringhead;
3794 nic = read_nic_dword(dev,TX_BKPRIORITY_RING_ADDR);
3795 nicbegin = priv->txbkpringdma;
3798 tail = priv->txbepringtail;
3799 begin = priv->txbepring;
3800 head = priv->txbepringhead;
3801 nic = read_nic_dword(dev,TX_BEPRIORITY_RING_ADDR);
3802 nicbegin = priv->txbepringdma;
3805 tail = priv->txvipringtail;
3806 begin = priv->txvipring;
3807 head = priv->txvipringhead;
3808 nic = read_nic_dword(dev,TX_VIPRIORITY_RING_ADDR);
3809 nicbegin = priv->txvipringdma;
3812 tail = priv->txvopringtail;
3813 begin = priv->txvopring;
3814 head = priv->txvopringhead;
3815 nic = read_nic_dword(dev,TX_VOPRIORITY_RING_ADDR);
3816 nicbegin = priv->txvopringdma;
3819 tail = priv->txhpringtail;
3820 begin = priv->txhpring;
3821 head = priv->txhpringhead;
3822 nic = read_nic_dword(dev,TX_HIGHPRIORITY_RING_ADDR);
3823 nicbegin = priv->txhpringdma;
3827 spin_unlock_irqrestore(&priv->tx_lock,flag);
3831 nicv = (u32*) ((nic - nicbegin) + (u8*)begin);
3832 if((head <= tail && (nicv > tail || nicv < head)) ||
3833 (head > tail && (nicv > tail && nicv < head))){
3834 DMESGW("nic has lost pointer");
3835 spin_unlock_irqrestore(&priv->tx_lock,flag);
3836 rtl8180_restart(dev);
3840 /* we check all the descriptors between the head and the nic,
3841 * but not the currently pointed by the nic (the next to be txed)
3842 * and the previous of the pointed (might be in process ??)
3844 offs = (nic - nicbegin);
3846 hd = (head - begin) /8;
3851 j = offs + (priv->txringcount -1 -hd);
3858 if((*head) & (1<<31))
3860 if(((*head)&(0x10000000)) != 0){
3861 priv->CurrRetryCnt += (u16)((*head) & (0x000000ff));
3863 priv->NumTxOkTotal++;
3867 priv->NumTxOkBytesTotal += (*(head+3)) & (0x00000fff);
3869 *head = *head &~ (1<<31);
3871 if((head - begin)/8 == priv->txringcount-1)
3877 /* the head has been moved to the last certainly TXed
3878 * (or at least processed by the nic) packet.
3879 * The driver take forcefully owning of all these packets
3880 * If the packet previous of the nic pointer has been
3881 * processed this doesn't matter: it will be checked
3882 * here at the next round. Anyway if no more packet are
3883 * TXed no memory leak occour at all.
3887 case MANAGE_PRIORITY:
3888 priv->txmapringhead = head;
3890 if(priv->ack_tx_to_ieee){
3891 if(rtl8180_is_tx_queue_empty(dev)){
3892 priv->ack_tx_to_ieee = 0;
3893 ieee80211_ps_tx_ack(priv->ieee80211,!error);
3898 priv->txbkpringhead = head;
3901 priv->txbepringhead = head;
3904 priv->txvipringhead = head;
3907 priv->txvopringhead = head;
3910 priv->txhpringhead = head;
3914 spin_unlock_irqrestore(&priv->tx_lock,flag);
3917 void rtl8180_tx_irq_wq(struct work_struct *work)
3919 struct delayed_work *dwork = to_delayed_work(work);
3920 struct ieee80211_device * ieee = (struct ieee80211_device*)
3921 container_of(dwork, struct ieee80211_device, watch_dog_wq);
3922 struct net_device *dev = ieee->dev;
3924 rtl8180_tx_isr(dev,MANAGE_PRIORITY,0);
3926 irqreturn_t rtl8180_interrupt(int irq, void *netdev, struct pt_regs *regs)
3928 struct net_device *dev = (struct net_device *) netdev;
3929 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3930 unsigned long flags;
3933 /* We should return IRQ_NONE, but for now let me keep this */
3934 if(priv->irq_enabled == 0) return IRQ_HANDLED;
3936 spin_lock_irqsave(&priv->irq_th_lock,flags);
3939 inta = read_nic_dword(dev, ISR);// & priv->IntrMask;
3940 write_nic_dword(dev,ISR,inta); // reset int situation
3942 priv->stats.shints++;
3945 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
3948 most probably we can safely return IRQ_NONE,
3949 but for now is better to avoid problems
3953 if (inta == 0xffff) {
3955 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3961 if(!netif_running(dev)) {
3962 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
3966 if (inta & ISR_TimeOut)
3967 write_nic_dword(dev, TimerInt, 0);
3969 if (inta & ISR_TBDOK)
3970 priv->stats.txbeacon++;
3972 if (inta & ISR_TBDER)
3973 priv->stats.txbeaconerr++;
3975 if (inta & IMR_TMGDOK)
3976 rtl8180_tx_isr(dev,MANAGE_PRIORITY,0);
3978 if(inta & ISR_THPDER){
3979 priv->stats.txhperr++;
3980 rtl8180_tx_isr(dev,HI_PRIORITY,1);
3981 priv->ieee80211->stats.tx_errors++;
3984 if(inta & ISR_THPDOK){ //High priority tx ok
3985 priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
3986 priv->stats.txhpokint++;
3987 rtl8180_tx_isr(dev,HI_PRIORITY,0);
3990 if(inta & ISR_RER) {
3991 priv->stats.rxerr++;
3993 if(inta & ISR_TBKDER){ //corresponding to BK_PRIORITY
3994 priv->stats.txbkperr++;
3995 priv->ieee80211->stats.tx_errors++;
3996 rtl8180_tx_isr(dev,BK_PRIORITY,1);
3997 rtl8180_try_wake_queue(dev, BE_PRIORITY);
4000 if(inta & ISR_TBEDER){ //corresponding to BE_PRIORITY
4001 priv->stats.txbeperr++;
4002 priv->ieee80211->stats.tx_errors++;
4003 rtl8180_tx_isr(dev,BE_PRIORITY,1);
4004 rtl8180_try_wake_queue(dev, BE_PRIORITY);
4006 if(inta & ISR_TNPDER){ //corresponding to VO_PRIORITY
4007 priv->stats.txnperr++;
4008 priv->ieee80211->stats.tx_errors++;
4009 rtl8180_tx_isr(dev,NORM_PRIORITY,1);
4010 rtl8180_try_wake_queue(dev, NORM_PRIORITY);
4013 if(inta & ISR_TLPDER){ //corresponding to VI_PRIORITY
4014 priv->stats.txlperr++;
4015 priv->ieee80211->stats.tx_errors++;
4016 rtl8180_tx_isr(dev,LOW_PRIORITY,1);
4017 rtl8180_try_wake_queue(dev, LOW_PRIORITY);
4021 priv->stats.rxint++;
4022 tasklet_schedule(&priv->irq_rx_tasklet);
4025 if(inta & ISR_RQoSOK ){
4026 priv->stats.rxint++;
4027 tasklet_schedule(&priv->irq_rx_tasklet);
4029 if(inta & ISR_BcnInt) {
4030 rtl8180_prepare_beacon(dev);
4034 DMESGW("No RX descriptor available");
4035 priv->stats.rxrdu++;
4036 tasklet_schedule(&priv->irq_rx_tasklet);
4039 if(inta & ISR_RXFOVW){
4040 priv->stats.rxoverflow++;
4041 tasklet_schedule(&priv->irq_rx_tasklet);
4044 if (inta & ISR_TXFOVW)
4045 priv->stats.txoverflow++;
4047 if(inta & ISR_TNPDOK){ //Normal priority tx ok
4048 priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
4049 priv->stats.txnpokint++;
4050 rtl8180_tx_isr(dev,NORM_PRIORITY,0);
4053 if(inta & ISR_TLPDOK){ //Low priority tx ok
4054 priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
4055 priv->stats.txlpokint++;
4056 rtl8180_tx_isr(dev,LOW_PRIORITY,0);
4057 rtl8180_try_wake_queue(dev, LOW_PRIORITY);
4060 if(inta & ISR_TBKDOK){ //corresponding to BK_PRIORITY
4061 priv->stats.txbkpokint++;
4062 priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
4063 rtl8180_tx_isr(dev,BK_PRIORITY,0);
4064 rtl8180_try_wake_queue(dev, BE_PRIORITY);
4067 if(inta & ISR_TBEDOK){ //corresponding to BE_PRIORITY
4068 priv->stats.txbeperr++;
4069 priv->link_detect.NumTxOkInPeriod++; //YJ,add,080828
4070 rtl8180_tx_isr(dev,BE_PRIORITY,0);
4071 rtl8180_try_wake_queue(dev, BE_PRIORITY);
4073 force_pci_posting(dev);
4074 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
4079 void rtl8180_irq_rx_tasklet(struct r8180_priv* priv)
4081 rtl8180_rx(priv->dev);
4084 void GPIOChangeRFWorkItemCallBack(struct work_struct *work)
4086 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, GPIOChangeRFWorkItem.work);
4087 struct net_device *dev = ieee->dev;
4088 struct r8180_priv *priv = ieee80211_priv(dev);
4091 RT_RF_POWER_STATE eRfPowerStateToSet;
4092 bool bActuallySet=false;
4095 static char *RadioPowerPath = "/etc/acpi/events/RadioPower.sh";
4096 static char *envp[] = {"HOME=/", "TERM=linux", "PATH=/usr/bin:/bin", NULL};
4097 static int readf_count = 0;
4099 if(readf_count % 10 == 0)
4100 priv->PowerProfile = read_acadapter_file("/proc/acpi/ac_adapter/AC0/state");
4102 readf_count = (readf_count+1)%0xffff;
4103 /* We should turn off LED before polling FF51[4]. */
4106 btPSR = read_nic_byte(dev, PSR);
4107 write_nic_byte(dev, PSR, (btPSR & ~BIT3));
4109 /* It need to delay 4us suggested by Jong, 2008-01-16 */
4112 /* HW radio On/Off according to the value of FF51[4](config0) */
4113 btConfig0 = btPSR = read_nic_byte(dev, CONFIG0);
4115 eRfPowerStateToSet = (btConfig0 & BIT4) ? eRfOn : eRfOff;
4117 /* Turn LED back on when radio enabled */
4118 if (eRfPowerStateToSet == eRfOn)
4119 write_nic_byte(dev, PSR, btPSR | BIT3);
4121 if ((priv->ieee80211->bHwRadioOff == true) &&
4122 (eRfPowerStateToSet == eRfOn)) {
4123 priv->ieee80211->bHwRadioOff = false;
4124 bActuallySet = true;
4125 } else if ((priv->ieee80211->bHwRadioOff == false) &&
4126 (eRfPowerStateToSet == eRfOff)) {
4127 priv->ieee80211->bHwRadioOff = true;
4128 bActuallySet = true;
4132 MgntActSet_RF_State(dev, eRfPowerStateToSet, RF_CHANGE_BY_HW);
4134 /* To update the UI status for Power status changed */
4135 if (priv->ieee80211->bHwRadioOff == true)
4139 argv[0] = RadioPowerPath;
4142 call_usermodehelper(RadioPowerPath, argv, envp, 1);
4146 static u8 read_acadapter_file(char *filename)
4151 module_init(rtl8180_pci_module_init);
4152 module_exit(rtl8180_pci_module_exit);