2 This is part of rtl818x pci OpenSource driver - v 0.1
3 Copyright (C) Andrea Merello 2004-2005 <andrea.merello@gmail.com>
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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32 #undef RX_DONT_PASS_UL
35 #include <linux/slab.h>
36 #include <linux/syscalls.h>
37 #include <linux/eeprom_93cx6.h>
38 #include <linux/interrupt.h>
39 #include <linux/proc_fs.h>
40 #include <linux/seq_file.h>
44 #include "r8180_rtl8225.h" /* RTL8225 Radio frontend */
45 #include "r8180_93cx6.h" /* Card EEPROM */
49 #include "ieee80211/dot11d.h"
51 static struct pci_device_id rtl8180_pci_id_tbl[] = {
53 .vendor = PCI_VENDOR_ID_REALTEK,
55 .subvendor = PCI_ANY_ID,
56 .subdevice = PCI_ANY_ID,
68 static char ifname[IFNAMSIZ] = "wlan%d";
71 MODULE_LICENSE("GPL");
72 MODULE_DEVICE_TABLE(pci, rtl8180_pci_id_tbl);
73 MODULE_AUTHOR("Andrea Merello <andrea.merello@gmail.com>");
74 MODULE_DESCRIPTION("Linux driver for Realtek RTL8187SE WiFi cards");
76 module_param_string(ifname, ifname, sizeof(ifname), S_IRUGO|S_IWUSR);
77 module_param(hwwep, int, S_IRUGO|S_IWUSR);
79 MODULE_PARM_DESC(hwwep, " Try to use hardware WEP support. Still broken and not available on all cards");
81 static int rtl8180_pci_probe(struct pci_dev *pdev,
82 const struct pci_device_id *id);
84 static void rtl8180_pci_remove(struct pci_dev *pdev);
86 static void rtl8180_shutdown(struct pci_dev *pdev)
88 struct net_device *dev = pci_get_drvdata(pdev);
89 if (dev->netdev_ops->ndo_stop)
90 dev->netdev_ops->ndo_stop(dev);
91 pci_disable_device(pdev);
94 static int rtl8180_suspend(struct pci_dev *pdev, pm_message_t state)
96 struct net_device *dev = pci_get_drvdata(pdev);
98 if (!netif_running(dev))
101 if (dev->netdev_ops->ndo_stop)
102 dev->netdev_ops->ndo_stop(dev);
104 netif_device_detach(dev);
107 pci_save_state(pdev);
108 pci_disable_device(pdev);
109 pci_set_power_state(pdev, pci_choose_state(pdev, state));
113 static int rtl8180_resume(struct pci_dev *pdev)
115 struct net_device *dev = pci_get_drvdata(pdev);
119 pci_set_power_state(pdev, PCI_D0);
121 err = pci_enable_device(pdev);
123 dev_err(&pdev->dev, "pci_enable_device failed on resume\n");
128 pci_restore_state(pdev);
131 * Suspend/Resume resets the PCI configuration space, so we have to
132 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
133 * from interfering with C3 CPU state. pci_restore_state won't help
134 * here since it only restores the first 64 bytes pci config header.
136 pci_read_config_dword(pdev, 0x40, &val);
137 if ((val & 0x0000ff00) != 0)
138 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
140 if (!netif_running(dev))
143 if (dev->netdev_ops->ndo_open)
144 dev->netdev_ops->ndo_open(dev);
146 netif_device_attach(dev);
151 static struct pci_driver rtl8180_pci_driver = {
152 .name = RTL8180_MODULE_NAME,
153 .id_table = rtl8180_pci_id_tbl,
154 .probe = rtl8180_pci_probe,
155 .remove = rtl8180_pci_remove,
156 .suspend = rtl8180_suspend,
157 .resume = rtl8180_resume,
158 .shutdown = rtl8180_shutdown,
161 u8 read_nic_byte(struct net_device *dev, int x)
163 return 0xff&readb((u8 __iomem *)dev->mem_start + x);
166 u32 read_nic_dword(struct net_device *dev, int x)
168 return readl((u8 __iomem *)dev->mem_start + x);
171 u16 read_nic_word(struct net_device *dev, int x)
173 return readw((u8 __iomem *)dev->mem_start + x);
176 void write_nic_byte(struct net_device *dev, int x, u8 y)
178 writeb(y, (u8 __iomem *)dev->mem_start + x);
182 void write_nic_dword(struct net_device *dev, int x, u32 y)
184 writel(y, (u8 __iomem *)dev->mem_start + x);
188 void write_nic_word(struct net_device *dev, int x, u16 y)
190 writew(y, (u8 __iomem *)dev->mem_start + x);
194 inline void force_pci_posting(struct net_device *dev)
196 read_nic_byte(dev, EPROM_CMD);
200 static irqreturn_t rtl8180_interrupt(int irq, void *netdev);
201 void set_nic_rxring(struct net_device *dev);
202 void set_nic_txring(struct net_device *dev);
203 static struct net_device_stats *rtl8180_stats(struct net_device *dev);
204 void rtl8180_commit(struct net_device *dev);
205 void rtl8180_start_tx_beacon(struct net_device *dev);
207 static struct proc_dir_entry *rtl8180_proc;
209 static int proc_get_registers(struct seq_file *m, void *v)
211 struct net_device *dev = m->private;
212 int i, n, max = 0xff;
214 /* This dump the current register page */
215 for (n = 0; n <= max;) {
216 seq_printf(m, "\nD: %2x > ", n);
218 for (i = 0; i < 16 && n <= max; i++, n++)
219 seq_printf(m, "%2x ", read_nic_byte(dev, n));
225 int get_curr_tx_free_desc(struct net_device *dev, int priority);
227 static int proc_get_stats_hw(struct seq_file *m, void *v)
232 static int proc_get_stats_rx(struct seq_file *m, void *v)
234 struct net_device *dev = m->private;
235 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
240 "RX CRC Error(0-500): %lu\n"
241 "RX CRC Error(500-1000): %lu\n"
242 "RX CRC Error(>1000): %lu\n"
243 "RX ICV Error: %lu\n",
246 priv->stats.rxcrcerrmin,
247 priv->stats.rxcrcerrmid,
248 priv->stats.rxcrcerrmax,
255 static int proc_get_stats_tx(struct seq_file *m, void *v)
257 struct net_device *dev = m->private;
258 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
259 unsigned long totalOK;
261 totalOK = priv->stats.txnpokint+priv->stats.txhpokint+priv->stats.txlpokint;
266 "TX beacon OK: %lu\n"
267 "TX beacon error: %lu\n",
269 priv->stats.txnperr+priv->stats.txhperr+priv->stats.txlperr,
271 priv->stats.txbeacon,
272 priv->stats.txbeaconerr
278 static void rtl8180_proc_module_init(void)
280 DMESG("Initializing proc filesystem");
281 rtl8180_proc = proc_mkdir(RTL8180_MODULE_NAME, init_net.proc_net);
284 static void rtl8180_proc_module_remove(void)
286 remove_proc_entry(RTL8180_MODULE_NAME, init_net.proc_net);
289 static void rtl8180_proc_remove_one(struct net_device *dev)
291 remove_proc_subtree(dev->name, rtl8180_proc);
295 * seq_file wrappers for procfile show routines.
297 static int rtl8180_proc_open(struct inode *inode, struct file *file)
299 struct net_device *dev = proc_get_parent_data(inode);
300 int (*show)(struct seq_file *, void *) = PDE_DATA(inode);
302 return single_open(file, show, dev);
305 static const struct file_operations rtl8180_proc_fops = {
306 .open = rtl8180_proc_open,
309 .release = single_release,
313 * Table of proc files we need to create.
315 struct rtl8180_proc_file {
317 int (*show)(struct seq_file *, void *);
320 static const struct rtl8180_proc_file rtl8180_proc_files[] = {
321 { "stats-hw", &proc_get_stats_hw },
322 { "stats-rx", &proc_get_stats_rx },
323 { "stats-tx", &proc_get_stats_tx },
324 { "registers", &proc_get_registers },
328 static void rtl8180_proc_init_one(struct net_device *dev)
330 const struct rtl8180_proc_file *f;
331 struct proc_dir_entry *dir;
333 dir = proc_mkdir_data(dev->name, 0, rtl8180_proc, dev);
335 DMESGE("Unable to initialize /proc/net/r8180/%s\n", dev->name);
339 for (f = rtl8180_proc_files; f->name[0]; f++) {
340 if (!proc_create_data(f->name, S_IFREG | S_IRUGO, dir,
341 &rtl8180_proc_fops, f->show)) {
342 DMESGE("Unable to initialize /proc/net/r8180/%s/%s\n",
350 FIXME: check if we can use some standard already-existent
351 data type+functions in kernel
354 static short buffer_add(struct buffer **buffer, u32 *buf, dma_addr_t dma,
355 struct buffer **bufferhead)
361 *buffer = kmalloc(sizeof(struct buffer), GFP_KERNEL);
363 if (*buffer == NULL) {
364 DMESGE("Failed to kmalloc head of TX/RX struct");
367 (*buffer)->next = *buffer;
368 (*buffer)->buf = buf;
369 (*buffer)->dma = dma;
370 if (bufferhead != NULL)
371 (*bufferhead) = (*buffer);
376 while (tmp->next != (*buffer))
378 tmp->next = kmalloc(sizeof(struct buffer), GFP_KERNEL);
379 if (tmp->next == NULL) {
380 DMESGE("Failed to kmalloc TX/RX struct");
383 tmp->next->buf = buf;
384 tmp->next->dma = dma;
385 tmp->next->next = *buffer;
390 static void buffer_free(struct net_device *dev, struct buffer **buffer, int len,
394 struct buffer *tmp, *next;
395 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
396 struct pci_dev *pdev = priv->pdev;
406 pci_free_consistent(pdev, len,
409 pci_unmap_single(pdev, tmp->dma,
410 len, PCI_DMA_FROMDEVICE);
415 } while (next != *buffer);
420 int get_curr_tx_free_desc(struct net_device *dev, int priority)
422 struct r8180_priv *priv = ieee80211_priv(dev);
428 case MANAGE_PRIORITY:
429 head = priv->txmapringhead;
430 tail = priv->txmapringtail;
433 head = priv->txbkpringhead;
434 tail = priv->txbkpringtail;
437 head = priv->txbepringhead;
438 tail = priv->txbepringtail;
441 head = priv->txvipringhead;
442 tail = priv->txvipringtail;
445 head = priv->txvopringhead;
446 tail = priv->txvopringtail;
449 head = priv->txhpringhead;
450 tail = priv->txhpringtail;
457 ret = priv->txringcount - (tail - head)/8;
459 ret = (head - tail)/8;
461 if (ret > priv->txringcount)
467 static short check_nic_enought_desc(struct net_device *dev, int priority)
469 struct r8180_priv *priv = ieee80211_priv(dev);
470 struct ieee80211_device *ieee = netdev_priv(dev);
471 int requiredbyte, required;
473 requiredbyte = priv->ieee80211->fts + sizeof(struct ieee80211_header_data);
475 if (ieee->current_network.QoS_Enable)
478 required = requiredbyte / (priv->txbuffsize-4);
480 if (requiredbyte % priv->txbuffsize)
483 /* for now we keep two free descriptor as a safety boundary
484 * between the tail and the head
487 return (required+2 < get_curr_tx_free_desc(dev, priority));
490 void fix_tx_fifo(struct net_device *dev)
492 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
496 for (tmp = priv->txmapring, i = 0;
497 i < priv->txringcount;
499 *tmp = *tmp & ~(1<<31);
502 for (tmp = priv->txbkpring, i = 0;
503 i < priv->txringcount;
505 *tmp = *tmp & ~(1<<31);
508 for (tmp = priv->txbepring, i = 0;
509 i < priv->txringcount;
511 *tmp = *tmp & ~(1<<31);
513 for (tmp = priv->txvipring, i = 0;
514 i < priv->txringcount;
516 *tmp = *tmp & ~(1<<31);
519 for (tmp = priv->txvopring, i = 0;
520 i < priv->txringcount;
522 *tmp = *tmp & ~(1<<31);
525 for (tmp = priv->txhpring, i = 0;
526 i < priv->txringcount;
528 *tmp = *tmp & ~(1<<31);
531 for (tmp = priv->txbeaconring, i = 0;
532 i < priv->txbeaconcount;
534 *tmp = *tmp & ~(1<<31);
537 priv->txmapringtail = priv->txmapring;
538 priv->txmapringhead = priv->txmapring;
539 priv->txmapbufstail = priv->txmapbufs;
541 priv->txbkpringtail = priv->txbkpring;
542 priv->txbkpringhead = priv->txbkpring;
543 priv->txbkpbufstail = priv->txbkpbufs;
545 priv->txbepringtail = priv->txbepring;
546 priv->txbepringhead = priv->txbepring;
547 priv->txbepbufstail = priv->txbepbufs;
549 priv->txvipringtail = priv->txvipring;
550 priv->txvipringhead = priv->txvipring;
551 priv->txvipbufstail = priv->txvipbufs;
553 priv->txvopringtail = priv->txvopring;
554 priv->txvopringhead = priv->txvopring;
555 priv->txvopbufstail = priv->txvopbufs;
557 priv->txhpringtail = priv->txhpring;
558 priv->txhpringhead = priv->txhpring;
559 priv->txhpbufstail = priv->txhpbufs;
561 priv->txbeaconringtail = priv->txbeaconring;
562 priv->txbeaconbufstail = priv->txbeaconbufs;
565 ieee80211_reset_queue(priv->ieee80211);
566 priv->ack_tx_to_ieee = 0;
569 void fix_rx_fifo(struct net_device *dev)
571 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
573 struct buffer *rxbuf;
576 rx_desc_size = 8; /* 4*8 = 32 bytes */
578 for (tmp = priv->rxring, rxbuf = priv->rxbufferhead;
579 (tmp < (priv->rxring)+(priv->rxringcount)*rx_desc_size);
580 tmp += rx_desc_size, rxbuf = rxbuf->next) {
581 *(tmp+2) = rxbuf->dma;
582 *tmp = *tmp & ~0xfff;
583 *tmp = *tmp | priv->rxbuffersize;
587 priv->rxringtail = priv->rxring;
588 priv->rxbuffer = priv->rxbufferhead;
589 priv->rx_skb_complete = 1;
593 static void rtl8180_irq_disable(struct net_device *dev)
595 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
597 write_nic_dword(dev, IMR, 0);
598 force_pci_posting(dev);
599 priv->irq_enabled = 0;
602 void rtl8180_set_mode(struct net_device *dev, int mode)
606 ecmd = read_nic_byte(dev, EPROM_CMD);
607 ecmd = ecmd & ~EPROM_CMD_OPERATING_MODE_MASK;
608 ecmd = ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
609 ecmd = ecmd & ~(1<<EPROM_CS_SHIFT);
610 ecmd = ecmd & ~(1<<EPROM_CK_SHIFT);
611 write_nic_byte(dev, EPROM_CMD, ecmd);
614 void rtl8180_beacon_tx_enable(struct net_device *dev);
616 void rtl8180_update_msr(struct net_device *dev)
618 struct r8180_priv *priv = ieee80211_priv(dev);
622 msr = read_nic_byte(dev, MSR);
623 msr &= ~MSR_LINK_MASK;
625 rxconf = read_nic_dword(dev, RX_CONF);
627 if (priv->ieee80211->state == IEEE80211_LINKED) {
628 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
629 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
630 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
631 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
632 else if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
633 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
635 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
636 rxconf |= (1<<RX_CHECK_BSSID_SHIFT);
639 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
640 rxconf &= ~(1<<RX_CHECK_BSSID_SHIFT);
643 write_nic_byte(dev, MSR, msr);
644 write_nic_dword(dev, RX_CONF, rxconf);
647 void rtl8180_set_chan(struct net_device *dev, short ch)
649 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
651 if ((ch > 14) || (ch < 1)) {
652 printk("In %s: Invalid chnanel %d\n", __func__, ch);
657 priv->rf_set_chan(dev, priv->chan);
660 void set_nic_txring(struct net_device *dev)
662 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
664 write_nic_dword(dev, TX_MANAGEPRIORITY_RING_ADDR, priv->txmapringdma);
665 write_nic_dword(dev, TX_BKPRIORITY_RING_ADDR, priv->txbkpringdma);
666 write_nic_dword(dev, TX_BEPRIORITY_RING_ADDR, priv->txbepringdma);
667 write_nic_dword(dev, TX_VIPRIORITY_RING_ADDR, priv->txvipringdma);
668 write_nic_dword(dev, TX_VOPRIORITY_RING_ADDR, priv->txvopringdma);
669 write_nic_dword(dev, TX_HIGHPRIORITY_RING_ADDR, priv->txhpringdma);
670 write_nic_dword(dev, TX_BEACON_RING_ADDR, priv->txbeaconringdma);
673 void rtl8180_beacon_tx_enable(struct net_device *dev)
675 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
677 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
678 priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_BQ);
679 write_nic_byte(dev, TPPollStop, priv->dma_poll_mask);
680 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
683 void rtl8180_beacon_tx_disable(struct net_device *dev)
685 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
687 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
688 priv->dma_poll_stop_mask |= TPPOLLSTOP_BQ;
689 write_nic_byte(dev, TPPollStop, priv->dma_poll_stop_mask);
690 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
694 void rtl8180_rtx_disable(struct net_device *dev)
697 struct r8180_priv *priv = ieee80211_priv(dev);
699 cmd = read_nic_byte(dev, CMD);
700 write_nic_byte(dev, CMD, cmd &
701 ~((1<<CMD_RX_ENABLE_SHIFT)|(1<<CMD_TX_ENABLE_SHIFT)));
702 force_pci_posting(dev);
705 if (!priv->rx_skb_complete)
706 dev_kfree_skb_any(priv->rx_skb);
709 static short alloc_tx_desc_ring(struct net_device *dev, int bufsize, int count,
715 dma_addr_t dma_desc, dma_tmp;
716 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
717 struct pci_dev *pdev = priv->pdev;
720 if ((bufsize & 0xfff) != bufsize) {
721 DMESGE("TX buffer allocation too large");
724 desc = (u32 *)pci_alloc_consistent(pdev,
725 sizeof(u32)*8*count+256, &dma_desc);
731 * descriptor's buffer must be 256 byte aligned
732 * we shouldn't be here, since we set DMA mask !
734 WARN(1, "DMA buffer is not aligned\n");
738 for (i = 0; i < count; i++) {
739 buf = (void *)pci_alloc_consistent(pdev, bufsize, &dma_tmp);
744 case TX_MANAGEPRIORITY_RING_ADDR:
745 if (-1 == buffer_add(&(priv->txmapbufs), buf, dma_tmp, NULL)) {
746 DMESGE("Unable to allocate mem for buffer NP");
750 case TX_BKPRIORITY_RING_ADDR:
751 if (-1 == buffer_add(&(priv->txbkpbufs), buf, dma_tmp, NULL)) {
752 DMESGE("Unable to allocate mem for buffer LP");
756 case TX_BEPRIORITY_RING_ADDR:
757 if (-1 == buffer_add(&(priv->txbepbufs), buf, dma_tmp, NULL)) {
758 DMESGE("Unable to allocate mem for buffer NP");
762 case TX_VIPRIORITY_RING_ADDR:
763 if (-1 == buffer_add(&(priv->txvipbufs), buf, dma_tmp, NULL)) {
764 DMESGE("Unable to allocate mem for buffer LP");
768 case TX_VOPRIORITY_RING_ADDR:
769 if (-1 == buffer_add(&(priv->txvopbufs), buf, dma_tmp, NULL)) {
770 DMESGE("Unable to allocate mem for buffer NP");
774 case TX_HIGHPRIORITY_RING_ADDR:
775 if (-1 == buffer_add(&(priv->txhpbufs), buf, dma_tmp, NULL)) {
776 DMESGE("Unable to allocate mem for buffer HP");
780 case TX_BEACON_RING_ADDR:
781 if (-1 == buffer_add(&(priv->txbeaconbufs), buf, dma_tmp, NULL)) {
782 DMESGE("Unable to allocate mem for buffer BP");
787 *tmp = *tmp & ~(1<<31); /* descriptor empty, owned by the drv */
788 *(tmp+2) = (u32)dma_tmp;
792 *(tmp+4) = (u32)dma_desc+((i+1)*8*4);
794 *(tmp+4) = (u32)dma_desc;
800 case TX_MANAGEPRIORITY_RING_ADDR:
801 priv->txmapringdma = dma_desc;
802 priv->txmapring = desc;
804 case TX_BKPRIORITY_RING_ADDR:
805 priv->txbkpringdma = dma_desc;
806 priv->txbkpring = desc;
808 case TX_BEPRIORITY_RING_ADDR:
809 priv->txbepringdma = dma_desc;
810 priv->txbepring = desc;
812 case TX_VIPRIORITY_RING_ADDR:
813 priv->txvipringdma = dma_desc;
814 priv->txvipring = desc;
816 case TX_VOPRIORITY_RING_ADDR:
817 priv->txvopringdma = dma_desc;
818 priv->txvopring = desc;
820 case TX_HIGHPRIORITY_RING_ADDR:
821 priv->txhpringdma = dma_desc;
822 priv->txhpring = desc;
824 case TX_BEACON_RING_ADDR:
825 priv->txbeaconringdma = dma_desc;
826 priv->txbeaconring = desc;
834 static void free_tx_desc_rings(struct net_device *dev)
836 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
837 struct pci_dev *pdev = priv->pdev;
838 int count = priv->txringcount;
840 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
841 priv->txmapring, priv->txmapringdma);
842 buffer_free(dev, &(priv->txmapbufs), priv->txbuffsize, 1);
844 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
845 priv->txbkpring, priv->txbkpringdma);
846 buffer_free(dev, &(priv->txbkpbufs), priv->txbuffsize, 1);
848 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
849 priv->txbepring, priv->txbepringdma);
850 buffer_free(dev, &(priv->txbepbufs), priv->txbuffsize, 1);
852 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
853 priv->txvipring, priv->txvipringdma);
854 buffer_free(dev, &(priv->txvipbufs), priv->txbuffsize, 1);
856 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
857 priv->txvopring, priv->txvopringdma);
858 buffer_free(dev, &(priv->txvopbufs), priv->txbuffsize, 1);
860 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
861 priv->txhpring, priv->txhpringdma);
862 buffer_free(dev, &(priv->txhpbufs), priv->txbuffsize, 1);
864 count = priv->txbeaconcount;
865 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
866 priv->txbeaconring, priv->txbeaconringdma);
867 buffer_free(dev, &(priv->txbeaconbufs), priv->txbuffsize, 1);
870 static void free_rx_desc_ring(struct net_device *dev)
872 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
873 struct pci_dev *pdev = priv->pdev;
874 int count = priv->rxringcount;
876 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
877 priv->rxring, priv->rxringdma);
879 buffer_free(dev, &(priv->rxbuffer), priv->rxbuffersize, 0);
882 static short alloc_rx_desc_ring(struct net_device *dev, u16 bufsize, int count)
887 dma_addr_t dma_desc, dma_tmp;
888 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
889 struct pci_dev *pdev = priv->pdev;
893 rx_desc_size = 8; /* 4*8 = 32 bytes */
895 if ((bufsize & 0xfff) != bufsize) {
896 DMESGE("RX buffer allocation too large");
900 desc = (u32 *)pci_alloc_consistent(pdev, sizeof(u32)*rx_desc_size*count+256,
905 * descriptor's buffer must be 256 byte aligned
906 * should never happen since we specify the DMA mask
908 WARN(1, "DMA buffer is not aligned\n");
911 priv->rxringdma = dma_desc;
914 for (i = 0; i < count; i++) {
915 buf = kmalloc(bufsize * sizeof(u8), GFP_ATOMIC);
917 DMESGE("Failed to kmalloc RX buffer");
921 dma_tmp = pci_map_single(pdev, buf, bufsize * sizeof(u8),
923 if (pci_dma_mapping_error(pdev, dma_tmp))
925 if (-1 == buffer_add(&(priv->rxbuffer), buf, dma_tmp,
926 &(priv->rxbufferhead))) {
927 DMESGE("Unable to allocate mem RX buf");
930 *tmp = 0; /* zero pads the header of the descriptor */
931 *tmp = *tmp | (bufsize&0xfff);
932 *(tmp+2) = (u32)dma_tmp;
933 *tmp = *tmp | (1<<31); /* descriptor void, owned by the NIC */
935 tmp = tmp+rx_desc_size;
938 *(tmp-rx_desc_size) = *(tmp-rx_desc_size) | (1<<30); /* this is the last descriptor */
944 void set_nic_rxring(struct net_device *dev)
947 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
949 pgreg = read_nic_byte(dev, PGSELECT);
950 write_nic_byte(dev, PGSELECT, pgreg & ~(1<<PGSELECT_PG_SHIFT));
952 write_nic_dword(dev, RXRING_ADDR, priv->rxringdma);
955 void rtl8180_reset(struct net_device *dev)
959 rtl8180_irq_disable(dev);
961 cr = read_nic_byte(dev, CMD);
963 cr = cr | (1<<CMD_RST_SHIFT);
964 write_nic_byte(dev, CMD, cr);
966 force_pci_posting(dev);
970 if (read_nic_byte(dev, CMD) & (1<<CMD_RST_SHIFT))
971 DMESGW("Card reset timeout!");
973 DMESG("Card successfully reset");
975 rtl8180_set_mode(dev, EPROM_CMD_LOAD);
976 force_pci_posting(dev);
980 inline u16 ieeerate2rtlrate(int rate)
1012 static u16 rtl_rate[] = {10, 20, 55, 110, 60, 90, 120, 180, 240, 360, 480, 540, 720};
1014 inline u16 rtl8180_rate2rate(short rate)
1018 return rtl_rate[rate];
1021 inline u8 rtl8180_IsWirelessBMode(u16 rate)
1023 if (((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220))
1029 u16 N_DBPSOfRate(u16 DataRate);
1031 static u16 ComputeTxTime(u16 FrameLength, u16 DataRate, u8 bManagementFrame,
1038 if (rtl8180_IsWirelessBMode(DataRate)) {
1039 if (bManagementFrame || !bShortPreamble || DataRate == 10)
1041 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1043 /* short preamble */
1044 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1046 if ((FrameLength*8 % (DataRate/10)) != 0) /* get the ceilling */
1048 } else { /* 802.11g DSSS-OFDM PLCP length field calculation. */
1049 N_DBPS = N_DBPSOfRate(DataRate);
1050 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1051 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1052 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1057 u16 N_DBPSOfRate(u16 DataRate)
1094 * For Netgear case, they want good-looking signal strength.
1096 static long NetgearSignalStrengthTranslate(long LastSS, long CurrSS)
1100 /* Step 1. Scale mapping. */
1101 if (CurrSS >= 71 && CurrSS <= 100)
1102 RetSS = 90 + ((CurrSS - 70) / 3);
1103 else if (CurrSS >= 41 && CurrSS <= 70)
1104 RetSS = 78 + ((CurrSS - 40) / 3);
1105 else if (CurrSS >= 31 && CurrSS <= 40)
1106 RetSS = 66 + (CurrSS - 30);
1107 else if (CurrSS >= 21 && CurrSS <= 30)
1108 RetSS = 54 + (CurrSS - 20);
1109 else if (CurrSS >= 5 && CurrSS <= 20)
1110 RetSS = 42 + (((CurrSS - 5) * 2) / 3);
1111 else if (CurrSS == 4)
1113 else if (CurrSS == 3)
1115 else if (CurrSS == 2)
1117 else if (CurrSS == 1)
1122 /* Step 2. Smoothing. */
1124 RetSS = ((LastSS * 5) + (RetSS) + 5) / 6;
1130 * Translate 0-100 signal strength index into dBm.
1132 static long TranslateToDbm8185(u8 SignalStrengthIndex)
1136 /* Translate to dBm (x=0.5y-95). */
1137 SignalPower = (long)((SignalStrengthIndex + 1) >> 1);
1144 * Perform signal smoothing for dynamic mechanism.
1145 * This is different with PerformSignalSmoothing8185 in smoothing formula.
1146 * No dramatic adjustion is apply because dynamic mechanism need some degree
1147 * of correctness. Ported from 8187B.
1149 static void PerformUndecoratedSignalSmoothing8185(struct r8180_priv *priv,
1152 /* Determin the current packet is CCK rate. */
1153 priv->bCurCCKPkt = bCckRate;
1155 if (priv->UndecoratedSmoothedSS >= 0)
1156 priv->UndecoratedSmoothedSS = ((priv->UndecoratedSmoothedSS * 5) +
1157 (priv->SignalStrength * 10)) / 6;
1159 priv->UndecoratedSmoothedSS = priv->SignalStrength * 10;
1161 priv->UndercorateSmoothedRxPower = ((priv->UndercorateSmoothedRxPower * 50) +
1162 (priv->RxPower * 11)) / 60;
1165 priv->CurCCKRSSI = priv->RSSI;
1167 priv->CurCCKRSSI = 0;
1172 * This is rough RX isr handling routine
1174 static void rtl8180_rx(struct net_device *dev)
1176 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1177 struct sk_buff *tmp_skb;
1181 unsigned char quality, signal;
1190 u8 LNA_gain[4] = {02, 17, 29, 39};
1192 struct ieee80211_hdr_4addr *hdr;
1194 u8 bHwError = 0, bCRC = 0, bICV = 0;
1195 bool bCckRate = false;
1197 long SignalStrengthIndex = 0;
1198 struct ieee80211_rx_stats stats = {
1202 .freq = IEEE80211_24GHZ_BAND,
1205 stats.nic_type = NIC_8185B;
1208 if ((*(priv->rxringtail)) & (1<<31)) {
1209 /* we have got an RX int, but the descriptor
1210 * we are pointing is empty */
1212 priv->stats.rxnodata++;
1213 priv->ieee80211->stats.rx_errors++;
1216 tmp = priv->rxringtail;
1218 if (tmp == priv->rxring)
1219 tmp = priv->rxring + (priv->rxringcount - 1)*rx_desc_size;
1221 tmp -= rx_desc_size;
1223 if (!(*tmp & (1<<31)))
1225 } while (tmp != priv->rxring);
1228 priv->rxringtail = tmp2;
1231 /* while there are filled descriptors */
1232 while (!(*(priv->rxringtail) & (1<<31))) {
1233 if (*(priv->rxringtail) & (1<<26))
1234 DMESGW("RX buffer overflow");
1235 if (*(priv->rxringtail) & (1<<12))
1236 priv->stats.rxicverr++;
1238 if (*(priv->rxringtail) & (1<<27)) {
1239 priv->stats.rxdmafail++;
1240 /* DMESG("EE: RX DMA FAILED at buffer pointed by descriptor %x",(u32)priv->rxringtail); */
1244 pci_dma_sync_single_for_cpu(priv->pdev,
1245 priv->rxbuffer->dma,
1246 priv->rxbuffersize * sizeof(u8),
1247 PCI_DMA_FROMDEVICE);
1249 first = *(priv->rxringtail) & (1<<29) ? 1 : 0;
1251 priv->rx_prevlen = 0;
1253 last = *(priv->rxringtail) & (1<<28) ? 1 : 0;
1255 lastlen = ((*priv->rxringtail) & 0xfff);
1257 /* if the last descriptor (that should
1258 * tell us the total packet len) tell
1259 * us something less than the descriptors
1260 * len we had until now, then there is some
1262 * workaround to prevent kernel panic
1264 if (lastlen < priv->rx_prevlen)
1267 len = lastlen-priv->rx_prevlen;
1269 if (*(priv->rxringtail) & (1<<13)) {
1270 if ((*(priv->rxringtail) & 0xfff) < 500)
1271 priv->stats.rxcrcerrmin++;
1272 else if ((*(priv->rxringtail) & 0x0fff) > 1000)
1273 priv->stats.rxcrcerrmax++;
1275 priv->stats.rxcrcerrmid++;
1280 len = priv->rxbuffersize;
1283 if (first && last) {
1284 padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
1286 padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
1293 priv->rx_prevlen += len;
1295 if (priv->rx_prevlen > MAX_FRAG_THRESHOLD + 100) {
1296 /* HW is probably passing several buggy frames
1297 * without FD or LD flag set.
1298 * Throw this garbage away to prevent skb
1301 if (!priv->rx_skb_complete)
1302 dev_kfree_skb_any(priv->rx_skb);
1303 priv->rx_skb_complete = 1;
1306 signal = (unsigned char)(((*(priv->rxringtail+3)) & (0x00ff0000))>>16);
1307 signal = (signal & 0xfe) >> 1;
1309 quality = (unsigned char)((*(priv->rxringtail+3)) & (0xff));
1311 stats.mac_time[0] = *(priv->rxringtail+1);
1312 stats.mac_time[1] = *(priv->rxringtail+2);
1313 rxpower = ((char)(((*(priv->rxringtail+4)) & (0x00ff0000))>>16))/2 - 42;
1314 RSSI = ((u8)(((*(priv->rxringtail+3)) & (0x0000ff00))>>8)) & (0x7f);
1316 rate = ((*(priv->rxringtail)) &
1317 ((1<<23)|(1<<22)|(1<<21)|(1<<20)))>>20;
1319 stats.rate = rtl8180_rate2rate(rate);
1320 Antenna = (((*(priv->rxringtail+3)) & (0x00008000)) == 0) ? 0 : 1;
1321 if (!rtl8180_IsWirelessBMode(stats.rate)) { /* OFDM rate. */
1322 RxAGC_dBm = rxpower+1; /* bias */
1323 } else { /* CCK rate. */
1324 RxAGC_dBm = signal; /* bit 0 discard */
1326 LNA = (u8) (RxAGC_dBm & 0x60) >> 5; /* bit 6~ bit 5 */
1327 BB = (u8) (RxAGC_dBm & 0x1F); /* bit 4 ~ bit 0 */
1329 RxAGC_dBm = -(LNA_gain[LNA] + (BB*2)); /* Pin_11b=-(LNA_gain+BB_gain) (dBm) */
1331 RxAGC_dBm += 4; /* bias */
1334 if (RxAGC_dBm & 0x80) /* absolute value */
1335 RXAGC = ~(RxAGC_dBm)+1;
1336 bCckRate = rtl8180_IsWirelessBMode(stats.rate);
1337 /* Translate RXAGC into 1-100. */
1338 if (!rtl8180_IsWirelessBMode(stats.rate)) { /* OFDM rate. */
1341 else if (RXAGC < 25)
1343 RXAGC = (90-RXAGC)*100/65;
1344 } else { /* CCK rate. */
1347 else if (RXAGC < 30)
1349 RXAGC = (95-RXAGC)*100/65;
1351 priv->SignalStrength = (u8)RXAGC;
1352 priv->RecvSignalPower = RxAGC_dBm;
1353 priv->RxPower = rxpower;
1355 /* SQ translation formula is provided by SD3 DZ. 2006.06.27 */
1357 quality = 1; /*0; */ /* 0 will cause epc to show signal zero , walk around now; */
1358 else if (quality < 27)
1361 quality = 127 - quality;
1362 priv->SignalQuality = quality;
1364 stats.signal = (u8)quality; /*priv->wstats.qual.level = priv->SignalStrength; */
1365 stats.signalstrength = RXAGC;
1366 if (stats.signalstrength > 100)
1367 stats.signalstrength = 100;
1368 stats.signalstrength = (stats.signalstrength * 70)/100 + 30;
1369 /* printk("==========================>rx : RXAGC is %d,signalstrength is %d\n",RXAGC,stats.signalstrength); */
1370 stats.rssi = priv->wstats.qual.qual = priv->SignalQuality;
1371 stats.noise = priv->wstats.qual.noise = 100 - priv->wstats.qual.qual;
1372 bHwError = (((*(priv->rxringtail)) & (0x00000fff)) == 4080) |
1373 (((*(priv->rxringtail)) & (0x04000000)) != 0) |
1374 (((*(priv->rxringtail)) & (0x08000000)) != 0) |
1375 (((~(*(priv->rxringtail))) & (0x10000000)) != 0) |
1376 (((~(*(priv->rxringtail))) & (0x20000000)) != 0);
1377 bCRC = ((*(priv->rxringtail)) & (0x00002000)) >> 13;
1378 bICV = ((*(priv->rxringtail)) & (0x00001000)) >> 12;
1379 hdr = (struct ieee80211_hdr_4addr *)priv->rxbuffer->buf;
1380 fc = le16_to_cpu(hdr->frame_ctl);
1381 type = WLAN_FC_GET_TYPE(fc);
1383 if (IEEE80211_FTYPE_CTL != type &&
1384 !bHwError && !bCRC && !bICV &&
1385 eqMacAddr(priv->ieee80211->current_network.bssid,
1386 fc & IEEE80211_FCTL_TODS ? hdr->addr1 :
1387 fc & IEEE80211_FCTL_FROMDS ? hdr->addr2 :
1390 /* Perform signal smoothing for dynamic
1391 * mechanism on demand. This is different
1392 * with PerformSignalSmoothing8185 in smoothing
1393 * fomula. No dramatic adjustion is apply
1394 * because dynamic mechanism need some degree
1395 * of correctness. */
1396 PerformUndecoratedSignalSmoothing8185(priv, bCckRate);
1398 /* For good-looking singal strength. */
1399 SignalStrengthIndex = NetgearSignalStrengthTranslate(
1400 priv->LastSignalStrengthInPercent,
1401 priv->SignalStrength);
1403 priv->LastSignalStrengthInPercent = SignalStrengthIndex;
1404 priv->Stats_SignalStrength = TranslateToDbm8185((u8)SignalStrengthIndex);
1406 * We need more correct power of received packets and the "SignalStrength" of RxStats is beautified,
1407 * so we record the correct power here.
1409 priv->Stats_SignalQuality = (long)(priv->Stats_SignalQuality * 5 + (long)priv->SignalQuality + 5) / 6;
1410 priv->Stats_RecvSignalPower = (long)(priv->Stats_RecvSignalPower * 5 + priv->RecvSignalPower - 1) / 6;
1412 /* Figure out which antenna that received the last packet. */
1413 priv->LastRxPktAntenna = Antenna ? 1 : 0; /* 0: aux, 1: main. */
1414 SwAntennaDiversityRxOk8185(dev, priv->SignalStrength);
1418 if (!priv->rx_skb_complete) {
1419 /* seems that HW sometimes fails to receive and
1420 doesn't provide the last descriptor */
1421 dev_kfree_skb_any(priv->rx_skb);
1422 priv->stats.rxnolast++;
1424 priv->rx_skb = dev_alloc_skb(len+2);
1428 priv->rx_skb_complete = 0;
1429 priv->rx_skb->dev = dev;
1431 /* if we are here we should have already RXed
1433 * If we get here and the skb is not allocated then
1434 * we have just throw out garbage (skb not allocated)
1435 * and we are still rxing garbage....
1437 if (!priv->rx_skb_complete) {
1439 tmp_skb = dev_alloc_skb(priv->rx_skb->len+len+2);
1446 memcpy(skb_put(tmp_skb, priv->rx_skb->len),
1450 dev_kfree_skb_any(priv->rx_skb);
1452 priv->rx_skb = tmp_skb;
1456 if (!priv->rx_skb_complete) {
1458 memcpy(skb_put(priv->rx_skb, len),
1459 (((unsigned char *)priv->rxbuffer->buf) + 2), len);
1461 memcpy(skb_put(priv->rx_skb, len),
1462 priv->rxbuffer->buf, len);
1466 if (last && !priv->rx_skb_complete) {
1467 if (priv->rx_skb->len > 4)
1468 skb_trim(priv->rx_skb, priv->rx_skb->len-4);
1469 if (!ieee80211_rtl_rx(priv->ieee80211,
1470 priv->rx_skb, &stats))
1471 dev_kfree_skb_any(priv->rx_skb);
1472 priv->rx_skb_complete = 1;
1475 pci_dma_sync_single_for_device(priv->pdev,
1476 priv->rxbuffer->dma,
1477 priv->rxbuffersize * sizeof(u8),
1478 PCI_DMA_FROMDEVICE);
1480 drop: /* this is used when we have not enough mem */
1481 /* restore the descriptor */
1482 *(priv->rxringtail+2) = priv->rxbuffer->dma;
1483 *(priv->rxringtail) = *(priv->rxringtail) & ~0xfff;
1484 *(priv->rxringtail) =
1485 *(priv->rxringtail) | priv->rxbuffersize;
1487 *(priv->rxringtail) =
1488 *(priv->rxringtail) | (1<<31);
1490 priv->rxringtail += rx_desc_size;
1491 if (priv->rxringtail >=
1492 (priv->rxring)+(priv->rxringcount)*rx_desc_size)
1493 priv->rxringtail = priv->rxring;
1495 priv->rxbuffer = (priv->rxbuffer->next);
1500 static void rtl8180_dma_kick(struct net_device *dev, int priority)
1502 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1504 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1505 write_nic_byte(dev, TX_DMA_POLLING,
1506 (1 << (priority + 1)) | priv->dma_poll_mask);
1507 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1509 force_pci_posting(dev);
1512 static void rtl8180_data_hard_stop(struct net_device *dev)
1514 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1516 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1517 priv->dma_poll_stop_mask |= TPPOLLSTOP_AC_VIQ;
1518 write_nic_byte(dev, TPPollStop, priv->dma_poll_stop_mask);
1519 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1522 static void rtl8180_data_hard_resume(struct net_device *dev)
1524 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1526 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1527 priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_AC_VIQ);
1528 write_nic_byte(dev, TPPollStop, priv->dma_poll_stop_mask);
1529 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1533 * This function TX data frames when the ieee80211 stack requires this.
1534 * It checks also if we need to stop the ieee tx queue, eventually do it
1536 static void rtl8180_hard_data_xmit(struct sk_buff *skb, struct net_device *dev,
1539 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1541 struct ieee80211_hdr_3addr *h = (struct ieee80211_hdr_3addr *) skb->data;
1542 short morefrag = (h->frame_control) & IEEE80211_FCTL_MOREFRAGS;
1543 unsigned long flags;
1546 mode = priv->ieee80211->iw_mode;
1548 rate = ieeerate2rtlrate(rate);
1550 * This function doesn't require lock because we make
1551 * sure it's called with the tx_lock already acquired.
1552 * this come from the kernel's hard_xmit callback (through
1553 * the ieee stack, or from the try_wake_queue (again through
1556 priority = AC2Q(skb->priority);
1557 spin_lock_irqsave(&priv->tx_lock, flags);
1559 if (priv->ieee80211->bHwRadioOff) {
1560 spin_unlock_irqrestore(&priv->tx_lock, flags);
1565 if (!check_nic_enought_desc(dev, priority)) {
1566 DMESGW("Error: no descriptor left by previous TX (avail %d) ",
1567 get_curr_tx_free_desc(dev, priority));
1568 ieee80211_rtl_stop_queue(priv->ieee80211);
1570 rtl8180_tx(dev, skb->data, skb->len, priority, morefrag, 0, rate);
1571 if (!check_nic_enought_desc(dev, priority))
1572 ieee80211_rtl_stop_queue(priv->ieee80211);
1574 spin_unlock_irqrestore(&priv->tx_lock, flags);
1578 * This is a rough attempt to TX a frame
1579 * This is called by the ieee 80211 stack to TX management frames.
1580 * If the ring is full packets are dropped (for data frame the queue
1581 * is stopped before this can happen). For this reason it is better
1582 * if the descriptors are larger than the largest management frame
1583 * we intend to TX: i'm unsure what the HW does if it will not find
1584 * the last fragment of a frame because it has been dropped...
1585 * Since queues for Management and Data frames are different we
1586 * might use a different lock than tx_lock (for example mgmt_tx_lock)
1588 /* these function may loop if invoked with 0 descriptors or 0 len buffer */
1589 static int rtl8180_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1591 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1592 unsigned long flags;
1595 priority = MANAGE_PRIORITY;
1597 spin_lock_irqsave(&priv->tx_lock, flags);
1599 if (priv->ieee80211->bHwRadioOff) {
1600 spin_unlock_irqrestore(&priv->tx_lock, flags);
1601 dev_kfree_skb_any(skb);
1602 return NETDEV_TX_OK;
1605 rtl8180_tx(dev, skb->data, skb->len, priority,
1606 0, 0, ieeerate2rtlrate(priv->ieee80211->basic_rate));
1608 priv->ieee80211->stats.tx_bytes += skb->len;
1609 priv->ieee80211->stats.tx_packets++;
1610 spin_unlock_irqrestore(&priv->tx_lock, flags);
1612 dev_kfree_skb_any(skb);
1613 return NETDEV_TX_OK;
1616 /* longpre 144+48 shortpre 72+24 */
1617 u16 rtl8180_len2duration(u32 len, short rate, short *ext)
1626 duration = ((len+4)<<4) / 0x2;
1627 drift = ((len+4)<<4) % 0x2;
1634 duration = ((len+4)<<4) / 0x4;
1635 drift = ((len+4)<<4) % 0x4;
1640 case 2: /* 5.5mbps */
1642 duration = ((len+4)<<4) / 0xb;
1643 drift = ((len+4)<<4) % 0xb;
1649 case 3: /* 11mbps */
1651 duration = ((len+4)<<4) / 0x16;
1652 drift = ((len+4)<<4) % 0x16;
1665 static void rtl8180_prepare_beacon(struct net_device *dev)
1667 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1668 struct sk_buff *skb;
1670 u16 word = read_nic_word(dev, BcnItv);
1671 word &= ~BcnItv_BcnItv; /* clear Bcn_Itv */
1672 word |= cpu_to_le16(priv->ieee80211->current_network.beacon_interval); /* 0x64; */
1673 write_nic_word(dev, BcnItv, word);
1675 skb = ieee80211_get_beacon(priv->ieee80211);
1677 rtl8180_tx(dev, skb->data, skb->len, BEACON_PRIORITY,
1678 0, 0, ieeerate2rtlrate(priv->ieee80211->basic_rate));
1679 dev_kfree_skb_any(skb);
1684 * This function do the real dirty work: it enqueues a TX command
1685 * descriptor in the ring buffer, copyes the frame in a TX buffer
1686 * and kicks the NIC to ensure it does the DMA transfer.
1688 short rtl8180_tx(struct net_device *dev, u8 *txbuf, int len, int priority,
1689 short morefrag, short descfrag, int rate)
1691 struct r8180_priv *priv = ieee80211_priv(dev);
1692 u32 *tail, *temp_tail;
1699 struct buffer *buflist;
1700 struct ieee80211_hdr_3addr *frag_hdr = (struct ieee80211_hdr_3addr *)txbuf;
1702 u8 bUseShortPreamble = 0;
1707 u16 ThisFrameTime = 0;
1708 u16 TxDescDuration = 0;
1709 bool ownbit_flag = false;
1712 case MANAGE_PRIORITY:
1713 tail = priv->txmapringtail;
1714 begin = priv->txmapring;
1715 buflist = priv->txmapbufstail;
1716 count = priv->txringcount;
1719 tail = priv->txbkpringtail;
1720 begin = priv->txbkpring;
1721 buflist = priv->txbkpbufstail;
1722 count = priv->txringcount;
1725 tail = priv->txbepringtail;
1726 begin = priv->txbepring;
1727 buflist = priv->txbepbufstail;
1728 count = priv->txringcount;
1731 tail = priv->txvipringtail;
1732 begin = priv->txvipring;
1733 buflist = priv->txvipbufstail;
1734 count = priv->txringcount;
1737 tail = priv->txvopringtail;
1738 begin = priv->txvopring;
1739 buflist = priv->txvopbufstail;
1740 count = priv->txringcount;
1743 tail = priv->txhpringtail;
1744 begin = priv->txhpring;
1745 buflist = priv->txhpbufstail;
1746 count = priv->txringcount;
1748 case BEACON_PRIORITY:
1749 tail = priv->txbeaconringtail;
1750 begin = priv->txbeaconring;
1751 buflist = priv->txbeaconbufstail;
1752 count = priv->txbeaconcount;
1759 memcpy(&dest, frag_hdr->addr1, ETH_ALEN);
1760 if (is_multicast_ether_addr(dest)) {
1766 ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate),
1767 0, bUseShortPreamble);
1768 TxDescDuration = ThisFrameTime;
1769 } else { /* Unicast packet */
1772 /* YJ,add,080828,for Keep alive */
1773 priv->NumTxUnicast++;
1775 /* Figure out ACK rate according to BSS basic rate
1777 AckTime = ComputeTxTime(14, 10, 0, 0); /* AckCTSLng = 14 use 1M bps send */
1779 if (((len + sCrcLng) > priv->rts) && priv->rts) { /* RTS/CTS. */
1780 u16 RtsTime, CtsTime;
1785 /* Rate and time required for RTS. */
1786 RtsTime = ComputeTxTime(sAckCtsLng/8, priv->ieee80211->basic_rate, 0, 0);
1787 /* Rate and time required for CTS. */
1788 CtsTime = ComputeTxTime(14, 10, 0, 0); /* AckCTSLng = 14 use 1M bps send */
1790 /* Figure out time required to transmit this frame. */
1791 ThisFrameTime = ComputeTxTime(len + sCrcLng,
1792 rtl8180_rate2rate(rate),
1796 /* RTS-CTS-ThisFrame-ACK. */
1797 RtsDur = CtsTime + ThisFrameTime + AckTime + 3*aSifsTime;
1799 TxDescDuration = RtsTime + RtsDur;
1800 } else { /* Normal case. */
1805 ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate),
1806 0, bUseShortPreamble);
1807 TxDescDuration = ThisFrameTime + aSifsTime + AckTime;
1810 if (!(frag_hdr->frame_control & IEEE80211_FCTL_MOREFRAGS)) {
1811 /* ThisFrame-ACK. */
1812 Duration = aSifsTime + AckTime;
1813 } else { /* One or more fragments remained. */
1815 NextFragTime = ComputeTxTime(len + sCrcLng, /* pretend following packet length equal current packet */
1816 rtl8180_rate2rate(rate),
1820 /* ThisFrag-ACk-NextFrag-ACK. */
1821 Duration = NextFragTime + 3*aSifsTime + 2*AckTime;
1824 } /* End of Unicast packet */
1826 frag_hdr->duration_id = Duration;
1828 buflen = priv->txbuffsize;
1832 while (remain != 0) {
1835 DMESGE("TX buffer error, cannot TX frames. pri %d.", priority);
1840 if ((*tail & (1 << 31)) && (priority != BEACON_PRIORITY)) {
1841 DMESGW("No more TX desc, returning %x of %x",
1843 priv->stats.txrdu++;
1847 *tail = 0; /* zeroes header */
1854 /* FIXME: this should be triggered by HW encryption parameters.*/
1855 *tail |= (1<<15); /* no encrypt */
1857 if (remain == len && !descfrag) {
1858 ownbit_flag = false;
1859 *tail = *tail | (1<<29); /* fist segment of the packet */
1860 *tail = *tail | (len);
1865 for (i = 0; i < buflen && remain > 0; i++, remain--) {
1866 ((u8 *)buf)[i] = txbuf[i]; /* copy data into descriptor pointed DMAble buffer */
1867 if (remain == 4 && i+4 >= buflen)
1869 /* ensure the last desc has at least 4 bytes payload */
1873 *(tail+3) = *(tail+3) & ~0xfff;
1874 *(tail+3) = *(tail+3) | i; /* buffer length */
1875 /* Use short preamble or not */
1876 if (priv->ieee80211->current_network.capability&WLAN_CAPABILITY_SHORT_PREAMBLE)
1877 if (priv->plcp_preamble_mode == 1 && rate != 0) /* short mode now, not long! */
1878 ; /* *tail |= (1<<16); */ /* enable short preamble mode. */
1883 if (bRTSEnable) { /* rts enable */
1884 *tail |= ((ieeerate2rtlrate(priv->ieee80211->basic_rate))<<19); /* RTS RATE */
1885 *tail |= (1<<23); /* rts enable */
1886 *(tail+1) |= (RtsDur&0xffff); /* RTS Duration */
1888 *(tail+3) |= ((TxDescDuration&0xffff)<<16); /* DURATION */
1889 /* *(tail+3) |= (0xe6<<16); */
1890 *(tail+5) |= (11<<8); /* (priv->retry_data<<8); */ /* retry lim; */
1892 *tail = *tail | ((rate&0xf) << 24);
1895 *tail = (*tail) | (1<<17); /* more fragment */
1897 *tail = (*tail) | (1<<28); /* last segment of frame */
1899 *(tail+5) = *(tail+5)|(2<<27);
1900 *(tail+7) = *(tail+7)|(1<<4);
1904 *tail = *tail | (1<<31); /* descriptor ready to be txed */
1906 if ((tail - begin)/8 == count-1)
1911 buflist = buflist->next;
1916 case MANAGE_PRIORITY:
1917 priv->txmapringtail = tail;
1918 priv->txmapbufstail = buflist;
1921 priv->txbkpringtail = tail;
1922 priv->txbkpbufstail = buflist;
1925 priv->txbepringtail = tail;
1926 priv->txbepbufstail = buflist;
1929 priv->txvipringtail = tail;
1930 priv->txvipbufstail = buflist;
1933 priv->txvopringtail = tail;
1934 priv->txvopbufstail = buflist;
1937 priv->txhpringtail = tail;
1938 priv->txhpbufstail = buflist;
1940 case BEACON_PRIORITY:
1942 * The HW seems to be happy with the 1st
1943 * descriptor filled and the 2nd empty...
1944 * So always update descriptor 1 and never
1950 *temp_tail = *temp_tail | (1<<31); /* descriptor ready to be txed */
1951 rtl8180_dma_kick(dev, priority);
1956 void rtl8180_irq_rx_tasklet(struct r8180_priv *priv);
1958 static void rtl8180_link_change(struct net_device *dev)
1960 struct r8180_priv *priv = ieee80211_priv(dev);
1961 u16 beacon_interval;
1962 struct ieee80211_network *net = &priv->ieee80211->current_network;
1964 rtl8180_update_msr(dev);
1966 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1968 write_nic_dword(dev, BSSID, ((u32 *)net->bssid)[0]);
1969 write_nic_word(dev, BSSID+4, ((u16 *)net->bssid)[2]);
1971 beacon_interval = read_nic_word(dev, BEACON_INTERVAL);
1972 beacon_interval &= ~BEACON_INTERVAL_MASK;
1973 beacon_interval |= net->beacon_interval;
1974 write_nic_word(dev, BEACON_INTERVAL, beacon_interval);
1976 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1978 rtl8180_set_chan(dev, priv->chan);
1981 static void rtl8180_rq_tx_ack(struct net_device *dev)
1984 struct r8180_priv *priv = ieee80211_priv(dev);
1986 write_nic_byte(dev, CONFIG4, read_nic_byte(dev, CONFIG4) | CONFIG4_PWRMGT);
1987 priv->ack_tx_to_ieee = 1;
1990 static short rtl8180_is_tx_queue_empty(struct net_device *dev)
1993 struct r8180_priv *priv = ieee80211_priv(dev);
1996 for (d = priv->txmapring;
1997 d < priv->txmapring + priv->txringcount; d += 8)
2001 for (d = priv->txbkpring;
2002 d < priv->txbkpring + priv->txringcount; d += 8)
2006 for (d = priv->txbepring;
2007 d < priv->txbepring + priv->txringcount; d += 8)
2011 for (d = priv->txvipring;
2012 d < priv->txvipring + priv->txringcount; d += 8)
2016 for (d = priv->txvopring;
2017 d < priv->txvopring + priv->txringcount; d += 8)
2021 for (d = priv->txhpring;
2022 d < priv->txhpring + priv->txringcount; d += 8)
2028 static void rtl8180_hw_wakeup(struct net_device *dev)
2030 unsigned long flags;
2031 struct r8180_priv *priv = ieee80211_priv(dev);
2033 spin_lock_irqsave(&priv->ps_lock, flags);
2034 write_nic_byte(dev, CONFIG4, read_nic_byte(dev, CONFIG4) & ~CONFIG4_PWRMGT);
2035 if (priv->rf_wakeup)
2036 priv->rf_wakeup(dev);
2037 spin_unlock_irqrestore(&priv->ps_lock, flags);
2040 static void rtl8180_hw_sleep_down(struct net_device *dev)
2042 unsigned long flags;
2043 struct r8180_priv *priv = ieee80211_priv(dev);
2045 spin_lock_irqsave(&priv->ps_lock, flags);
2047 priv->rf_sleep(dev);
2048 spin_unlock_irqrestore(&priv->ps_lock, flags);
2051 static void rtl8180_hw_sleep(struct net_device *dev, u32 th, u32 tl)
2053 struct r8180_priv *priv = ieee80211_priv(dev);
2055 unsigned long flags;
2057 spin_lock_irqsave(&priv->ps_lock, flags);
2060 * Writing HW register with 0 equals to disable
2061 * the timer, that is not really what we want
2063 tl -= MSECS(4+16+7);
2066 * If the interval in witch we are requested to sleep is too
2067 * short then give up and remain awake
2069 if (((tl >= rb) && (tl-rb) <= MSECS(MIN_SLEEP_TIME))
2070 || ((rb > tl) && (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
2071 spin_unlock_irqrestore(&priv->ps_lock, flags);
2072 printk("too short to sleep\n");
2077 u32 tmp = (tl > rb) ? (tl-rb) : (rb-tl);
2079 priv->DozePeriodInPast2Sec += jiffies_to_msecs(tmp);
2080 /* as tl may be less than rb */
2081 queue_delayed_work(priv->ieee80211->wq, &priv->ieee80211->hw_wakeup_wq, tmp);
2084 * If we suspect the TimerInt is gone beyond tl
2085 * while setting it, then give up
2088 if (((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME))) ||
2089 ((tl < rb) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))) {
2090 spin_unlock_irqrestore(&priv->ps_lock, flags);
2094 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_sleep_wq);
2095 spin_unlock_irqrestore(&priv->ps_lock, flags);
2098 static void rtl8180_wmm_param_update(struct work_struct *work)
2100 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, wmm_param_update_wq);
2101 struct net_device *dev = ieee->dev;
2102 u8 *ac_param = (u8 *)(ieee->current_network.wmm_param);
2103 u8 mode = ieee->current_network.mode;
2109 if (!ieee->current_network.QoS_Enable) {
2110 /* legacy ac_xx_param update */
2111 AcParam.longData = 0;
2112 AcParam.f.AciAifsn.f.AIFSN = 2; /* Follow 802.11 DIFS. */
2113 AcParam.f.AciAifsn.f.ACM = 0;
2114 AcParam.f.Ecw.f.ECWmin = 3; /* Follow 802.11 CWmin. */
2115 AcParam.f.Ecw.f.ECWmax = 7; /* Follow 802.11 CWmax. */
2116 AcParam.f.TXOPLimit = 0;
2117 for (eACI = 0; eACI < AC_MAX; eACI++) {
2118 AcParam.f.AciAifsn.f.ACI = (u8)eACI;
2122 pAcParam = (PAC_PARAM)(&AcParam);
2123 /* Retrieve parameters to update. */
2124 u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN * (((mode&IEEE_G) == IEEE_G) ? 9 : 20) + aSifsTime;
2125 u4bAcParam = ((((u32)(pAcParam->f.TXOPLimit))<<AC_PARAM_TXOP_LIMIT_OFFSET)|
2126 (((u32)(pAcParam->f.Ecw.f.ECWmax))<<AC_PARAM_ECW_MAX_OFFSET)|
2127 (((u32)(pAcParam->f.Ecw.f.ECWmin))<<AC_PARAM_ECW_MIN_OFFSET)|
2128 (((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
2131 write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
2134 write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
2137 write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
2140 write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
2143 pr_warn("SetHwReg8185():invalid ACI: %d!\n",
2152 for (i = 0; i < AC_MAX; i++) {
2153 /* AcParam.longData = 0; */
2154 pAcParam = (AC_PARAM *)ac_param;
2160 /* Retrieve parameters to update. */
2161 eACI = pAcParam->f.AciAifsn.f.ACI;
2162 /* Mode G/A: slotTimeTimer = 9; Mode B: 20 */
2163 u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN * (((mode&IEEE_G) == IEEE_G) ? 9 : 20) + aSifsTime;
2164 u4bAcParam = ((((u32)(pAcParam->f.TXOPLimit)) << AC_PARAM_TXOP_LIMIT_OFFSET) |
2165 (((u32)(pAcParam->f.Ecw.f.ECWmax)) << AC_PARAM_ECW_MAX_OFFSET) |
2166 (((u32)(pAcParam->f.Ecw.f.ECWmin)) << AC_PARAM_ECW_MIN_OFFSET) |
2167 (((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
2171 write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
2174 write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
2177 write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
2180 write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
2183 pr_warn("SetHwReg8185(): invalid ACI: %d !\n",
2188 ac_param += (sizeof(AC_PARAM));
2192 void rtl8180_restart_wq(struct work_struct *work);
2193 /* void rtl8180_rq_tx_ack(struct work_struct *work); */
2194 void rtl8180_watch_dog_wq(struct work_struct *work);
2195 void rtl8180_hw_wakeup_wq(struct work_struct *work);
2196 void rtl8180_hw_sleep_wq(struct work_struct *work);
2197 void rtl8180_sw_antenna_wq(struct work_struct *work);
2198 void rtl8180_watch_dog(struct net_device *dev);
2200 static void watch_dog_adaptive(unsigned long data)
2202 struct r8180_priv *priv = ieee80211_priv((struct net_device *)data);
2205 DMESG("<----watch_dog_adaptive():driver is not up!\n");
2209 /* Tx High Power Mechanism. */
2210 if (CheckHighPower((struct net_device *)data))
2211 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->tx_pw_wq);
2213 /* Tx Power Tracking on 87SE. */
2214 if (CheckTxPwrTracking((struct net_device *)data))
2215 TxPwrTracking87SE((struct net_device *)data);
2217 /* Perform DIG immediately. */
2218 if (CheckDig((struct net_device *)data))
2219 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_dig_wq);
2220 rtl8180_watch_dog((struct net_device *)data);
2222 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->GPIOChangeRFWorkItem);
2224 priv->watch_dog_timer.expires = jiffies + MSECS(IEEE80211_WATCH_DOG_TIME);
2225 add_timer(&priv->watch_dog_timer);
2228 static CHANNEL_LIST ChannelPlan[] = {
2229 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64},19}, /* FCC */
2230 {{1,2,3,4,5,6,7,8,9,10,11},11}, /* IC */
2231 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, /* ETSI */
2232 {{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. */
2233 {{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. */
2234 {{14,36,40,44,48,52,56,60,64},9}, /* MKK */
2235 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14, 36,40,44,48,52,56,60,64},22},/* MKK1 */
2236 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, /* Israel. */
2237 {{1,2,3,4,5,6,7,8,9,10,11,12,13,34,38,42,46},17}, /* For 11a , TELEC */
2238 {{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 */
2239 {{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 */
2242 static void rtl8180_set_channel_map(u8 channel_plan,
2243 struct ieee80211_device *ieee)
2247 /* lzm add 080826 */
2248 ieee->MinPassiveChnlNum = MAX_CHANNEL_NUMBER+1;
2249 ieee->IbssStartChnl = 0;
2251 switch (channel_plan) {
2252 case COUNTRY_CODE_FCC:
2253 case COUNTRY_CODE_IC:
2254 case COUNTRY_CODE_ETSI:
2255 case COUNTRY_CODE_SPAIN:
2256 case COUNTRY_CODE_FRANCE:
2257 case COUNTRY_CODE_MKK:
2258 case COUNTRY_CODE_MKK1:
2259 case COUNTRY_CODE_ISRAEL:
2260 case COUNTRY_CODE_TELEC:
2263 ieee->bGlobalDomain = false;
2264 if (ChannelPlan[channel_plan].Len != 0) {
2265 /* Clear old channel map */
2266 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
2267 /* Set new channel map */
2268 for (i = 0; i < ChannelPlan[channel_plan].Len; i++) {
2269 if (ChannelPlan[channel_plan].Channel[i] <= 14)
2270 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
2275 case COUNTRY_CODE_GLOBAL_DOMAIN:
2277 GET_DOT11D_INFO(ieee)->bEnabled = false;
2279 ieee->bGlobalDomain = true;
2282 case COUNTRY_CODE_WORLD_WIDE_13_INDEX:/* lzm add 080826 */
2284 ieee->MinPassiveChnlNum = 12;
2285 ieee->IbssStartChnl = 10;
2291 ieee->bGlobalDomain = false;
2292 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
2293 for (i = 1; i <= 14; i++)
2294 GET_DOT11D_INFO(ieee)->channel_map[i] = 1;
2300 void GPIOChangeRFWorkItemCallBack(struct work_struct *work);
2303 static void rtl8180_statistics_init(struct Stats *pstats)
2305 memset(pstats, 0, sizeof(struct Stats));
2308 static void rtl8180_link_detect_init(plink_detect_t plink_detect)
2310 memset(plink_detect, 0, sizeof(link_detect_t));
2311 plink_detect->SlotNum = DEFAULT_SLOT_NUM;
2314 /* YJ,add,080828,end */
2315 static void rtl8187se_eeprom_register_read(struct eeprom_93cx6 *eeprom)
2317 struct net_device *dev = eeprom->data;
2318 u8 reg = read_nic_byte(dev, EPROM_CMD);
2320 eeprom->reg_data_in = reg & RTL818X_EEPROM_CMD_WRITE;
2321 eeprom->reg_data_out = reg & RTL818X_EEPROM_CMD_READ;
2322 eeprom->reg_data_clock = reg & RTL818X_EEPROM_CMD_CK;
2323 eeprom->reg_chip_select = reg & RTL818X_EEPROM_CMD_CS;
2326 static void rtl8187se_eeprom_register_write(struct eeprom_93cx6 *eeprom)
2328 struct net_device *dev = eeprom->data;
2331 if (eeprom->reg_data_in)
2332 reg |= RTL818X_EEPROM_CMD_WRITE;
2333 if (eeprom->reg_data_out)
2334 reg |= RTL818X_EEPROM_CMD_READ;
2335 if (eeprom->reg_data_clock)
2336 reg |= RTL818X_EEPROM_CMD_CK;
2337 if (eeprom->reg_chip_select)
2338 reg |= RTL818X_EEPROM_CMD_CS;
2340 write_nic_byte(dev, EPROM_CMD, reg);
2341 read_nic_byte(dev, EPROM_CMD);
2345 static short rtl8180_init(struct net_device *dev)
2347 struct r8180_priv *priv = ieee80211_priv(dev);
2352 struct eeprom_93cx6 eeprom;
2356 eeprom.register_read = rtl8187se_eeprom_register_read;
2357 eeprom.register_write = rtl8187se_eeprom_register_write;
2358 eeprom.width = PCI_EEPROM_WIDTH_93C46;
2360 eeprom_93cx6_read(&eeprom, EEPROM_COUNTRY_CODE>>1, &eeprom_val);
2361 priv->channel_plan = eeprom_val & 0xFF;
2362 if (priv->channel_plan > COUNTRY_CODE_GLOBAL_DOMAIN) {
2363 printk("rtl8180_init:Error channel plan! Set to default.\n");
2364 priv->channel_plan = 0;
2367 DMESG("Channel plan is %d\n", priv->channel_plan);
2368 rtl8180_set_channel_map(priv->channel_plan, priv->ieee80211);
2370 /* FIXME: these constants are placed in a bad pleace. */
2371 priv->txbuffsize = 2048; /* 1024; */
2372 priv->txringcount = 32; /* 32; */
2373 priv->rxbuffersize = 2048; /* 1024; */
2374 priv->rxringcount = 64; /* 32; */
2375 priv->txbeaconcount = 2;
2376 priv->rx_skb_complete = 1;
2378 priv->RFChangeInProgress = false;
2379 priv->SetRFPowerStateInProgress = false;
2380 priv->RFProgType = 0;
2382 priv->irq_enabled = 0;
2384 rtl8180_statistics_init(&priv->stats);
2385 rtl8180_link_detect_init(&priv->link_detect);
2387 priv->ack_tx_to_ieee = 0;
2388 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2389 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2390 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2391 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2392 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;
2393 priv->ieee80211->active_scan = 1;
2394 priv->ieee80211->rate = 110; /* 11 mbps */
2395 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION;
2396 priv->ieee80211->host_encrypt = 1;
2397 priv->ieee80211->host_decrypt = 1;
2398 priv->ieee80211->sta_wake_up = rtl8180_hw_wakeup;
2399 priv->ieee80211->ps_request_tx_ack = rtl8180_rq_tx_ack;
2400 priv->ieee80211->enter_sleep_state = rtl8180_hw_sleep;
2401 priv->ieee80211->ps_is_queue_empty = rtl8180_is_tx_queue_empty;
2403 priv->hw_wep = hwwep;
2405 priv->retry_rts = DEFAULT_RETRY_RTS;
2406 priv->retry_data = DEFAULT_RETRY_DATA;
2407 priv->RFChangeInProgress = false;
2408 priv->SetRFPowerStateInProgress = false;
2409 priv->RFProgType = 0;
2410 priv->bInactivePs = true; /* false; */
2411 priv->ieee80211->bInactivePs = priv->bInactivePs;
2412 priv->bSwRfProcessing = false;
2413 priv->eRFPowerState = eRfOff;
2414 priv->RfOffReason = 0;
2415 priv->LedStrategy = SW_LED_MODE0;
2416 priv->TxPollingTimes = 0; /* lzm add 080826 */
2417 priv->bLeisurePs = true;
2418 priv->dot11PowerSaveMode = eActive;
2419 priv->AdMinCheckPeriod = 5;
2420 priv->AdMaxCheckPeriod = 10;
2421 priv->AdMaxRxSsThreshold = 30; /* 60->30 */
2422 priv->AdRxSsThreshold = 20; /* 50->20 */
2423 priv->AdCheckPeriod = priv->AdMinCheckPeriod;
2424 priv->AdTickCount = 0;
2425 priv->AdRxSignalStrength = -1;
2426 priv->RegSwAntennaDiversityMechanism = 0;
2427 priv->RegDefaultAntenna = 0;
2428 priv->SignalStrength = 0;
2429 priv->AdRxOkCnt = 0;
2430 priv->CurrAntennaIndex = 0;
2431 priv->AdRxSsBeforeSwitched = 0;
2432 init_timer(&priv->SwAntennaDiversityTimer);
2433 priv->SwAntennaDiversityTimer.data = (unsigned long)dev;
2434 priv->SwAntennaDiversityTimer.function = (void *)SwAntennaDiversityTimerCallback;
2435 priv->bDigMechanism = true;
2436 priv->InitialGain = 6;
2437 priv->bXtalCalibration = false;
2438 priv->XtalCal_Xin = 0;
2439 priv->XtalCal_Xout = 0;
2440 priv->bTxPowerTrack = false;
2441 priv->ThermalMeter = 0;
2442 priv->FalseAlarmRegValue = 0;
2443 priv->RegDigOfdmFaUpTh = 0xc; /* Upper threshold of OFDM false alarm, which is used in DIG. */
2444 priv->DIG_NumberFallbackVote = 0;
2445 priv->DIG_NumberUpgradeVote = 0;
2446 priv->LastSignalStrengthInPercent = 0;
2447 priv->Stats_SignalStrength = 0;
2448 priv->LastRxPktAntenna = 0;
2449 priv->SignalQuality = 0; /* in 0-100 index. */
2450 priv->Stats_SignalQuality = 0;
2451 priv->RecvSignalPower = 0; /* in dBm. */
2452 priv->Stats_RecvSignalPower = 0;
2453 priv->AdMainAntennaRxOkCnt = 0;
2454 priv->AdAuxAntennaRxOkCnt = 0;
2455 priv->bHWAdSwitched = false;
2456 priv->bRegHighPowerMechanism = true;
2457 priv->RegHiPwrUpperTh = 77;
2458 priv->RegHiPwrLowerTh = 75;
2459 priv->RegRSSIHiPwrUpperTh = 70;
2460 priv->RegRSSIHiPwrLowerTh = 20;
2461 priv->bCurCCKPkt = false;
2462 priv->UndecoratedSmoothedSS = -1;
2463 priv->bToUpdateTxPwr = false;
2464 priv->CurCCKRSSI = 0;
2467 priv->NumTxOkTotal = 0;
2468 priv->NumTxUnicast = 0;
2469 priv->keepAliveLevel = DEFAULT_KEEP_ALIVE_LEVEL;
2470 priv->CurrRetryCnt = 0;
2471 priv->LastRetryCnt = 0;
2472 priv->LastTxokCnt = 0;
2473 priv->LastRxokCnt = 0;
2474 priv->LastRetryRate = 0;
2475 priv->bTryuping = 0;
2476 priv->CurrTxRate = 0;
2477 priv->CurrRetryRate = 0;
2478 priv->TryupingCount = 0;
2479 priv->TryupingCountNoData = 0;
2480 priv->TryDownCountLowData = 0;
2481 priv->LastTxOKBytes = 0;
2482 priv->LastFailTxRate = 0;
2483 priv->LastFailTxRateSS = 0;
2484 priv->FailTxRateCount = 0;
2485 priv->LastTxThroughput = 0;
2486 priv->NumTxOkBytesTotal = 0;
2487 priv->ForcedDataRate = 0;
2488 priv->RegBModeGainStage = 1;
2490 priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
2491 spin_lock_init(&priv->irq_th_lock);
2492 spin_lock_init(&priv->tx_lock);
2493 spin_lock_init(&priv->ps_lock);
2494 spin_lock_init(&priv->rf_ps_lock);
2495 sema_init(&priv->wx_sem, 1);
2496 INIT_WORK(&priv->reset_wq, (void *)rtl8180_restart_wq);
2497 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,
2498 (void *)rtl8180_hw_wakeup_wq);
2499 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,
2500 (void *)rtl8180_hw_sleep_wq);
2501 INIT_WORK(&priv->ieee80211->wmm_param_update_wq,
2502 (void *)rtl8180_wmm_param_update);
2503 INIT_DELAYED_WORK(&priv->ieee80211->rate_adapter_wq,
2504 (void *)rtl8180_rate_adapter);
2505 INIT_DELAYED_WORK(&priv->ieee80211->hw_dig_wq,
2506 (void *)rtl8180_hw_dig_wq);
2507 INIT_DELAYED_WORK(&priv->ieee80211->tx_pw_wq,
2508 (void *)rtl8180_tx_pw_wq);
2509 INIT_DELAYED_WORK(&priv->ieee80211->GPIOChangeRFWorkItem,
2510 (void *) GPIOChangeRFWorkItemCallBack);
2511 tasklet_init(&priv->irq_rx_tasklet,
2512 (void(*)(unsigned long)) rtl8180_irq_rx_tasklet,
2513 (unsigned long)priv);
2515 init_timer(&priv->watch_dog_timer);
2516 priv->watch_dog_timer.data = (unsigned long)dev;
2517 priv->watch_dog_timer.function = watch_dog_adaptive;
2519 init_timer(&priv->rateadapter_timer);
2520 priv->rateadapter_timer.data = (unsigned long)dev;
2521 priv->rateadapter_timer.function = timer_rate_adaptive;
2522 priv->RateAdaptivePeriod = RATE_ADAPTIVE_TIMER_PERIOD;
2523 priv->bEnhanceTxPwr = false;
2525 priv->ieee80211->softmac_hard_start_xmit = rtl8180_hard_start_xmit;
2526 priv->ieee80211->set_chan = rtl8180_set_chan;
2527 priv->ieee80211->link_change = rtl8180_link_change;
2528 priv->ieee80211->softmac_data_hard_start_xmit = rtl8180_hard_data_xmit;
2529 priv->ieee80211->data_hard_stop = rtl8180_data_hard_stop;
2530 priv->ieee80211->data_hard_resume = rtl8180_data_hard_resume;
2532 priv->ieee80211->init_wmmparam_flag = 0;
2534 priv->ieee80211->start_send_beacons = rtl8180_start_tx_beacon;
2535 priv->ieee80211->stop_send_beacons = rtl8180_beacon_tx_disable;
2536 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2538 priv->ShortRetryLimit = 7;
2539 priv->LongRetryLimit = 7;
2540 priv->EarlyRxThreshold = 7;
2542 priv->TransmitConfig = (1<<TCR_DurProcMode_OFFSET) |
2543 (7<<TCR_MXDMA_OFFSET) |
2544 (priv->ShortRetryLimit<<TCR_SRL_OFFSET) |
2545 (priv->LongRetryLimit<<TCR_LRL_OFFSET);
2547 priv->ReceiveConfig = RCR_AMF | RCR_ADF | RCR_ACF |
2548 RCR_AB | RCR_AM | RCR_APM |
2549 (7<<RCR_MXDMA_OFFSET) |
2550 (priv->EarlyRxThreshold<<RCR_FIFO_OFFSET) |
2551 (priv->EarlyRxThreshold == 7 ?
2552 RCR_ONLYERLPKT : 0);
2554 priv->IntrMask = IMR_TMGDOK | IMR_TBDER |
2555 IMR_THPDER | IMR_THPDOK |
2556 IMR_TVODER | IMR_TVODOK |
2557 IMR_TVIDER | IMR_TVIDOK |
2558 IMR_TBEDER | IMR_TBEDOK |
2559 IMR_TBKDER | IMR_TBKDOK |
2564 priv->InitialGain = 6;
2566 DMESG("MAC controller is a RTL8187SE b/g");
2568 priv->ieee80211->modulation |= IEEE80211_OFDM_MODULATION;
2569 priv->ieee80211->short_slot = 1;
2571 eeprom_93cx6_read(&eeprom, EEPROM_SW_REVD_OFFSET, &usValue);
2572 DMESG("usValue is %#hx\n", usValue);
2573 /* 3Read AntennaDiversity */
2575 /* SW Antenna Diversity. */
2576 priv->EEPROMSwAntennaDiversity = (usValue & EEPROM_SW_AD_MASK) ==
2577 EEPROM_SW_AD_ENABLE;
2579 /* Default Antenna to use. */
2580 priv->EEPROMDefaultAntenna1 = (usValue & EEPROM_DEF_ANT_MASK) ==
2583 if (priv->RegSwAntennaDiversityMechanism == 0) /* Auto */
2584 /* 0: default from EEPROM. */
2585 priv->bSwAntennaDiverity = priv->EEPROMSwAntennaDiversity;
2587 /* 1:disable antenna diversity, 2: enable antenna diversity. */
2588 priv->bSwAntennaDiverity = priv->RegSwAntennaDiversityMechanism == 2;
2590 if (priv->RegDefaultAntenna == 0)
2591 /* 0: default from EEPROM. */
2592 priv->bDefaultAntenna1 = priv->EEPROMDefaultAntenna1;
2594 /* 1: main, 2: aux. */
2595 priv->bDefaultAntenna1 = priv->RegDefaultAntenna == 2;
2597 priv->plcp_preamble_mode = 2;
2598 /* the eeprom type is stored in RCR register bit #6 */
2599 if (RCR_9356SEL & read_nic_dword(dev, RCR))
2600 priv->epromtype = EPROM_93c56;
2602 priv->epromtype = EPROM_93c46;
2604 eeprom_93cx6_multiread(&eeprom, 0x7, (__le16 *)
2607 for (i = 1, j = 0; i < 14; i += 2, j++) {
2608 eeprom_93cx6_read(&eeprom, EPROM_TXPW_CH1_2 + j, &word);
2609 priv->chtxpwr[i] = word & 0xff;
2610 priv->chtxpwr[i+1] = (word & 0xff00)>>8;
2612 for (i = 1, j = 0; i < 14; i += 2, j++) {
2613 eeprom_93cx6_read(&eeprom, EPROM_TXPW_OFDM_CH1_2 + j, &word);
2614 priv->chtxpwr_ofdm[i] = word & 0xff;
2615 priv->chtxpwr_ofdm[i+1] = (word & 0xff00) >> 8;
2618 /* 3Read crystal calibration and thermal meter indication on 87SE. */
2619 eeprom_93cx6_read(&eeprom, EEPROM_RSV>>1, &tmpu16);
2621 /* Crystal calibration for Xin and Xout resp. */
2622 priv->XtalCal_Xout = tmpu16 & EEPROM_XTAL_CAL_XOUT_MASK;
2623 priv->XtalCal_Xin = (tmpu16 & EEPROM_XTAL_CAL_XIN_MASK) >> 4;
2624 if ((tmpu16 & EEPROM_XTAL_CAL_ENABLE) >> 12)
2625 priv->bXtalCalibration = true;
2627 /* Thermal meter reference indication. */
2628 priv->ThermalMeter = (u8)((tmpu16 & EEPROM_THERMAL_METER_MASK) >> 8);
2629 if ((tmpu16 & EEPROM_THERMAL_METER_ENABLE) >> 13)
2630 priv->bTxPowerTrack = true;
2632 priv->rf_sleep = rtl8225z4_rf_sleep;
2633 priv->rf_wakeup = rtl8225z4_rf_wakeup;
2634 DMESGW("**PLEASE** REPORT SUCCESSFUL/UNSUCCESSFUL TO Realtek!");
2636 priv->rf_close = rtl8225z2_rf_close;
2637 priv->rf_init = rtl8225z2_rf_init;
2638 priv->rf_set_chan = rtl8225z2_rf_set_chan;
2639 priv->rf_set_sens = NULL;
2641 if (0 != alloc_rx_desc_ring(dev, priv->rxbuffersize, priv->rxringcount))
2644 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2645 TX_MANAGEPRIORITY_RING_ADDR))
2648 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2649 TX_BKPRIORITY_RING_ADDR))
2652 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2653 TX_BEPRIORITY_RING_ADDR))
2656 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2657 TX_VIPRIORITY_RING_ADDR))
2660 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2661 TX_VOPRIORITY_RING_ADDR))
2664 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2665 TX_HIGHPRIORITY_RING_ADDR))
2668 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txbeaconcount,
2669 TX_BEACON_RING_ADDR))
2672 if (request_irq(dev->irq, rtl8180_interrupt, IRQF_SHARED, dev->name, dev)) {
2673 DMESGE("Error allocating IRQ %d", dev->irq);
2676 priv->irq = dev->irq;
2677 DMESG("IRQ %d", dev->irq);
2683 void rtl8180_no_hw_wep(struct net_device *dev)
2687 void rtl8180_set_hw_wep(struct net_device *dev)
2689 struct r8180_priv *priv = ieee80211_priv(dev);
2694 pgreg = read_nic_byte(dev, PGSELECT);
2695 write_nic_byte(dev, PGSELECT, pgreg & ~(1<<PGSELECT_PG_SHIFT));
2697 key0_word4 = read_nic_dword(dev, KEY0+4+4+4);
2698 key0_word4 &= ~0xff;
2699 key0_word4 |= priv->key0[3] & 0xff;
2700 write_nic_dword(dev, KEY0, (priv->key0[0]));
2701 write_nic_dword(dev, KEY0+4, (priv->key0[1]));
2702 write_nic_dword(dev, KEY0+4+4, (priv->key0[2]));
2703 write_nic_dword(dev, KEY0+4+4+4, (key0_word4));
2705 security = read_nic_byte(dev, SECURITY);
2706 security |= (1<<SECURITY_WEP_TX_ENABLE_SHIFT);
2707 security |= (1<<SECURITY_WEP_RX_ENABLE_SHIFT);
2708 security &= ~SECURITY_ENCRYP_MASK;
2709 security |= (SECURITY_ENCRYP_104<<SECURITY_ENCRYP_SHIFT);
2711 write_nic_byte(dev, SECURITY, security);
2713 DMESG("key %x %x %x %x", read_nic_dword(dev, KEY0+4+4+4),
2714 read_nic_dword(dev, KEY0+4+4), read_nic_dword(dev, KEY0+4),
2715 read_nic_dword(dev, KEY0));
2719 void rtl8185_rf_pins_enable(struct net_device *dev)
2722 /* tmp = read_nic_word(dev, RFPinsEnable); */
2723 write_nic_word(dev, RFPinsEnable, 0x1fff); /* | tmp); */
2726 void rtl8185_set_anaparam2(struct net_device *dev, u32 a)
2730 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
2732 conf3 = read_nic_byte(dev, CONFIG3);
2733 write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
2734 write_nic_dword(dev, ANAPARAM2, a);
2736 conf3 = read_nic_byte(dev, CONFIG3);
2737 write_nic_byte(dev, CONFIG3, conf3 & ~(1<<CONFIG3_ANAPARAM_W_SHIFT));
2738 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
2741 void rtl8180_set_anaparam(struct net_device *dev, u32 a)
2745 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
2747 conf3 = read_nic_byte(dev, CONFIG3);
2748 write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
2749 write_nic_dword(dev, ANAPARAM, a);
2751 conf3 = read_nic_byte(dev, CONFIG3);
2752 write_nic_byte(dev, CONFIG3, conf3 & ~(1<<CONFIG3_ANAPARAM_W_SHIFT));
2753 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
2756 void rtl8185_tx_antenna(struct net_device *dev, u8 ant)
2758 write_nic_byte(dev, TX_ANTENNA, ant);
2759 force_pci_posting(dev);
2763 static void rtl8185_write_phy(struct net_device *dev, u8 adr, u32 data)
2769 phyw = ((data<<8) | adr);
2771 /* Note that, we must write 0xff7c after 0x7d-0x7f to write BB register. */
2772 write_nic_byte(dev, 0x7f, ((phyw & 0xff000000) >> 24));
2773 write_nic_byte(dev, 0x7e, ((phyw & 0x00ff0000) >> 16));
2774 write_nic_byte(dev, 0x7d, ((phyw & 0x0000ff00) >> 8));
2775 write_nic_byte(dev, 0x7c, ((phyw & 0x000000ff)));
2777 /* this is ok to fail when we write AGC table. check for AGC table might be
2778 * done by masking with 0x7f instead of 0xff
2780 /* if (phyr != (data&0xff)) DMESGW("Phy write timeout %x %x %x", phyr, data, adr); */
2783 inline void write_phy_ofdm(struct net_device *dev, u8 adr, u32 data)
2786 rtl8185_write_phy(dev, adr, data);
2789 void write_phy_cck(struct net_device *dev, u8 adr, u32 data)
2792 rtl8185_write_phy(dev, adr, data | 0x10000);
2796 * This configures registers for beacon tx and enables it via
2797 * rtl8180_beacon_tx_enable(). rtl8180_beacon_tx_disable() might
2798 * be used to stop beacon transmission
2800 void rtl8180_start_tx_beacon(struct net_device *dev)
2804 DMESG("Enabling beacon TX");
2805 rtl8180_prepare_beacon(dev);
2806 rtl8180_irq_disable(dev);
2807 rtl8180_beacon_tx_enable(dev);
2809 word = read_nic_word(dev, AtimWnd) & ~AtimWnd_AtimWnd;
2810 write_nic_word(dev, AtimWnd, word); /* word |= */
2812 word = read_nic_word(dev, BintrItv);
2813 word &= ~BintrItv_BintrItv;
2814 word |= 1000; /* priv->ieee80211->current_network.beacon_interval *
2815 ((priv->txbeaconcount > 1)?(priv->txbeaconcount-1):1);
2816 // FIXME: check if correct ^^ worked with 0x3e8;
2818 write_nic_word(dev, BintrItv, word);
2820 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
2822 rtl8185b_irq_enable(dev);
2825 static struct net_device_stats *rtl8180_stats(struct net_device *dev)
2827 struct r8180_priv *priv = ieee80211_priv(dev);
2829 return &priv->ieee80211->stats;
2833 * Change current and default preamble mode.
2835 static bool MgntActSet_802_11_PowerSaveMode(struct r8180_priv *priv,
2836 RT_PS_MODE rtPsMode)
2838 /* Currently, we do not change power save mode on IBSS mode. */
2839 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
2842 priv->ieee80211->ps = rtPsMode;
2847 static void LeisurePSEnter(struct r8180_priv *priv)
2849 if (priv->bLeisurePs) {
2850 if (priv->ieee80211->ps == IEEE80211_PS_DISABLED)
2851 /* IEEE80211_PS_ENABLE */
2852 MgntActSet_802_11_PowerSaveMode(priv, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST);
2856 static void LeisurePSLeave(struct r8180_priv *priv)
2858 if (priv->bLeisurePs) {
2859 if (priv->ieee80211->ps != IEEE80211_PS_DISABLED)
2860 MgntActSet_802_11_PowerSaveMode(priv, IEEE80211_PS_DISABLED);
2864 void rtl8180_hw_wakeup_wq(struct work_struct *work)
2866 struct delayed_work *dwork = to_delayed_work(work);
2867 struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, hw_wakeup_wq);
2868 struct net_device *dev = ieee->dev;
2870 rtl8180_hw_wakeup(dev);
2873 void rtl8180_hw_sleep_wq(struct work_struct *work)
2875 struct delayed_work *dwork = to_delayed_work(work);
2876 struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, hw_sleep_wq);
2877 struct net_device *dev = ieee->dev;
2879 rtl8180_hw_sleep_down(dev);
2882 static void MgntLinkKeepAlive(struct r8180_priv *priv)
2884 if (priv->keepAliveLevel == 0)
2887 if (priv->ieee80211->state == IEEE80211_LINKED) {
2892 if ((priv->keepAliveLevel == 2) ||
2893 (priv->link_detect.LastNumTxUnicast == priv->NumTxUnicast &&
2894 priv->link_detect.LastNumRxUnicast == priv->ieee80211->NumRxUnicast)
2896 priv->link_detect.IdleCount++;
2899 * Send a Keep-Alive packet packet to AP if we had been idle for a while.
2901 if (priv->link_detect.IdleCount >= ((KEEP_ALIVE_INTERVAL / CHECK_FOR_HANG_PERIOD)-1)) {
2902 priv->link_detect.IdleCount = 0;
2903 ieee80211_sta_ps_send_null_frame(priv->ieee80211, false);
2906 priv->link_detect.IdleCount = 0;
2908 priv->link_detect.LastNumTxUnicast = priv->NumTxUnicast;
2909 priv->link_detect.LastNumRxUnicast = priv->ieee80211->NumRxUnicast;
2913 void rtl8180_watch_dog(struct net_device *dev)
2915 struct r8180_priv *priv = ieee80211_priv(dev);
2916 bool bEnterPS = false;
2917 bool bBusyTraffic = false;
2921 if (priv->ieee80211->actscanning == false) {
2922 if ((priv->ieee80211->iw_mode != IW_MODE_ADHOC) &&
2923 (priv->ieee80211->state == IEEE80211_NOLINK) &&
2924 (priv->ieee80211->beinretry == false) &&
2925 (priv->eRFPowerState == eRfOn))
2928 /* YJ,add,080828,for link state check */
2929 if ((priv->ieee80211->state == IEEE80211_LINKED) && (priv->ieee80211->iw_mode == IW_MODE_INFRA)) {
2930 SlotIndex = (priv->link_detect.SlotIndex++) % priv->link_detect.SlotNum;
2931 priv->link_detect.RxFrameNum[SlotIndex] = priv->ieee80211->NumRxDataInPeriod + priv->ieee80211->NumRxBcnInPeriod;
2932 for (i = 0; i < priv->link_detect.SlotNum; i++)
2933 TotalRxNum += priv->link_detect.RxFrameNum[i];
2935 if (TotalRxNum == 0) {
2936 priv->ieee80211->state = IEEE80211_ASSOCIATING;
2937 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
2941 /* YJ,add,080828,for KeepAlive */
2942 MgntLinkKeepAlive(priv);
2944 /* YJ,add,080828,for LPS */
2945 LeisurePSLeave(priv);
2947 if (priv->ieee80211->state == IEEE80211_LINKED) {
2948 priv->link_detect.NumRxOkInPeriod = priv->ieee80211->NumRxDataInPeriod;
2949 if (priv->link_detect.NumRxOkInPeriod > 666 ||
2950 priv->link_detect.NumTxOkInPeriod > 666) {
2951 bBusyTraffic = true;
2953 if (((priv->link_detect.NumRxOkInPeriod + priv->link_detect.NumTxOkInPeriod) > 8)
2954 || (priv->link_detect.NumRxOkInPeriod > 2)) {
2960 LeisurePSEnter(priv);
2962 LeisurePSLeave(priv);
2964 LeisurePSLeave(priv);
2965 priv->link_detect.bBusyTraffic = bBusyTraffic;
2966 priv->link_detect.NumRxOkInPeriod = 0;
2967 priv->link_detect.NumTxOkInPeriod = 0;
2968 priv->ieee80211->NumRxDataInPeriod = 0;
2969 priv->ieee80211->NumRxBcnInPeriod = 0;
2972 static int _rtl8180_up(struct net_device *dev)
2974 struct r8180_priv *priv = ieee80211_priv(dev);
2978 DMESG("Bringing up iface");
2979 rtl8185b_adapter_start(dev);
2980 rtl8185b_rx_enable(dev);
2981 rtl8185b_tx_enable(dev);
2982 if (priv->bInactivePs) {
2983 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
2986 timer_rate_adaptive((unsigned long)dev);
2987 watch_dog_adaptive((unsigned long)dev);
2988 if (priv->bSwAntennaDiverity)
2989 SwAntennaDiversityTimerCallback(dev);
2990 ieee80211_softmac_start_protocol(priv->ieee80211);
2994 static int rtl8180_open(struct net_device *dev)
2996 struct r8180_priv *priv = ieee80211_priv(dev);
2999 down(&priv->wx_sem);
3000 ret = rtl8180_up(dev);
3005 int rtl8180_up(struct net_device *dev)
3007 struct r8180_priv *priv = ieee80211_priv(dev);
3012 return _rtl8180_up(dev);
3015 static int rtl8180_close(struct net_device *dev)
3017 struct r8180_priv *priv = ieee80211_priv(dev);
3020 down(&priv->wx_sem);
3021 ret = rtl8180_down(dev);
3027 int rtl8180_down(struct net_device *dev)
3029 struct r8180_priv *priv = ieee80211_priv(dev);
3036 ieee80211_softmac_stop_protocol(priv->ieee80211);
3038 if (!netif_queue_stopped(dev))
3039 netif_stop_queue(dev);
3040 rtl8180_rtx_disable(dev);
3041 rtl8180_irq_disable(dev);
3042 del_timer_sync(&priv->watch_dog_timer);
3043 del_timer_sync(&priv->rateadapter_timer);
3044 cancel_delayed_work(&priv->ieee80211->rate_adapter_wq);
3045 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
3046 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
3047 cancel_delayed_work(&priv->ieee80211->hw_dig_wq);
3048 cancel_delayed_work(&priv->ieee80211->tx_pw_wq);
3049 del_timer_sync(&priv->SwAntennaDiversityTimer);
3050 SetZebraRFPowerState8185(dev, eRfOff);
3051 memset(&(priv->ieee80211->current_network), 0, sizeof(struct ieee80211_network));
3052 priv->ieee80211->state = IEEE80211_NOLINK;
3056 void rtl8180_restart_wq(struct work_struct *work)
3058 struct r8180_priv *priv = container_of(work, struct r8180_priv, reset_wq);
3059 struct net_device *dev = priv->dev;
3061 down(&priv->wx_sem);
3063 rtl8180_commit(dev);
3068 static void rtl8180_restart(struct net_device *dev)
3070 struct r8180_priv *priv = ieee80211_priv(dev);
3072 schedule_work(&priv->reset_wq);
3075 void rtl8180_commit(struct net_device *dev)
3077 struct r8180_priv *priv = ieee80211_priv(dev);
3082 del_timer_sync(&priv->watch_dog_timer);
3083 del_timer_sync(&priv->rateadapter_timer);
3084 cancel_delayed_work(&priv->ieee80211->rate_adapter_wq);
3085 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
3086 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
3087 cancel_delayed_work(&priv->ieee80211->hw_dig_wq);
3088 cancel_delayed_work(&priv->ieee80211->tx_pw_wq);
3089 del_timer_sync(&priv->SwAntennaDiversityTimer);
3090 ieee80211_softmac_stop_protocol(priv->ieee80211);
3091 rtl8180_irq_disable(dev);
3092 rtl8180_rtx_disable(dev);
3096 static void r8180_set_multicast(struct net_device *dev)
3098 struct r8180_priv *priv = ieee80211_priv(dev);
3101 promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
3103 if (promisc != priv->promisc)
3104 rtl8180_restart(dev);
3106 priv->promisc = promisc;
3109 static int r8180_set_mac_adr(struct net_device *dev, void *mac)
3111 struct r8180_priv *priv = ieee80211_priv(dev);
3112 struct sockaddr *addr = mac;
3114 down(&priv->wx_sem);
3116 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
3118 if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
3119 memcpy(priv->ieee80211->current_network.bssid, dev->dev_addr, ETH_ALEN);
3131 /* based on ipw2200 driver */
3132 static int rtl8180_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3134 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3135 struct iwreq *wrq = (struct iwreq *) rq;
3139 case RTL_IOCTL_WPA_SUPPLICANT:
3140 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
3149 static const struct net_device_ops rtl8180_netdev_ops = {
3150 .ndo_open = rtl8180_open,
3151 .ndo_stop = rtl8180_close,
3152 .ndo_get_stats = rtl8180_stats,
3153 .ndo_tx_timeout = rtl8180_restart,
3154 .ndo_do_ioctl = rtl8180_ioctl,
3155 .ndo_set_rx_mode = r8180_set_multicast,
3156 .ndo_set_mac_address = r8180_set_mac_adr,
3157 .ndo_validate_addr = eth_validate_addr,
3158 .ndo_change_mtu = eth_change_mtu,
3159 .ndo_start_xmit = ieee80211_rtl_xmit,
3162 static int rtl8180_pci_probe(struct pci_dev *pdev,
3163 const struct pci_device_id *id)
3165 unsigned long ioaddr = 0;
3166 struct net_device *dev = NULL;
3167 struct r8180_priv *priv = NULL;
3171 unsigned long pmem_start, pmem_len, pmem_flags;
3173 DMESG("Configuring chip resources");
3175 if (pci_enable_device(pdev)) {
3176 DMESG("Failed to enable PCI device");
3180 pci_set_master(pdev);
3181 pci_set_dma_mask(pdev, 0xffffff00ULL);
3182 pci_set_consistent_dma_mask(pdev, 0xffffff00ULL);
3183 dev = alloc_ieee80211(sizeof(struct r8180_priv));
3188 priv = ieee80211_priv(dev);
3189 priv->ieee80211 = netdev_priv(dev);
3191 pci_set_drvdata(pdev, dev);
3192 SET_NETDEV_DEV(dev, &pdev->dev);
3194 priv = ieee80211_priv(dev);
3197 pmem_start = pci_resource_start(pdev, 1);
3198 pmem_len = pci_resource_len(pdev, 1);
3199 pmem_flags = pci_resource_flags(pdev, 1);
3201 if (!(pmem_flags & IORESOURCE_MEM)) {
3202 DMESG("region #1 not a MMIO resource, aborting");
3206 if (!request_mem_region(pmem_start, pmem_len, RTL8180_MODULE_NAME)) {
3207 DMESG("request_mem_region failed!");
3211 ioaddr = (unsigned long)ioremap_nocache(pmem_start, pmem_len);
3212 if (ioaddr == (unsigned long)NULL) {
3213 DMESG("ioremap failed!");
3217 dev->mem_start = ioaddr; /* shared mem start */
3218 dev->mem_end = ioaddr + pci_resource_len(pdev, 0); /* shared mem end */
3220 pci_read_config_byte(pdev, 0x05, &unit);
3221 pci_write_config_byte(pdev, 0x05, unit & (~0x04));
3223 dev->irq = pdev->irq;
3226 dev->netdev_ops = &rtl8180_netdev_ops;
3227 dev->wireless_handlers = &r8180_wx_handlers_def;
3229 dev->type = ARPHRD_ETHER;
3230 dev->watchdog_timeo = HZ*3;
3232 if (dev_alloc_name(dev, ifname) < 0) {
3233 DMESG("Oops: devname already taken! Trying wlan%%d...\n");
3234 strcpy(ifname, "wlan%d");
3235 dev_alloc_name(dev, ifname);
3238 if (rtl8180_init(dev) != 0) {
3239 DMESG("Initialization failed");
3243 netif_carrier_off(dev);
3245 if (register_netdev(dev))
3248 rtl8180_proc_init_one(dev);
3250 DMESG("Driver probe completed\n");
3253 if (dev->mem_start != (unsigned long)NULL) {
3254 iounmap((void __iomem *)dev->mem_start);
3255 release_mem_region(pci_resource_start(pdev, 1),
3256 pci_resource_len(pdev, 1));
3261 free_irq(dev->irq, dev);
3264 free_ieee80211(dev);
3268 pci_disable_device(pdev);
3270 DMESG("wlan driver load failed\n");
3274 static void rtl8180_pci_remove(struct pci_dev *pdev)
3276 struct r8180_priv *priv;
3277 struct net_device *dev = pci_get_drvdata(pdev);
3280 unregister_netdev(dev);
3282 priv = ieee80211_priv(dev);
3284 rtl8180_proc_remove_one(dev);
3286 priv->rf_close(dev);
3291 DMESG("Freeing irq %d", dev->irq);
3292 free_irq(dev->irq, dev);
3296 free_rx_desc_ring(dev);
3297 free_tx_desc_rings(dev);
3299 if (dev->mem_start != (unsigned long)NULL) {
3300 iounmap((void __iomem *)dev->mem_start);
3301 release_mem_region(pci_resource_start(pdev, 1),
3302 pci_resource_len(pdev, 1));
3305 free_ieee80211(dev);
3307 pci_disable_device(pdev);
3309 DMESG("wlan driver removed\n");
3312 static int __init rtl8180_pci_module_init(void)
3316 ret = ieee80211_crypto_init();
3318 pr_err("ieee80211_crypto_init() failed %d\n", ret);
3321 ret = ieee80211_crypto_tkip_init();
3323 pr_err("ieee80211_crypto_tkip_init() failed %d\n", ret);
3326 ret = ieee80211_crypto_ccmp_init();
3328 pr_err("ieee80211_crypto_ccmp_init() failed %d\n", ret);
3331 ret = ieee80211_crypto_wep_init();
3333 pr_err("ieee80211_crypto_wep_init() failed %d\n", ret);
3337 pr_info("\nLinux kernel driver for RTL8180 / RTL8185 based WLAN cards\n");
3338 pr_info("Copyright (c) 2004-2005, Andrea Merello\n");
3339 DMESG("Initializing module");
3340 DMESG("Wireless extensions version %d", WIRELESS_EXT);
3341 rtl8180_proc_module_init();
3343 if (pci_register_driver(&rtl8180_pci_driver)) {
3344 DMESG("No device found");
3350 static void __exit rtl8180_pci_module_exit(void)
3352 pci_unregister_driver(&rtl8180_pci_driver);
3353 rtl8180_proc_module_remove();
3354 ieee80211_crypto_tkip_exit();
3355 ieee80211_crypto_ccmp_exit();
3356 ieee80211_crypto_wep_exit();
3357 ieee80211_crypto_deinit();
3361 static void rtl8180_try_wake_queue(struct net_device *dev, int pri)
3363 unsigned long flags;
3365 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3367 spin_lock_irqsave(&priv->tx_lock, flags);
3368 enough_desc = check_nic_enought_desc(dev, pri);
3369 spin_unlock_irqrestore(&priv->tx_lock, flags);
3372 ieee80211_rtl_wake_queue(priv->ieee80211);
3375 static void rtl8180_tx_isr(struct net_device *dev, int pri, short error)
3377 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3378 u32 *tail; /* tail virtual addr */
3379 u32 *head; /* head virtual addr */
3380 u32 *begin; /* start of ring virtual addr */
3381 u32 *nicv; /* nic pointer virtual addr */
3382 u32 nic; /* nic pointer physical addr */
3383 u32 nicbegin; /* start of ring physical addr */
3385 /* physical addr are ok on 32 bits since we set DMA mask */
3390 priv->stats.txretry++; /* tony 20060601 */
3391 spin_lock_irqsave(&priv->tx_lock, flag);
3393 case MANAGE_PRIORITY:
3394 tail = priv->txmapringtail;
3395 begin = priv->txmapring;
3396 head = priv->txmapringhead;
3397 nic = read_nic_dword(dev, TX_MANAGEPRIORITY_RING_ADDR);
3398 nicbegin = priv->txmapringdma;
3401 tail = priv->txbkpringtail;
3402 begin = priv->txbkpring;
3403 head = priv->txbkpringhead;
3404 nic = read_nic_dword(dev, TX_BKPRIORITY_RING_ADDR);
3405 nicbegin = priv->txbkpringdma;
3408 tail = priv->txbepringtail;
3409 begin = priv->txbepring;
3410 head = priv->txbepringhead;
3411 nic = read_nic_dword(dev, TX_BEPRIORITY_RING_ADDR);
3412 nicbegin = priv->txbepringdma;
3415 tail = priv->txvipringtail;
3416 begin = priv->txvipring;
3417 head = priv->txvipringhead;
3418 nic = read_nic_dword(dev, TX_VIPRIORITY_RING_ADDR);
3419 nicbegin = priv->txvipringdma;
3422 tail = priv->txvopringtail;
3423 begin = priv->txvopring;
3424 head = priv->txvopringhead;
3425 nic = read_nic_dword(dev, TX_VOPRIORITY_RING_ADDR);
3426 nicbegin = priv->txvopringdma;
3429 tail = priv->txhpringtail;
3430 begin = priv->txhpring;
3431 head = priv->txhpringhead;
3432 nic = read_nic_dword(dev, TX_HIGHPRIORITY_RING_ADDR);
3433 nicbegin = priv->txhpringdma;
3437 spin_unlock_irqrestore(&priv->tx_lock, flag);
3441 nicv = (u32 *)((nic - nicbegin) + (u8 *)begin);
3442 if ((head <= tail && (nicv > tail || nicv < head)) ||
3443 (head > tail && (nicv > tail && nicv < head))) {
3444 DMESGW("nic has lost pointer");
3445 spin_unlock_irqrestore(&priv->tx_lock, flag);
3446 rtl8180_restart(dev);
3451 * We check all the descriptors between the head and the nic,
3452 * but not the currently pointed by the nic (the next to be txed)
3453 * and the previous of the pointed (might be in process ??)
3455 offs = (nic - nicbegin);
3456 offs = offs / 8 / 4;
3457 hd = (head - begin) / 8;
3462 j = offs + (priv->txringcount-1-hd);
3468 for (i = 0; i < j; i++) {
3469 if ((*head) & (1<<31))
3471 if (((*head)&(0x10000000)) != 0) {
3472 priv->CurrRetryCnt += (u16)((*head) & (0x000000ff));
3474 priv->NumTxOkTotal++;
3478 priv->NumTxOkBytesTotal += (*(head+3)) & (0x00000fff);
3480 *head = *head & ~(1<<31);
3482 if ((head - begin)/8 == priv->txringcount-1)
3489 * The head has been moved to the last certainly TXed
3490 * (or at least processed by the nic) packet.
3491 * The driver take forcefully owning of all these packets
3492 * If the packet previous of the nic pointer has been
3493 * processed this doesn't matter: it will be checked
3494 * here at the next round. Anyway if no more packet are
3495 * TXed no memory leak occur at all.
3499 case MANAGE_PRIORITY:
3500 priv->txmapringhead = head;
3502 if (priv->ack_tx_to_ieee) {
3503 if (rtl8180_is_tx_queue_empty(dev)) {
3504 priv->ack_tx_to_ieee = 0;
3505 ieee80211_ps_tx_ack(priv->ieee80211, !error);
3510 priv->txbkpringhead = head;
3513 priv->txbepringhead = head;
3516 priv->txvipringhead = head;
3519 priv->txvopringhead = head;
3522 priv->txhpringhead = head;
3526 spin_unlock_irqrestore(&priv->tx_lock, flag);
3529 static irqreturn_t rtl8180_interrupt(int irq, void *netdev)
3531 struct net_device *dev = (struct net_device *) netdev;
3532 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3533 unsigned long flags;
3536 /* We should return IRQ_NONE, but for now let me keep this */
3537 if (priv->irq_enabled == 0)
3540 spin_lock_irqsave(&priv->irq_th_lock, flags);
3543 inta = read_nic_dword(dev, ISR); /* & priv->IntrMask; */
3544 write_nic_dword(dev, ISR, inta); /* reset int situation */
3546 priv->stats.shints++;
3549 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3552 * most probably we can safely return IRQ_NONE,
3553 * but for now is better to avoid problems
3557 if (inta == 0xffff) {
3558 /* HW disappeared */
3559 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3565 if (!netif_running(dev)) {
3566 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3570 if (inta & ISR_TimeOut)
3571 write_nic_dword(dev, TimerInt, 0);
3573 if (inta & ISR_TBDOK)
3574 priv->stats.txbeacon++;
3576 if (inta & ISR_TBDER)
3577 priv->stats.txbeaconerr++;
3579 if (inta & IMR_TMGDOK)
3580 rtl8180_tx_isr(dev, MANAGE_PRIORITY, 0);
3582 if (inta & ISR_THPDER) {
3583 priv->stats.txhperr++;
3584 rtl8180_tx_isr(dev, HI_PRIORITY, 1);
3585 priv->ieee80211->stats.tx_errors++;
3588 if (inta & ISR_THPDOK) { /* High priority tx ok */
3589 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3590 priv->stats.txhpokint++;
3591 rtl8180_tx_isr(dev, HI_PRIORITY, 0);
3595 priv->stats.rxerr++;
3597 if (inta & ISR_TBKDER) { /* corresponding to BK_PRIORITY */
3598 priv->stats.txbkperr++;
3599 priv->ieee80211->stats.tx_errors++;
3600 rtl8180_tx_isr(dev, BK_PRIORITY, 1);
3601 rtl8180_try_wake_queue(dev, BK_PRIORITY);
3604 if (inta & ISR_TBEDER) { /* corresponding to BE_PRIORITY */
3605 priv->stats.txbeperr++;
3606 priv->ieee80211->stats.tx_errors++;
3607 rtl8180_tx_isr(dev, BE_PRIORITY, 1);
3608 rtl8180_try_wake_queue(dev, BE_PRIORITY);
3610 if (inta & ISR_TNPDER) { /* corresponding to VO_PRIORITY */
3611 priv->stats.txnperr++;
3612 priv->ieee80211->stats.tx_errors++;
3613 rtl8180_tx_isr(dev, NORM_PRIORITY, 1);
3614 rtl8180_try_wake_queue(dev, NORM_PRIORITY);
3617 if (inta & ISR_TLPDER) { /* corresponding to VI_PRIORITY */
3618 priv->stats.txlperr++;
3619 priv->ieee80211->stats.tx_errors++;
3620 rtl8180_tx_isr(dev, LOW_PRIORITY, 1);
3621 rtl8180_try_wake_queue(dev, LOW_PRIORITY);
3624 if (inta & ISR_ROK) {
3625 priv->stats.rxint++;
3626 tasklet_schedule(&priv->irq_rx_tasklet);
3629 if (inta & ISR_RQoSOK) {
3630 priv->stats.rxint++;
3631 tasklet_schedule(&priv->irq_rx_tasklet);
3634 if (inta & ISR_BcnInt)
3635 rtl8180_prepare_beacon(dev);
3637 if (inta & ISR_RDU) {
3638 DMESGW("No RX descriptor available");
3639 priv->stats.rxrdu++;
3640 tasklet_schedule(&priv->irq_rx_tasklet);
3643 if (inta & ISR_RXFOVW) {
3644 priv->stats.rxoverflow++;
3645 tasklet_schedule(&priv->irq_rx_tasklet);
3648 if (inta & ISR_TXFOVW)
3649 priv->stats.txoverflow++;
3651 if (inta & ISR_TNPDOK) { /* Normal priority tx ok */
3652 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3653 priv->stats.txnpokint++;
3654 rtl8180_tx_isr(dev, NORM_PRIORITY, 0);
3655 rtl8180_try_wake_queue(dev, NORM_PRIORITY);
3658 if (inta & ISR_TLPDOK) { /* Low priority tx ok */
3659 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3660 priv->stats.txlpokint++;
3661 rtl8180_tx_isr(dev, LOW_PRIORITY, 0);
3662 rtl8180_try_wake_queue(dev, LOW_PRIORITY);
3665 if (inta & ISR_TBKDOK) { /* corresponding to BK_PRIORITY */
3666 priv->stats.txbkpokint++;
3667 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3668 rtl8180_tx_isr(dev, BK_PRIORITY, 0);
3669 rtl8180_try_wake_queue(dev, BE_PRIORITY);
3672 if (inta & ISR_TBEDOK) { /* corresponding to BE_PRIORITY */
3673 priv->stats.txbeperr++;
3674 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3675 rtl8180_tx_isr(dev, BE_PRIORITY, 0);
3676 rtl8180_try_wake_queue(dev, BE_PRIORITY);
3678 force_pci_posting(dev);
3679 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3684 void rtl8180_irq_rx_tasklet(struct r8180_priv *priv)
3686 rtl8180_rx(priv->dev);
3689 void GPIOChangeRFWorkItemCallBack(struct work_struct *work)
3691 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, GPIOChangeRFWorkItem.work);
3692 struct net_device *dev = ieee->dev;
3693 struct r8180_priv *priv = ieee80211_priv(dev);
3696 RT_RF_POWER_STATE eRfPowerStateToSet;
3697 bool bActuallySet = false;
3700 static char *RadioPowerPath = "/etc/acpi/events/RadioPower.sh";
3701 static char *envp[] = {"HOME=/", "TERM=linux", "PATH=/usr/bin:/bin", NULL};
3702 static int readf_count;
3704 readf_count = (readf_count+1)%0xffff;
3705 /* We should turn off LED before polling FF51[4]. */
3708 btPSR = read_nic_byte(dev, PSR);
3709 write_nic_byte(dev, PSR, (btPSR & ~BIT3));
3711 /* It need to delay 4us suggested by Jong, 2008-01-16 */
3714 /* HW radio On/Off according to the value of FF51[4](config0) */
3715 btConfig0 = btPSR = read_nic_byte(dev, CONFIG0);
3717 eRfPowerStateToSet = (btConfig0 & BIT4) ? eRfOn : eRfOff;
3719 /* Turn LED back on when radio enabled */
3720 if (eRfPowerStateToSet == eRfOn)
3721 write_nic_byte(dev, PSR, btPSR | BIT3);
3723 if ((priv->ieee80211->bHwRadioOff == true) &&
3724 (eRfPowerStateToSet == eRfOn)) {
3725 priv->ieee80211->bHwRadioOff = false;
3726 bActuallySet = true;
3727 } else if ((priv->ieee80211->bHwRadioOff == false) &&
3728 (eRfPowerStateToSet == eRfOff)) {
3729 priv->ieee80211->bHwRadioOff = true;
3730 bActuallySet = true;
3734 MgntActSet_RF_State(dev, eRfPowerStateToSet, RF_CHANGE_BY_HW);
3736 /* To update the UI status for Power status changed */
3737 if (priv->ieee80211->bHwRadioOff == true)
3741 argv[0] = RadioPowerPath;
3744 call_usermodehelper(RadioPowerPath, argv, envp, UMH_WAIT_PROC);
3748 module_init(rtl8180_pci_module_init);
3749 module_exit(rtl8180_pci_module_exit);