2 This is part of rtl818x pci OpenSource driver - v 0.1
3 Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it>
4 Released under the terms of GPL (General Public License)
6 Parts of this driver are based on the GPL part of the official
9 Parts of this driver are based on the rtl8180 driver skeleton
10 from Patric Schenke & Andres Salomon.
12 Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver.
14 Parts of BB/RF code are derived from David Young rtl8180 netbsd driver.
16 RSSI calc function from 'The Deuce'
18 Some ideas borrowed from the 8139too.c driver included in linux kernel.
20 We (I?) want to thanks the Authors of those projecs and also the
21 Ndiswrapper's project Authors.
23 A big big thanks goes also to Realtek corp. for their help in my attempt to
24 add RTL8185 and RTL8225 support, and to David Young also.
26 Power management interface routines.
27 Written by Mariusz Matuszek.
30 #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 <andreamrl@tiscali.it>");
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 *)dev->mem_start + x);
166 u32 read_nic_dword(struct net_device *dev, int x)
168 return readl((u8 *)dev->mem_start + x);
171 u16 read_nic_word(struct net_device *dev, int x)
173 return readw((u8 *)dev->mem_start + x);
176 void write_nic_byte(struct net_device *dev, int x, u8 y)
178 writeb(y, (u8 *)dev->mem_start + x);
182 void write_nic_dword(struct net_device *dev, int x, u32 y)
184 writel(y, (u8 *)dev->mem_start + x);
188 void write_nic_word(struct net_device *dev, int x, u16 y)
190 writew(y, (u8 *)dev->mem_start + x);
194 inline void force_pci_posting(struct net_device *dev)
196 read_nic_byte(dev, EPROM_CMD);
200 irqreturn_t rtl8180_interrupt(int irq, void *netdev, struct pt_regs *regs);
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 void rtl8180_proc_module_init(void)
280 DMESG("Initializing proc filesystem");
281 rtl8180_proc = proc_mkdir(RTL8180_MODULE_NAME, init_net.proc_net);
284 void rtl8180_proc_module_remove(void)
286 remove_proc_entry(RTL8180_MODULE_NAME, init_net.proc_net);
289 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 = PDE(inode)->parent->data;
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 = seq_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 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 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 void buffer_free(struct net_device *dev, struct buffer **buffer, int len, short consistent)
393 struct buffer *tmp, *next;
394 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
395 struct pci_dev *pdev = priv->pdev;
405 pci_free_consistent(pdev, len,
408 pci_unmap_single(pdev, tmp->dma,
409 len, PCI_DMA_FROMDEVICE);
414 } while (next != *buffer);
419 int get_curr_tx_free_desc(struct net_device *dev, int priority)
421 struct r8180_priv *priv = ieee80211_priv(dev);
427 case MANAGE_PRIORITY:
428 head = priv->txmapringhead;
429 tail = priv->txmapringtail;
432 head = priv->txbkpringhead;
433 tail = priv->txbkpringtail;
436 head = priv->txbepringhead;
437 tail = priv->txbepringtail;
440 head = priv->txvipringhead;
441 tail = priv->txvipringtail;
444 head = priv->txvopringhead;
445 tail = priv->txvopringtail;
448 head = priv->txhpringhead;
449 tail = priv->txhpringtail;
456 ret = priv->txringcount - (tail - head)/8;
458 ret = (head - tail)/8;
460 if (ret > priv->txringcount)
466 short check_nic_enought_desc(struct net_device *dev, int priority)
468 struct r8180_priv *priv = ieee80211_priv(dev);
469 struct ieee80211_device *ieee = netdev_priv(dev);
470 int requiredbyte, required;
472 requiredbyte = priv->ieee80211->fts + sizeof(struct ieee80211_header_data);
474 if (ieee->current_network.QoS_Enable)
477 required = requiredbyte / (priv->txbuffsize-4);
479 if (requiredbyte % priv->txbuffsize)
482 /* for now we keep two free descriptor as a safety boundary
483 * between the tail and the head
486 return (required+2 < get_curr_tx_free_desc(dev, priority));
489 void fix_tx_fifo(struct net_device *dev)
491 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
495 for (tmp = priv->txmapring, i = 0;
496 i < priv->txringcount;
498 *tmp = *tmp & ~(1<<31);
501 for (tmp = priv->txbkpring, i = 0;
502 i < priv->txringcount;
504 *tmp = *tmp & ~(1<<31);
507 for (tmp = priv->txbepring, i = 0;
508 i < priv->txringcount;
510 *tmp = *tmp & ~(1<<31);
512 for (tmp = priv->txvipring, i = 0;
513 i < priv->txringcount;
515 *tmp = *tmp & ~(1<<31);
518 for (tmp = priv->txvopring, i = 0;
519 i < priv->txringcount;
521 *tmp = *tmp & ~(1<<31);
524 for (tmp = priv->txhpring, i = 0;
525 i < priv->txringcount;
527 *tmp = *tmp & ~(1<<31);
530 for (tmp = priv->txbeaconring, i = 0;
531 i < priv->txbeaconcount;
533 *tmp = *tmp & ~(1<<31);
536 priv->txmapringtail = priv->txmapring;
537 priv->txmapringhead = priv->txmapring;
538 priv->txmapbufstail = priv->txmapbufs;
540 priv->txbkpringtail = priv->txbkpring;
541 priv->txbkpringhead = priv->txbkpring;
542 priv->txbkpbufstail = priv->txbkpbufs;
544 priv->txbepringtail = priv->txbepring;
545 priv->txbepringhead = priv->txbepring;
546 priv->txbepbufstail = priv->txbepbufs;
548 priv->txvipringtail = priv->txvipring;
549 priv->txvipringhead = priv->txvipring;
550 priv->txvipbufstail = priv->txvipbufs;
552 priv->txvopringtail = priv->txvopring;
553 priv->txvopringhead = priv->txvopring;
554 priv->txvopbufstail = priv->txvopbufs;
556 priv->txhpringtail = priv->txhpring;
557 priv->txhpringhead = priv->txhpring;
558 priv->txhpbufstail = priv->txhpbufs;
560 priv->txbeaconringtail = priv->txbeaconring;
561 priv->txbeaconbufstail = priv->txbeaconbufs;
564 ieee80211_reset_queue(priv->ieee80211);
565 priv->ack_tx_to_ieee = 0;
568 void fix_rx_fifo(struct net_device *dev)
570 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
572 struct buffer *rxbuf;
575 rx_desc_size = 8; /* 4*8 = 32 bytes */
577 for (tmp = priv->rxring, rxbuf = priv->rxbufferhead;
578 (tmp < (priv->rxring)+(priv->rxringcount)*rx_desc_size);
579 tmp += rx_desc_size, rxbuf = rxbuf->next) {
580 *(tmp+2) = rxbuf->dma;
581 *tmp = *tmp & ~0xfff;
582 *tmp = *tmp | priv->rxbuffersize;
586 priv->rxringtail = priv->rxring;
587 priv->rxbuffer = priv->rxbufferhead;
588 priv->rx_skb_complete = 1;
592 void rtl8180_irq_disable(struct net_device *dev)
594 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
596 write_nic_dword(dev, IMR, 0);
597 force_pci_posting(dev);
598 priv->irq_enabled = 0;
601 void rtl8180_set_mode(struct net_device *dev, int mode)
605 ecmd = read_nic_byte(dev, EPROM_CMD);
606 ecmd = ecmd & ~EPROM_CMD_OPERATING_MODE_MASK;
607 ecmd = ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
608 ecmd = ecmd & ~(1<<EPROM_CS_SHIFT);
609 ecmd = ecmd & ~(1<<EPROM_CK_SHIFT);
610 write_nic_byte(dev, EPROM_CMD, ecmd);
613 void rtl8180_beacon_tx_enable(struct net_device *dev);
615 void rtl8180_update_msr(struct net_device *dev)
617 struct r8180_priv *priv = ieee80211_priv(dev);
621 msr = read_nic_byte(dev, MSR);
622 msr &= ~MSR_LINK_MASK;
624 rxconf = read_nic_dword(dev, RX_CONF);
626 if (priv->ieee80211->state == IEEE80211_LINKED) {
627 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
628 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
629 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
630 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
631 else if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
632 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
634 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
635 rxconf |= (1<<RX_CHECK_BSSID_SHIFT);
638 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
639 rxconf &= ~(1<<RX_CHECK_BSSID_SHIFT);
642 write_nic_byte(dev, MSR, msr);
643 write_nic_dword(dev, RX_CONF, rxconf);
646 void rtl8180_set_chan(struct net_device *dev, short ch)
648 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
650 if ((ch > 14) || (ch < 1)) {
651 printk("In %s: Invalid chnanel %d\n", __func__, ch);
656 priv->rf_set_chan(dev, priv->chan);
659 void set_nic_txring(struct net_device *dev)
661 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
663 write_nic_dword(dev, TX_MANAGEPRIORITY_RING_ADDR, priv->txmapringdma);
664 write_nic_dword(dev, TX_BKPRIORITY_RING_ADDR, priv->txbkpringdma);
665 write_nic_dword(dev, TX_BEPRIORITY_RING_ADDR, priv->txbepringdma);
666 write_nic_dword(dev, TX_VIPRIORITY_RING_ADDR, priv->txvipringdma);
667 write_nic_dword(dev, TX_VOPRIORITY_RING_ADDR, priv->txvopringdma);
668 write_nic_dword(dev, TX_HIGHPRIORITY_RING_ADDR, priv->txhpringdma);
669 write_nic_dword(dev, TX_BEACON_RING_ADDR, priv->txbeaconringdma);
672 void rtl8180_beacon_tx_enable(struct net_device *dev)
674 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
676 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
677 priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_BQ);
678 write_nic_byte(dev, TPPollStop, priv->dma_poll_mask);
679 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
682 void rtl8180_beacon_tx_disable(struct net_device *dev)
684 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
686 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
687 priv->dma_poll_stop_mask |= TPPOLLSTOP_BQ;
688 write_nic_byte(dev, TPPollStop, priv->dma_poll_stop_mask);
689 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
693 void rtl8180_rtx_disable(struct net_device *dev)
696 struct r8180_priv *priv = ieee80211_priv(dev);
698 cmd = read_nic_byte(dev, CMD);
699 write_nic_byte(dev, CMD, cmd &
700 ~((1<<CMD_RX_ENABLE_SHIFT)|(1<<CMD_TX_ENABLE_SHIFT)));
701 force_pci_posting(dev);
704 if (!priv->rx_skb_complete)
705 dev_kfree_skb_any(priv->rx_skb);
708 short alloc_tx_desc_ring(struct net_device *dev, int bufsize, int count,
714 dma_addr_t dma_desc, dma_tmp;
715 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
716 struct pci_dev *pdev = priv->pdev;
719 if ((bufsize & 0xfff) != bufsize) {
720 DMESGE("TX buffer allocation too large");
723 desc = (u32 *)pci_alloc_consistent(pdev,
724 sizeof(u32)*8*count+256, &dma_desc);
730 * descriptor's buffer must be 256 byte aligned
731 * we shouldn't be here, since we set DMA mask !
733 WARN(1, "DMA buffer is not aligned\n");
737 for (i = 0; i < count; i++) {
738 buf = (void *)pci_alloc_consistent(pdev, bufsize, &dma_tmp);
743 case TX_MANAGEPRIORITY_RING_ADDR:
744 if (-1 == buffer_add(&(priv->txmapbufs), buf, dma_tmp, NULL)) {
745 DMESGE("Unable to allocate mem for buffer NP");
749 case TX_BKPRIORITY_RING_ADDR:
750 if (-1 == buffer_add(&(priv->txbkpbufs), buf, dma_tmp, NULL)) {
751 DMESGE("Unable to allocate mem for buffer LP");
755 case TX_BEPRIORITY_RING_ADDR:
756 if (-1 == buffer_add(&(priv->txbepbufs), buf, dma_tmp, NULL)) {
757 DMESGE("Unable to allocate mem for buffer NP");
761 case TX_VIPRIORITY_RING_ADDR:
762 if (-1 == buffer_add(&(priv->txvipbufs), buf, dma_tmp, NULL)) {
763 DMESGE("Unable to allocate mem for buffer LP");
767 case TX_VOPRIORITY_RING_ADDR:
768 if (-1 == buffer_add(&(priv->txvopbufs), buf, dma_tmp, NULL)) {
769 DMESGE("Unable to allocate mem for buffer NP");
773 case TX_HIGHPRIORITY_RING_ADDR:
774 if (-1 == buffer_add(&(priv->txhpbufs), buf, dma_tmp, NULL)) {
775 DMESGE("Unable to allocate mem for buffer HP");
779 case TX_BEACON_RING_ADDR:
780 if (-1 == buffer_add(&(priv->txbeaconbufs), buf, dma_tmp, NULL)) {
781 DMESGE("Unable to allocate mem for buffer BP");
786 *tmp = *tmp & ~(1<<31); /* descriptor empty, owned by the drv */
787 *(tmp+2) = (u32)dma_tmp;
791 *(tmp+4) = (u32)dma_desc+((i+1)*8*4);
793 *(tmp+4) = (u32)dma_desc;
799 case TX_MANAGEPRIORITY_RING_ADDR:
800 priv->txmapringdma = dma_desc;
801 priv->txmapring = desc;
803 case TX_BKPRIORITY_RING_ADDR:
804 priv->txbkpringdma = dma_desc;
805 priv->txbkpring = desc;
807 case TX_BEPRIORITY_RING_ADDR:
808 priv->txbepringdma = dma_desc;
809 priv->txbepring = desc;
811 case TX_VIPRIORITY_RING_ADDR:
812 priv->txvipringdma = dma_desc;
813 priv->txvipring = desc;
815 case TX_VOPRIORITY_RING_ADDR:
816 priv->txvopringdma = dma_desc;
817 priv->txvopring = desc;
819 case TX_HIGHPRIORITY_RING_ADDR:
820 priv->txhpringdma = dma_desc;
821 priv->txhpring = desc;
823 case TX_BEACON_RING_ADDR:
824 priv->txbeaconringdma = dma_desc;
825 priv->txbeaconring = desc;
833 void free_tx_desc_rings(struct net_device *dev)
835 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
836 struct pci_dev *pdev = priv->pdev;
837 int count = priv->txringcount;
839 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
840 priv->txmapring, priv->txmapringdma);
841 buffer_free(dev, &(priv->txmapbufs), priv->txbuffsize, 1);
843 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
844 priv->txbkpring, priv->txbkpringdma);
845 buffer_free(dev, &(priv->txbkpbufs), priv->txbuffsize, 1);
847 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
848 priv->txbepring, priv->txbepringdma);
849 buffer_free(dev, &(priv->txbepbufs), priv->txbuffsize, 1);
851 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
852 priv->txvipring, priv->txvipringdma);
853 buffer_free(dev, &(priv->txvipbufs), priv->txbuffsize, 1);
855 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
856 priv->txvopring, priv->txvopringdma);
857 buffer_free(dev, &(priv->txvopbufs), priv->txbuffsize, 1);
859 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
860 priv->txhpring, priv->txhpringdma);
861 buffer_free(dev, &(priv->txhpbufs), priv->txbuffsize, 1);
863 count = priv->txbeaconcount;
864 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
865 priv->txbeaconring, priv->txbeaconringdma);
866 buffer_free(dev, &(priv->txbeaconbufs), priv->txbuffsize, 1);
869 void free_rx_desc_ring(struct net_device *dev)
871 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
872 struct pci_dev *pdev = priv->pdev;
873 int count = priv->rxringcount;
875 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
876 priv->rxring, priv->rxringdma);
878 buffer_free(dev, &(priv->rxbuffer), priv->rxbuffersize, 0);
881 short alloc_rx_desc_ring(struct net_device *dev, u16 bufsize, int count)
886 dma_addr_t dma_desc, dma_tmp;
887 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
888 struct pci_dev *pdev = priv->pdev;
892 rx_desc_size = 8; /* 4*8 = 32 bytes */
894 if ((bufsize & 0xfff) != bufsize) {
895 DMESGE("RX buffer allocation too large");
899 desc = (u32 *)pci_alloc_consistent(pdev, sizeof(u32)*rx_desc_size*count+256,
904 * descriptor's buffer must be 256 byte aligned
905 * should never happen since we specify the DMA mask
907 WARN(1, "DMA buffer is not aligned\n");
910 priv->rxringdma = dma_desc;
913 for (i = 0; i < count; i++) {
914 buf = kmalloc(bufsize * sizeof(u8), GFP_ATOMIC);
916 DMESGE("Failed to kmalloc RX buffer");
920 dma_tmp = pci_map_single(pdev, buf, bufsize * sizeof(u8),
922 if (pci_dma_mapping_error(pdev, dma_tmp))
924 if (-1 == buffer_add(&(priv->rxbuffer), buf, dma_tmp,
925 &(priv->rxbufferhead))) {
926 DMESGE("Unable to allocate mem RX buf");
929 *tmp = 0; /* zero pads the header of the descriptor */
930 *tmp = *tmp | (bufsize&0xfff);
931 *(tmp+2) = (u32)dma_tmp;
932 *tmp = *tmp | (1<<31); /* descriptor void, owned by the NIC */
934 tmp = tmp+rx_desc_size;
937 *(tmp-rx_desc_size) = *(tmp-rx_desc_size) | (1<<30); /* this is the last descriptor */
943 void set_nic_rxring(struct net_device *dev)
946 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
948 pgreg = read_nic_byte(dev, PGSELECT);
949 write_nic_byte(dev, PGSELECT, pgreg & ~(1<<PGSELECT_PG_SHIFT));
951 write_nic_dword(dev, RXRING_ADDR, priv->rxringdma);
954 void rtl8180_reset(struct net_device *dev)
958 rtl8180_irq_disable(dev);
960 cr = read_nic_byte(dev, CMD);
962 cr = cr | (1<<CMD_RST_SHIFT);
963 write_nic_byte(dev, CMD, cr);
965 force_pci_posting(dev);
969 if (read_nic_byte(dev, CMD) & (1<<CMD_RST_SHIFT))
970 DMESGW("Card reset timeout!");
972 DMESG("Card successfully reset");
974 rtl8180_set_mode(dev, EPROM_CMD_LOAD);
975 force_pci_posting(dev);
979 inline u16 ieeerate2rtlrate(int rate)
1011 static u16 rtl_rate[] = {10, 20, 55, 110, 60, 90, 120, 180, 240, 360, 480, 540, 720};
1013 inline u16 rtl8180_rate2rate(short rate)
1017 return rtl_rate[rate];
1020 inline u8 rtl8180_IsWirelessBMode(u16 rate)
1022 if (((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220))
1028 u16 N_DBPSOfRate(u16 DataRate);
1030 u16 ComputeTxTime(u16 FrameLength, u16 DataRate, u8 bManagementFrame,
1037 if (rtl8180_IsWirelessBMode(DataRate)) {
1038 if (bManagementFrame || !bShortPreamble || DataRate == 10)
1040 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1042 /* short preamble */
1043 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1045 if ((FrameLength*8 % (DataRate/10)) != 0) /* get the ceilling */
1047 } else { /* 802.11g DSSS-OFDM PLCP length field calculation. */
1048 N_DBPS = N_DBPSOfRate(DataRate);
1049 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1050 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1051 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1056 u16 N_DBPSOfRate(u16 DataRate)
1093 * For Netgear case, they want good-looking signal strength.
1095 long NetgearSignalStrengthTranslate(long LastSS, long CurrSS)
1099 /* Step 1. Scale mapping. */
1100 if (CurrSS >= 71 && CurrSS <= 100)
1101 RetSS = 90 + ((CurrSS - 70) / 3);
1102 else if (CurrSS >= 41 && CurrSS <= 70)
1103 RetSS = 78 + ((CurrSS - 40) / 3);
1104 else if (CurrSS >= 31 && CurrSS <= 40)
1105 RetSS = 66 + (CurrSS - 30);
1106 else if (CurrSS >= 21 && CurrSS <= 30)
1107 RetSS = 54 + (CurrSS - 20);
1108 else if (CurrSS >= 5 && CurrSS <= 20)
1109 RetSS = 42 + (((CurrSS - 5) * 2) / 3);
1110 else if (CurrSS == 4)
1112 else if (CurrSS == 3)
1114 else if (CurrSS == 2)
1116 else if (CurrSS == 1)
1121 /* Step 2. Smoothing. */
1123 RetSS = ((LastSS * 5) + (RetSS) + 5) / 6;
1129 * Translate 0-100 signal strength index into dBm.
1131 long TranslateToDbm8185(u8 SignalStrengthIndex)
1135 /* Translate to dBm (x=0.5y-95). */
1136 SignalPower = (long)((SignalStrengthIndex + 1) >> 1);
1143 * Perform signal smoothing for dynamic mechanism.
1144 * This is different with PerformSignalSmoothing8185 in smoothing formula.
1145 * No dramatic adjustion is apply because dynamic mechanism need some degree
1146 * of correctness. Ported from 8187B.
1148 void PerformUndecoratedSignalSmoothing8185(struct r8180_priv *priv,
1151 /* Determin the current packet is CCK rate. */
1152 priv->bCurCCKPkt = bCckRate;
1154 if (priv->UndecoratedSmoothedSS >= 0)
1155 priv->UndecoratedSmoothedSS = ((priv->UndecoratedSmoothedSS * 5) +
1156 (priv->SignalStrength * 10)) / 6;
1158 priv->UndecoratedSmoothedSS = priv->SignalStrength * 10;
1160 priv->UndercorateSmoothedRxPower = ((priv->UndercorateSmoothedRxPower * 50) +
1161 (priv->RxPower * 11)) / 60;
1164 priv->CurCCKRSSI = priv->RSSI;
1166 priv->CurCCKRSSI = 0;
1171 * This is rough RX isr handling routine
1173 void rtl8180_rx(struct net_device *dev)
1175 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1176 struct sk_buff *tmp_skb;
1180 unsigned char quality, signal;
1189 u8 LNA_gain[4] = {02, 17, 29, 39};
1191 struct ieee80211_hdr_4addr *hdr;
1193 u8 bHwError = 0, bCRC = 0, bICV = 0;
1194 bool bCckRate = false;
1196 long SignalStrengthIndex = 0;
1197 struct ieee80211_rx_stats stats = {
1201 .freq = IEEE80211_24GHZ_BAND,
1204 stats.nic_type = NIC_8185B;
1207 if ((*(priv->rxringtail)) & (1<<31)) {
1208 /* we have got an RX int, but the descriptor
1209 * we are pointing is empty */
1211 priv->stats.rxnodata++;
1212 priv->ieee80211->stats.rx_errors++;
1215 tmp = priv->rxringtail;
1217 if (tmp == priv->rxring)
1218 tmp = priv->rxring + (priv->rxringcount - 1)*rx_desc_size;
1220 tmp -= rx_desc_size;
1222 if (!(*tmp & (1<<31)))
1224 } while (tmp != priv->rxring);
1227 priv->rxringtail = tmp2;
1230 /* while there are filled descriptors */
1231 while (!(*(priv->rxringtail) & (1<<31))) {
1232 if (*(priv->rxringtail) & (1<<26))
1233 DMESGW("RX buffer overflow");
1234 if (*(priv->rxringtail) & (1<<12))
1235 priv->stats.rxicverr++;
1237 if (*(priv->rxringtail) & (1<<27)) {
1238 priv->stats.rxdmafail++;
1239 /* DMESG("EE: RX DMA FAILED at buffer pointed by descriptor %x",(u32)priv->rxringtail); */
1243 pci_dma_sync_single_for_cpu(priv->pdev,
1244 priv->rxbuffer->dma,
1245 priv->rxbuffersize * sizeof(u8),
1246 PCI_DMA_FROMDEVICE);
1248 first = *(priv->rxringtail) & (1<<29) ? 1 : 0;
1250 priv->rx_prevlen = 0;
1252 last = *(priv->rxringtail) & (1<<28) ? 1 : 0;
1254 lastlen = ((*priv->rxringtail) & 0xfff);
1256 /* if the last descriptor (that should
1257 * tell us the total packet len) tell
1258 * us something less than the descriptors
1259 * len we had until now, then there is some
1261 * workaround to prevent kernel panic
1263 if (lastlen < priv->rx_prevlen)
1266 len = lastlen-priv->rx_prevlen;
1268 if (*(priv->rxringtail) & (1<<13)) {
1269 if ((*(priv->rxringtail) & 0xfff) < 500)
1270 priv->stats.rxcrcerrmin++;
1271 else if ((*(priv->rxringtail) & 0x0fff) > 1000)
1272 priv->stats.rxcrcerrmax++;
1274 priv->stats.rxcrcerrmid++;
1279 len = priv->rxbuffersize;
1282 if (first && last) {
1283 padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
1285 padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
1292 priv->rx_prevlen += len;
1294 if (priv->rx_prevlen > MAX_FRAG_THRESHOLD + 100) {
1295 /* HW is probably passing several buggy frames
1296 * without FD or LD flag set.
1297 * Throw this garbage away to prevent skb
1300 if (!priv->rx_skb_complete)
1301 dev_kfree_skb_any(priv->rx_skb);
1302 priv->rx_skb_complete = 1;
1305 signal = (unsigned char)(((*(priv->rxringtail+3)) & (0x00ff0000))>>16);
1306 signal = (signal & 0xfe) >> 1;
1308 quality = (unsigned char)((*(priv->rxringtail+3)) & (0xff));
1310 stats.mac_time[0] = *(priv->rxringtail+1);
1311 stats.mac_time[1] = *(priv->rxringtail+2);
1312 rxpower = ((char)(((*(priv->rxringtail+4)) & (0x00ff0000))>>16))/2 - 42;
1313 RSSI = ((u8)(((*(priv->rxringtail+3)) & (0x0000ff00))>>8)) & (0x7f);
1315 rate = ((*(priv->rxringtail)) &
1316 ((1<<23)|(1<<22)|(1<<21)|(1<<20)))>>20;
1318 stats.rate = rtl8180_rate2rate(rate);
1319 Antenna = (((*(priv->rxringtail+3)) & (0x00008000)) == 0) ? 0 : 1;
1320 if (!rtl8180_IsWirelessBMode(stats.rate)) { /* OFDM rate. */
1321 RxAGC_dBm = rxpower+1; /* bias */
1322 } else { /* CCK rate. */
1323 RxAGC_dBm = signal; /* bit 0 discard */
1325 LNA = (u8) (RxAGC_dBm & 0x60) >> 5; /* bit 6~ bit 5 */
1326 BB = (u8) (RxAGC_dBm & 0x1F); /* bit 4 ~ bit 0 */
1328 RxAGC_dBm = -(LNA_gain[LNA] + (BB*2)); /* Pin_11b=-(LNA_gain+BB_gain) (dBm) */
1330 RxAGC_dBm += 4; /* bias */
1333 if (RxAGC_dBm & 0x80) /* absolute value */
1334 RXAGC = ~(RxAGC_dBm)+1;
1335 bCckRate = rtl8180_IsWirelessBMode(stats.rate);
1336 /* Translate RXAGC into 1-100. */
1337 if (!rtl8180_IsWirelessBMode(stats.rate)) { /* OFDM rate. */
1340 else if (RXAGC < 25)
1342 RXAGC = (90-RXAGC)*100/65;
1343 } else { /* CCK rate. */
1346 else if (RXAGC < 30)
1348 RXAGC = (95-RXAGC)*100/65;
1350 priv->SignalStrength = (u8)RXAGC;
1351 priv->RecvSignalPower = RxAGC_dBm;
1352 priv->RxPower = rxpower;
1354 /* SQ translation formula is provided by SD3 DZ. 2006.06.27 */
1356 quality = 1; /*0; */ /* 0 will cause epc to show signal zero , walk around now; */
1357 else if (quality < 27)
1360 quality = 127 - quality;
1361 priv->SignalQuality = quality;
1363 stats.signal = (u8)quality; /*priv->wstats.qual.level = priv->SignalStrength; */
1364 stats.signalstrength = RXAGC;
1365 if (stats.signalstrength > 100)
1366 stats.signalstrength = 100;
1367 stats.signalstrength = (stats.signalstrength * 70)/100 + 30;
1368 /* printk("==========================>rx : RXAGC is %d,signalstrength is %d\n",RXAGC,stats.signalstrength); */
1369 stats.rssi = priv->wstats.qual.qual = priv->SignalQuality;
1370 stats.noise = priv->wstats.qual.noise = 100 - priv->wstats.qual.qual;
1371 bHwError = (((*(priv->rxringtail)) & (0x00000fff)) == 4080) |
1372 (((*(priv->rxringtail)) & (0x04000000)) != 0) |
1373 (((*(priv->rxringtail)) & (0x08000000)) != 0) |
1374 (((~(*(priv->rxringtail))) & (0x10000000)) != 0) |
1375 (((~(*(priv->rxringtail))) & (0x20000000)) != 0);
1376 bCRC = ((*(priv->rxringtail)) & (0x00002000)) >> 13;
1377 bICV = ((*(priv->rxringtail)) & (0x00001000)) >> 12;
1378 hdr = (struct ieee80211_hdr_4addr *)priv->rxbuffer->buf;
1379 fc = le16_to_cpu(hdr->frame_ctl);
1380 type = WLAN_FC_GET_TYPE(fc);
1382 if (IEEE80211_FTYPE_CTL != type &&
1383 !bHwError && !bCRC && !bICV &&
1384 eqMacAddr(priv->ieee80211->current_network.bssid,
1385 fc & IEEE80211_FCTL_TODS ? hdr->addr1 :
1386 fc & IEEE80211_FCTL_FROMDS ? hdr->addr2 :
1389 /* Perform signal smoothing for dynamic
1390 * mechanism on demand. This is different
1391 * with PerformSignalSmoothing8185 in smoothing
1392 * fomula. No dramatic adjustion is apply
1393 * because dynamic mechanism need some degree
1394 * of correctness. */
1395 PerformUndecoratedSignalSmoothing8185(priv, bCckRate);
1397 /* For good-looking singal strength. */
1398 SignalStrengthIndex = NetgearSignalStrengthTranslate(
1399 priv->LastSignalStrengthInPercent,
1400 priv->SignalStrength);
1402 priv->LastSignalStrengthInPercent = SignalStrengthIndex;
1403 priv->Stats_SignalStrength = TranslateToDbm8185((u8)SignalStrengthIndex);
1405 * We need more correct power of received packets and the "SignalStrength" of RxStats is beautified,
1406 * so we record the correct power here.
1408 priv->Stats_SignalQuality = (long)(priv->Stats_SignalQuality * 5 + (long)priv->SignalQuality + 5) / 6;
1409 priv->Stats_RecvSignalPower = (long)(priv->Stats_RecvSignalPower * 5 + priv->RecvSignalPower - 1) / 6;
1411 /* Figure out which antenna that received the last packet. */
1412 priv->LastRxPktAntenna = Antenna ? 1 : 0; /* 0: aux, 1: main. */
1413 SwAntennaDiversityRxOk8185(dev, priv->SignalStrength);
1417 if (!priv->rx_skb_complete) {
1418 /* seems that HW sometimes fails to receive and
1419 doesn't provide the last descriptor */
1420 dev_kfree_skb_any(priv->rx_skb);
1421 priv->stats.rxnolast++;
1423 priv->rx_skb = dev_alloc_skb(len+2);
1427 priv->rx_skb_complete = 0;
1428 priv->rx_skb->dev = dev;
1430 /* if we are here we should have already RXed
1432 * If we get here and the skb is not allocated then
1433 * we have just throw out garbage (skb not allocated)
1434 * and we are still rxing garbage....
1436 if (!priv->rx_skb_complete) {
1438 tmp_skb = dev_alloc_skb(priv->rx_skb->len+len+2);
1445 memcpy(skb_put(tmp_skb, priv->rx_skb->len),
1449 dev_kfree_skb_any(priv->rx_skb);
1451 priv->rx_skb = tmp_skb;
1455 if (!priv->rx_skb_complete) {
1457 memcpy(skb_put(priv->rx_skb, len),
1458 (((unsigned char *)priv->rxbuffer->buf) + 2), len);
1460 memcpy(skb_put(priv->rx_skb, len),
1461 priv->rxbuffer->buf, len);
1465 if (last && !priv->rx_skb_complete) {
1466 if (priv->rx_skb->len > 4)
1467 skb_trim(priv->rx_skb, priv->rx_skb->len-4);
1468 if (!ieee80211_rtl_rx(priv->ieee80211,
1469 priv->rx_skb, &stats))
1470 dev_kfree_skb_any(priv->rx_skb);
1471 priv->rx_skb_complete = 1;
1474 pci_dma_sync_single_for_device(priv->pdev,
1475 priv->rxbuffer->dma,
1476 priv->rxbuffersize * sizeof(u8),
1477 PCI_DMA_FROMDEVICE);
1479 drop: /* this is used when we have not enough mem */
1480 /* restore the descriptor */
1481 *(priv->rxringtail+2) = priv->rxbuffer->dma;
1482 *(priv->rxringtail) = *(priv->rxringtail) & ~0xfff;
1483 *(priv->rxringtail) =
1484 *(priv->rxringtail) | priv->rxbuffersize;
1486 *(priv->rxringtail) =
1487 *(priv->rxringtail) | (1<<31);
1489 priv->rxringtail += rx_desc_size;
1490 if (priv->rxringtail >=
1491 (priv->rxring)+(priv->rxringcount)*rx_desc_size)
1492 priv->rxringtail = priv->rxring;
1494 priv->rxbuffer = (priv->rxbuffer->next);
1499 void rtl8180_dma_kick(struct net_device *dev, int priority)
1501 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1503 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1504 write_nic_byte(dev, TX_DMA_POLLING,
1505 (1 << (priority + 1)) | priv->dma_poll_mask);
1506 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1508 force_pci_posting(dev);
1511 void rtl8180_data_hard_stop(struct net_device *dev)
1513 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1515 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1516 priv->dma_poll_stop_mask |= TPPOLLSTOP_AC_VIQ;
1517 write_nic_byte(dev, TPPollStop, priv->dma_poll_stop_mask);
1518 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1521 void rtl8180_data_hard_resume(struct net_device *dev)
1523 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1525 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1526 priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_AC_VIQ);
1527 write_nic_byte(dev, TPPollStop, priv->dma_poll_stop_mask);
1528 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1532 * This function TX data frames when the ieee80211 stack requires this.
1533 * It checks also if we need to stop the ieee tx queue, eventually do it
1535 void rtl8180_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int
1537 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1539 struct ieee80211_hdr_3addr *h = (struct ieee80211_hdr_3addr *) skb->data;
1540 short morefrag = (h->frame_control) & IEEE80211_FCTL_MOREFRAGS;
1541 unsigned long flags;
1544 mode = priv->ieee80211->iw_mode;
1546 rate = ieeerate2rtlrate(rate);
1548 * This function doesn't require lock because we make
1549 * sure it's called with the tx_lock already acquired.
1550 * this come from the kernel's hard_xmit callback (through
1551 * the ieee stack, or from the try_wake_queue (again through
1554 priority = AC2Q(skb->priority);
1555 spin_lock_irqsave(&priv->tx_lock, flags);
1557 if (priv->ieee80211->bHwRadioOff) {
1558 spin_unlock_irqrestore(&priv->tx_lock, flags);
1563 if (!check_nic_enought_desc(dev, priority)) {
1564 DMESGW("Error: no descriptor left by previous TX (avail %d) ",
1565 get_curr_tx_free_desc(dev, priority));
1566 ieee80211_rtl_stop_queue(priv->ieee80211);
1568 rtl8180_tx(dev, skb->data, skb->len, priority, morefrag, 0, rate);
1569 if (!check_nic_enought_desc(dev, priority))
1570 ieee80211_rtl_stop_queue(priv->ieee80211);
1572 spin_unlock_irqrestore(&priv->tx_lock, flags);
1576 * This is a rough attempt to TX a frame
1577 * This is called by the ieee 80211 stack to TX management frames.
1578 * If the ring is full packets are dropped (for data frame the queue
1579 * is stopped before this can happen). For this reason it is better
1580 * if the descriptors are larger than the largest management frame
1581 * we intend to TX: i'm unsure what the HW does if it will not find
1582 * the last fragment of a frame because it has been dropped...
1583 * Since queues for Management and Data frames are different we
1584 * might use a different lock than tx_lock (for example mgmt_tx_lock)
1586 /* these function may loop if invoked with 0 descriptors or 0 len buffer */
1587 int rtl8180_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1589 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1590 unsigned long flags;
1593 priority = MANAGE_PRIORITY;
1595 spin_lock_irqsave(&priv->tx_lock, flags);
1597 if (priv->ieee80211->bHwRadioOff) {
1598 spin_unlock_irqrestore(&priv->tx_lock, flags);
1599 dev_kfree_skb_any(skb);
1600 return NETDEV_TX_OK;
1603 rtl8180_tx(dev, skb->data, skb->len, priority,
1604 0, 0, ieeerate2rtlrate(priv->ieee80211->basic_rate));
1606 priv->ieee80211->stats.tx_bytes += skb->len;
1607 priv->ieee80211->stats.tx_packets++;
1608 spin_unlock_irqrestore(&priv->tx_lock, flags);
1610 dev_kfree_skb_any(skb);
1611 return NETDEV_TX_OK;
1614 /* longpre 144+48 shortpre 72+24 */
1615 u16 rtl8180_len2duration(u32 len, short rate, short *ext)
1624 duration = ((len+4)<<4) / 0x2;
1625 drift = ((len+4)<<4) % 0x2;
1632 duration = ((len+4)<<4) / 0x4;
1633 drift = ((len+4)<<4) % 0x4;
1638 case 2: /* 5.5mbps */
1640 duration = ((len+4)<<4) / 0xb;
1641 drift = ((len+4)<<4) % 0xb;
1647 case 3: /* 11mbps */
1649 duration = ((len+4)<<4) / 0x16;
1650 drift = ((len+4)<<4) % 0x16;
1663 void rtl8180_prepare_beacon(struct net_device *dev)
1665 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1666 struct sk_buff *skb;
1668 u16 word = read_nic_word(dev, BcnItv);
1669 word &= ~BcnItv_BcnItv; /* clear Bcn_Itv */
1670 word |= cpu_to_le16(priv->ieee80211->current_network.beacon_interval); /* 0x64; */
1671 write_nic_word(dev, BcnItv, word);
1673 skb = ieee80211_get_beacon(priv->ieee80211);
1675 rtl8180_tx(dev, skb->data, skb->len, BEACON_PRIORITY,
1676 0, 0, ieeerate2rtlrate(priv->ieee80211->basic_rate));
1677 dev_kfree_skb_any(skb);
1682 * This function do the real dirty work: it enqueues a TX command
1683 * descriptor in the ring buffer, copyes the frame in a TX buffer
1684 * and kicks the NIC to ensure it does the DMA transfer.
1686 short rtl8180_tx(struct net_device *dev, u8 *txbuf, int len, int priority,
1687 short morefrag, short descfrag, int rate)
1689 struct r8180_priv *priv = ieee80211_priv(dev);
1690 u32 *tail, *temp_tail;
1697 struct buffer *buflist;
1698 struct ieee80211_hdr_3addr *frag_hdr = (struct ieee80211_hdr_3addr *)txbuf;
1700 u8 bUseShortPreamble = 0;
1705 u16 ThisFrameTime = 0;
1706 u16 TxDescDuration = 0;
1707 u8 ownbit_flag = false;
1710 case MANAGE_PRIORITY:
1711 tail = priv->txmapringtail;
1712 begin = priv->txmapring;
1713 buflist = priv->txmapbufstail;
1714 count = priv->txringcount;
1717 tail = priv->txbkpringtail;
1718 begin = priv->txbkpring;
1719 buflist = priv->txbkpbufstail;
1720 count = priv->txringcount;
1723 tail = priv->txbepringtail;
1724 begin = priv->txbepring;
1725 buflist = priv->txbepbufstail;
1726 count = priv->txringcount;
1729 tail = priv->txvipringtail;
1730 begin = priv->txvipring;
1731 buflist = priv->txvipbufstail;
1732 count = priv->txringcount;
1735 tail = priv->txvopringtail;
1736 begin = priv->txvopring;
1737 buflist = priv->txvopbufstail;
1738 count = priv->txringcount;
1741 tail = priv->txhpringtail;
1742 begin = priv->txhpring;
1743 buflist = priv->txhpbufstail;
1744 count = priv->txringcount;
1746 case BEACON_PRIORITY:
1747 tail = priv->txbeaconringtail;
1748 begin = priv->txbeaconring;
1749 buflist = priv->txbeaconbufstail;
1750 count = priv->txbeaconcount;
1757 memcpy(&dest, frag_hdr->addr1, ETH_ALEN);
1758 if (is_multicast_ether_addr(dest)) {
1764 ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate),
1765 0, bUseShortPreamble);
1766 TxDescDuration = ThisFrameTime;
1767 } else { /* Unicast packet */
1770 /* YJ,add,080828,for Keep alive */
1771 priv->NumTxUnicast++;
1773 /* Figure out ACK rate according to BSS basic rate
1775 AckTime = ComputeTxTime(14, 10, 0, 0); /* AckCTSLng = 14 use 1M bps send */
1777 if (((len + sCrcLng) > priv->rts) && priv->rts) { /* RTS/CTS. */
1778 u16 RtsTime, CtsTime;
1783 /* Rate and time required for RTS. */
1784 RtsTime = ComputeTxTime(sAckCtsLng/8, priv->ieee80211->basic_rate, 0, 0);
1785 /* Rate and time required for CTS. */
1786 CtsTime = ComputeTxTime(14, 10, 0, 0); /* AckCTSLng = 14 use 1M bps send */
1788 /* Figure out time required to transmit this frame. */
1789 ThisFrameTime = ComputeTxTime(len + sCrcLng,
1790 rtl8180_rate2rate(rate),
1794 /* RTS-CTS-ThisFrame-ACK. */
1795 RtsDur = CtsTime + ThisFrameTime + AckTime + 3*aSifsTime;
1797 TxDescDuration = RtsTime + RtsDur;
1798 } else { /* Normal case. */
1803 ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate),
1804 0, bUseShortPreamble);
1805 TxDescDuration = ThisFrameTime + aSifsTime + AckTime;
1808 if (!(frag_hdr->frame_control & IEEE80211_FCTL_MOREFRAGS)) {
1809 /* ThisFrame-ACK. */
1810 Duration = aSifsTime + AckTime;
1811 } else { /* One or more fragments remained. */
1813 NextFragTime = ComputeTxTime(len + sCrcLng, /* pretend following packet length equal current packet */
1814 rtl8180_rate2rate(rate),
1818 /* ThisFrag-ACk-NextFrag-ACK. */
1819 Duration = NextFragTime + 3*aSifsTime + 2*AckTime;
1822 } /* End of Unicast packet */
1824 frag_hdr->duration_id = Duration;
1826 buflen = priv->txbuffsize;
1830 while (remain != 0) {
1833 DMESGE("TX buffer error, cannot TX frames. pri %d.", priority);
1838 if ((*tail & (1 << 31)) && (priority != BEACON_PRIORITY)) {
1839 DMESGW("No more TX desc, returning %x of %x",
1841 priv->stats.txrdu++;
1845 *tail = 0; /* zeroes header */
1852 /* FIXME: this should be triggered by HW encryption parameters.*/
1853 *tail |= (1<<15); /* no encrypt */
1855 if (remain == len && !descfrag) {
1856 ownbit_flag = false;
1857 *tail = *tail | (1<<29) ; /* fist segment of the packet */
1858 *tail = *tail | (len);
1863 for (i = 0; i < buflen && remain > 0; i++, remain--) {
1864 ((u8 *)buf)[i] = txbuf[i]; /* copy data into descriptor pointed DMAble buffer */
1865 if (remain == 4 && i+4 >= buflen)
1867 /* ensure the last desc has at least 4 bytes payload */
1871 *(tail+3) = *(tail+3) & ~0xfff;
1872 *(tail+3) = *(tail+3) | i; /* buffer length */
1873 /* Use short preamble or not */
1874 if (priv->ieee80211->current_network.capability&WLAN_CAPABILITY_SHORT_PREAMBLE)
1875 if (priv->plcp_preamble_mode == 1 && rate != 0) /* short mode now, not long! */
1876 ; /* *tail |= (1<<16); */ /* enable short preamble mode. */
1881 if (bRTSEnable) { /* rts enable */
1882 *tail |= ((ieeerate2rtlrate(priv->ieee80211->basic_rate))<<19); /* RTS RATE */
1883 *tail |= (1<<23); /* rts enable */
1884 *(tail+1) |= (RtsDur&0xffff); /* RTS Duration */
1886 *(tail+3) |= ((TxDescDuration&0xffff)<<16); /* DURATION */
1887 /* *(tail+3) |= (0xe6<<16); */
1888 *(tail+5) |= (11<<8); /* (priv->retry_data<<8); */ /* retry lim; */
1890 *tail = *tail | ((rate&0xf) << 24);
1893 *tail = (*tail) | (1<<17); /* more fragment */
1895 *tail = (*tail) | (1<<28); /* last segment of frame */
1897 *(tail+5) = *(tail+5)|(2<<27);
1898 *(tail+7) = *(tail+7)|(1<<4);
1902 *tail = *tail | (1<<31); /* descriptor ready to be txed */
1904 if ((tail - begin)/8 == count-1)
1909 buflist = buflist->next;
1914 case MANAGE_PRIORITY:
1915 priv->txmapringtail = tail;
1916 priv->txmapbufstail = buflist;
1919 priv->txbkpringtail = tail;
1920 priv->txbkpbufstail = buflist;
1923 priv->txbepringtail = tail;
1924 priv->txbepbufstail = buflist;
1927 priv->txvipringtail = tail;
1928 priv->txvipbufstail = buflist;
1931 priv->txvopringtail = tail;
1932 priv->txvopbufstail = buflist;
1935 priv->txhpringtail = tail;
1936 priv->txhpbufstail = buflist;
1938 case BEACON_PRIORITY:
1940 * The HW seems to be happy with the 1st
1941 * descriptor filled and the 2nd empty...
1942 * So always update descriptor 1 and never
1948 *temp_tail = *temp_tail | (1<<31); /* descriptor ready to be txed */
1949 rtl8180_dma_kick(dev, priority);
1954 void rtl8180_irq_rx_tasklet(struct r8180_priv *priv);
1956 void rtl8180_link_change(struct net_device *dev)
1958 struct r8180_priv *priv = ieee80211_priv(dev);
1959 u16 beacon_interval;
1960 struct ieee80211_network *net = &priv->ieee80211->current_network;
1962 rtl8180_update_msr(dev);
1964 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1966 write_nic_dword(dev, BSSID, ((u32 *)net->bssid)[0]);
1967 write_nic_word(dev, BSSID+4, ((u16 *)net->bssid)[2]);
1969 beacon_interval = read_nic_word(dev, BEACON_INTERVAL);
1970 beacon_interval &= ~BEACON_INTERVAL_MASK;
1971 beacon_interval |= net->beacon_interval;
1972 write_nic_word(dev, BEACON_INTERVAL, beacon_interval);
1974 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1976 rtl8180_set_chan(dev, priv->chan);
1979 void rtl8180_rq_tx_ack(struct net_device *dev)
1982 struct r8180_priv *priv = ieee80211_priv(dev);
1984 write_nic_byte(dev, CONFIG4, read_nic_byte(dev, CONFIG4) | CONFIG4_PWRMGT);
1985 priv->ack_tx_to_ieee = 1;
1988 short rtl8180_is_tx_queue_empty(struct net_device *dev)
1991 struct r8180_priv *priv = ieee80211_priv(dev);
1994 for (d = priv->txmapring;
1995 d < priv->txmapring + priv->txringcount; d += 8)
1999 for (d = priv->txbkpring;
2000 d < priv->txbkpring + priv->txringcount; d += 8)
2004 for (d = priv->txbepring;
2005 d < priv->txbepring + priv->txringcount; d += 8)
2009 for (d = priv->txvipring;
2010 d < priv->txvipring + priv->txringcount; d += 8)
2014 for (d = priv->txvopring;
2015 d < priv->txvopring + priv->txringcount; d += 8)
2019 for (d = priv->txhpring;
2020 d < priv->txhpring + priv->txringcount; d += 8)
2026 void rtl8180_hw_wakeup(struct net_device *dev)
2028 unsigned long flags;
2029 struct r8180_priv *priv = ieee80211_priv(dev);
2031 spin_lock_irqsave(&priv->ps_lock, flags);
2032 write_nic_byte(dev, CONFIG4, read_nic_byte(dev, CONFIG4) & ~CONFIG4_PWRMGT);
2033 if (priv->rf_wakeup)
2034 priv->rf_wakeup(dev);
2035 spin_unlock_irqrestore(&priv->ps_lock, flags);
2038 void rtl8180_hw_sleep_down(struct net_device *dev)
2040 unsigned long flags;
2041 struct r8180_priv *priv = ieee80211_priv(dev);
2043 spin_lock_irqsave(&priv->ps_lock, flags);
2045 priv->rf_sleep(dev);
2046 spin_unlock_irqrestore(&priv->ps_lock, flags);
2049 void rtl8180_hw_sleep(struct net_device *dev, u32 th, u32 tl)
2051 struct r8180_priv *priv = ieee80211_priv(dev);
2053 unsigned long flags;
2055 spin_lock_irqsave(&priv->ps_lock, flags);
2058 * Writing HW register with 0 equals to disable
2059 * the timer, that is not really what we want
2061 tl -= MSECS(4+16+7);
2064 * If the interval in witch we are requested to sleep is too
2065 * short then give up and remain awake
2067 if (((tl >= rb) && (tl-rb) <= MSECS(MIN_SLEEP_TIME))
2068 || ((rb > tl) && (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
2069 spin_unlock_irqrestore(&priv->ps_lock, flags);
2070 printk("too short to sleep\n");
2075 u32 tmp = (tl > rb) ? (tl-rb) : (rb-tl);
2077 priv->DozePeriodInPast2Sec += jiffies_to_msecs(tmp);
2078 /* as tl may be less than rb */
2079 queue_delayed_work(priv->ieee80211->wq, &priv->ieee80211->hw_wakeup_wq, tmp);
2082 * If we suspect the TimerInt is gone beyond tl
2083 * while setting it, then give up
2086 if (((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME))) ||
2087 ((tl < rb) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))) {
2088 spin_unlock_irqrestore(&priv->ps_lock, flags);
2092 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_sleep_wq);
2093 spin_unlock_irqrestore(&priv->ps_lock, flags);
2096 void rtl8180_wmm_param_update(struct work_struct *work)
2098 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, wmm_param_update_wq);
2099 struct net_device *dev = ieee->dev;
2100 u8 *ac_param = (u8 *)(ieee->current_network.wmm_param);
2101 u8 mode = ieee->current_network.mode;
2107 if (!ieee->current_network.QoS_Enable) {
2108 /* legacy ac_xx_param update */
2109 AcParam.longData = 0;
2110 AcParam.f.AciAifsn.f.AIFSN = 2; /* Follow 802.11 DIFS. */
2111 AcParam.f.AciAifsn.f.ACM = 0;
2112 AcParam.f.Ecw.f.ECWmin = 3; /* Follow 802.11 CWmin. */
2113 AcParam.f.Ecw.f.ECWmax = 7; /* Follow 802.11 CWmax. */
2114 AcParam.f.TXOPLimit = 0;
2115 for (eACI = 0; eACI < AC_MAX; eACI++) {
2116 AcParam.f.AciAifsn.f.ACI = (u8)eACI;
2120 pAcParam = (PAC_PARAM)(&AcParam);
2121 /* Retrieve parameters to update. */
2122 u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN * (((mode&IEEE_G) == IEEE_G) ? 9 : 20) + aSifsTime;
2123 u4bAcParam = ((((u32)(pAcParam->f.TXOPLimit))<<AC_PARAM_TXOP_LIMIT_OFFSET)|
2124 (((u32)(pAcParam->f.Ecw.f.ECWmax))<<AC_PARAM_ECW_MAX_OFFSET)|
2125 (((u32)(pAcParam->f.Ecw.f.ECWmin))<<AC_PARAM_ECW_MIN_OFFSET)|
2126 (((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
2129 write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
2132 write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
2135 write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
2138 write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
2141 pr_warn("SetHwReg8185():invalid ACI: %d!\n",
2150 for (i = 0; i < AC_MAX; i++) {
2151 /* AcParam.longData = 0; */
2152 pAcParam = (AC_PARAM *)ac_param;
2158 /* Retrieve parameters to update. */
2159 eACI = pAcParam->f.AciAifsn.f.ACI;
2160 /* Mode G/A: slotTimeTimer = 9; Mode B: 20 */
2161 u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN * (((mode&IEEE_G) == IEEE_G) ? 9 : 20) + aSifsTime;
2162 u4bAcParam = ((((u32)(pAcParam->f.TXOPLimit)) << AC_PARAM_TXOP_LIMIT_OFFSET) |
2163 (((u32)(pAcParam->f.Ecw.f.ECWmax)) << AC_PARAM_ECW_MAX_OFFSET) |
2164 (((u32)(pAcParam->f.Ecw.f.ECWmin)) << AC_PARAM_ECW_MIN_OFFSET) |
2165 (((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
2169 write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
2172 write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
2175 write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
2178 write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
2181 pr_warn("SetHwReg8185(): invalid ACI: %d !\n",
2186 ac_param += (sizeof(AC_PARAM));
2190 void rtl8180_restart_wq(struct work_struct *work);
2191 /* void rtl8180_rq_tx_ack(struct work_struct *work); */
2192 void rtl8180_watch_dog_wq(struct work_struct *work);
2193 void rtl8180_hw_wakeup_wq(struct work_struct *work);
2194 void rtl8180_hw_sleep_wq(struct work_struct *work);
2195 void rtl8180_sw_antenna_wq(struct work_struct *work);
2196 void rtl8180_watch_dog(struct net_device *dev);
2198 void watch_dog_adaptive(unsigned long data)
2200 struct r8180_priv *priv = ieee80211_priv((struct net_device *)data);
2203 DMESG("<----watch_dog_adaptive():driver is not up!\n");
2207 /* Tx High Power Mechanism. */
2208 if (CheckHighPower((struct net_device *)data))
2209 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->tx_pw_wq);
2211 /* Tx Power Tracking on 87SE. */
2212 if (CheckTxPwrTracking((struct net_device *)data))
2213 TxPwrTracking87SE((struct net_device *)data);
2215 /* Perform DIG immediately. */
2216 if (CheckDig((struct net_device *)data) == true)
2217 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_dig_wq);
2218 rtl8180_watch_dog((struct net_device *)data);
2220 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->GPIOChangeRFWorkItem);
2222 priv->watch_dog_timer.expires = jiffies + MSECS(IEEE80211_WATCH_DOG_TIME);
2223 add_timer(&priv->watch_dog_timer);
2226 static CHANNEL_LIST ChannelPlan[] = {
2227 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64},19}, /* FCC */
2228 {{1,2,3,4,5,6,7,8,9,10,11},11}, /* IC */
2229 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, /* ETSI */
2230 {{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. */
2231 {{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. */
2232 {{14,36,40,44,48,52,56,60,64},9}, /* MKK */
2233 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14, 36,40,44,48,52,56,60,64},22},/* MKK1 */
2234 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, /* Israel. */
2235 {{1,2,3,4,5,6,7,8,9,10,11,12,13,34,38,42,46},17}, /* For 11a , TELEC */
2236 {{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 */
2237 {{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 */
2240 static void rtl8180_set_channel_map(u8 channel_plan, struct ieee80211_device *ieee)
2244 /* lzm add 080826 */
2245 ieee->MinPassiveChnlNum = MAX_CHANNEL_NUMBER+1;
2246 ieee->IbssStartChnl = 0;
2248 switch (channel_plan) {
2249 case COUNTRY_CODE_FCC:
2250 case COUNTRY_CODE_IC:
2251 case COUNTRY_CODE_ETSI:
2252 case COUNTRY_CODE_SPAIN:
2253 case COUNTRY_CODE_FRANCE:
2254 case COUNTRY_CODE_MKK:
2255 case COUNTRY_CODE_MKK1:
2256 case COUNTRY_CODE_ISRAEL:
2257 case COUNTRY_CODE_TELEC:
2260 ieee->bGlobalDomain = false;
2261 if (ChannelPlan[channel_plan].Len != 0) {
2262 /* Clear old channel map */
2263 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
2264 /* Set new channel map */
2265 for (i = 0; i < ChannelPlan[channel_plan].Len; i++) {
2266 if (ChannelPlan[channel_plan].Channel[i] <= 14)
2267 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
2272 case COUNTRY_CODE_GLOBAL_DOMAIN:
2274 GET_DOT11D_INFO(ieee)->bEnabled = 0;
2276 ieee->bGlobalDomain = true;
2279 case COUNTRY_CODE_WORLD_WIDE_13_INDEX:/* lzm add 080826 */
2281 ieee->MinPassiveChnlNum = 12;
2282 ieee->IbssStartChnl = 10;
2288 ieee->bGlobalDomain = false;
2289 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
2290 for (i = 1; i <= 14; i++)
2291 GET_DOT11D_INFO(ieee)->channel_map[i] = 1;
2297 void GPIOChangeRFWorkItemCallBack(struct work_struct *work);
2300 static void rtl8180_statistics_init(struct Stats *pstats)
2302 memset(pstats, 0, sizeof(struct Stats));
2305 static void rtl8180_link_detect_init(plink_detect_t plink_detect)
2307 memset(plink_detect, 0, sizeof(link_detect_t));
2308 plink_detect->SlotNum = DEFAULT_SLOT_NUM;
2311 /* YJ,add,080828,end */
2312 static void rtl8187se_eeprom_register_read(struct eeprom_93cx6 *eeprom)
2314 struct net_device *dev = eeprom->data;
2315 u8 reg = read_nic_byte(dev, EPROM_CMD);
2317 eeprom->reg_data_in = reg & RTL818X_EEPROM_CMD_WRITE;
2318 eeprom->reg_data_out = reg & RTL818X_EEPROM_CMD_READ;
2319 eeprom->reg_data_clock = reg & RTL818X_EEPROM_CMD_CK;
2320 eeprom->reg_chip_select = reg & RTL818X_EEPROM_CMD_CS;
2323 static void rtl8187se_eeprom_register_write(struct eeprom_93cx6 *eeprom)
2325 struct net_device *dev = eeprom->data;
2328 if (eeprom->reg_data_in)
2329 reg |= RTL818X_EEPROM_CMD_WRITE;
2330 if (eeprom->reg_data_out)
2331 reg |= RTL818X_EEPROM_CMD_READ;
2332 if (eeprom->reg_data_clock)
2333 reg |= RTL818X_EEPROM_CMD_CK;
2334 if (eeprom->reg_chip_select)
2335 reg |= RTL818X_EEPROM_CMD_CS;
2337 write_nic_byte(dev, EPROM_CMD, reg);
2338 read_nic_byte(dev, EPROM_CMD);
2342 short rtl8180_init(struct net_device *dev)
2344 struct r8180_priv *priv = ieee80211_priv(dev);
2349 struct eeprom_93cx6 eeprom;
2353 eeprom.register_read = rtl8187se_eeprom_register_read;
2354 eeprom.register_write = rtl8187se_eeprom_register_write;
2355 eeprom.width = PCI_EEPROM_WIDTH_93C46;
2357 eeprom_93cx6_read(&eeprom, EEPROM_COUNTRY_CODE>>1, &eeprom_val);
2358 priv->channel_plan = eeprom_val & 0xFF;
2359 if (priv->channel_plan > COUNTRY_CODE_GLOBAL_DOMAIN) {
2360 printk("rtl8180_init:Error channel plan! Set to default.\n");
2361 priv->channel_plan = 0;
2364 DMESG("Channel plan is %d\n", priv->channel_plan);
2365 rtl8180_set_channel_map(priv->channel_plan, priv->ieee80211);
2367 /* FIXME: these constants are placed in a bad pleace. */
2368 priv->txbuffsize = 2048; /* 1024; */
2369 priv->txringcount = 32; /* 32; */
2370 priv->rxbuffersize = 2048; /* 1024; */
2371 priv->rxringcount = 64; /* 32; */
2372 priv->txbeaconcount = 2;
2373 priv->rx_skb_complete = 1;
2375 priv->RFChangeInProgress = false;
2376 priv->SetRFPowerStateInProgress = false;
2377 priv->RFProgType = 0;
2379 priv->irq_enabled = 0;
2381 rtl8180_statistics_init(&priv->stats);
2382 rtl8180_link_detect_init(&priv->link_detect);
2384 priv->ack_tx_to_ieee = 0;
2385 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2386 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2387 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2388 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2389 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;
2390 priv->ieee80211->active_scan = 1;
2391 priv->ieee80211->rate = 110; /* 11 mbps */
2392 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION;
2393 priv->ieee80211->host_encrypt = 1;
2394 priv->ieee80211->host_decrypt = 1;
2395 priv->ieee80211->sta_wake_up = rtl8180_hw_wakeup;
2396 priv->ieee80211->ps_request_tx_ack = rtl8180_rq_tx_ack;
2397 priv->ieee80211->enter_sleep_state = rtl8180_hw_sleep;
2398 priv->ieee80211->ps_is_queue_empty = rtl8180_is_tx_queue_empty;
2400 priv->hw_wep = hwwep;
2402 priv->retry_rts = DEFAULT_RETRY_RTS;
2403 priv->retry_data = DEFAULT_RETRY_DATA;
2404 priv->RFChangeInProgress = false;
2405 priv->SetRFPowerStateInProgress = false;
2406 priv->RFProgType = 0;
2407 priv->bInactivePs = true; /* false; */
2408 priv->ieee80211->bInactivePs = priv->bInactivePs;
2409 priv->bSwRfProcessing = false;
2410 priv->eRFPowerState = eRfOff;
2411 priv->RfOffReason = 0;
2412 priv->LedStrategy = SW_LED_MODE0;
2413 priv->TxPollingTimes = 0; /* lzm add 080826 */
2414 priv->bLeisurePs = true;
2415 priv->dot11PowerSaveMode = eActive;
2416 priv->AdMinCheckPeriod = 5;
2417 priv->AdMaxCheckPeriod = 10;
2418 priv->AdMaxRxSsThreshold = 30; /* 60->30 */
2419 priv->AdRxSsThreshold = 20; /* 50->20 */
2420 priv->AdCheckPeriod = priv->AdMinCheckPeriod;
2421 priv->AdTickCount = 0;
2422 priv->AdRxSignalStrength = -1;
2423 priv->RegSwAntennaDiversityMechanism = 0;
2424 priv->RegDefaultAntenna = 0;
2425 priv->SignalStrength = 0;
2426 priv->AdRxOkCnt = 0;
2427 priv->CurrAntennaIndex = 0;
2428 priv->AdRxSsBeforeSwitched = 0;
2429 init_timer(&priv->SwAntennaDiversityTimer);
2430 priv->SwAntennaDiversityTimer.data = (unsigned long)dev;
2431 priv->SwAntennaDiversityTimer.function = (void *)SwAntennaDiversityTimerCallback;
2432 priv->bDigMechanism = 1;
2433 priv->InitialGain = 6;
2434 priv->bXtalCalibration = false;
2435 priv->XtalCal_Xin = 0;
2436 priv->XtalCal_Xout = 0;
2437 priv->bTxPowerTrack = false;
2438 priv->ThermalMeter = 0;
2439 priv->FalseAlarmRegValue = 0;
2440 priv->RegDigOfdmFaUpTh = 0xc; /* Upper threshold of OFDM false alarm, which is used in DIG. */
2441 priv->DIG_NumberFallbackVote = 0;
2442 priv->DIG_NumberUpgradeVote = 0;
2443 priv->LastSignalStrengthInPercent = 0;
2444 priv->Stats_SignalStrength = 0;
2445 priv->LastRxPktAntenna = 0;
2446 priv->SignalQuality = 0; /* in 0-100 index. */
2447 priv->Stats_SignalQuality = 0;
2448 priv->RecvSignalPower = 0; /* in dBm. */
2449 priv->Stats_RecvSignalPower = 0;
2450 priv->AdMainAntennaRxOkCnt = 0;
2451 priv->AdAuxAntennaRxOkCnt = 0;
2452 priv->bHWAdSwitched = false;
2453 priv->bRegHighPowerMechanism = true;
2454 priv->RegHiPwrUpperTh = 77;
2455 priv->RegHiPwrLowerTh = 75;
2456 priv->RegRSSIHiPwrUpperTh = 70;
2457 priv->RegRSSIHiPwrLowerTh = 20;
2458 priv->bCurCCKPkt = false;
2459 priv->UndecoratedSmoothedSS = -1;
2460 priv->bToUpdateTxPwr = false;
2461 priv->CurCCKRSSI = 0;
2464 priv->NumTxOkTotal = 0;
2465 priv->NumTxUnicast = 0;
2466 priv->keepAliveLevel = DEFAULT_KEEP_ALIVE_LEVEL;
2467 priv->CurrRetryCnt = 0;
2468 priv->LastRetryCnt = 0;
2469 priv->LastTxokCnt = 0;
2470 priv->LastRxokCnt = 0;
2471 priv->LastRetryRate = 0;
2472 priv->bTryuping = 0;
2473 priv->CurrTxRate = 0;
2474 priv->CurrRetryRate = 0;
2475 priv->TryupingCount = 0;
2476 priv->TryupingCountNoData = 0;
2477 priv->TryDownCountLowData = 0;
2478 priv->LastTxOKBytes = 0;
2479 priv->LastFailTxRate = 0;
2480 priv->LastFailTxRateSS = 0;
2481 priv->FailTxRateCount = 0;
2482 priv->LastTxThroughput = 0;
2483 priv->NumTxOkBytesTotal = 0;
2484 priv->ForcedDataRate = 0;
2485 priv->RegBModeGainStage = 1;
2487 priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
2488 spin_lock_init(&priv->irq_th_lock);
2489 spin_lock_init(&priv->tx_lock);
2490 spin_lock_init(&priv->ps_lock);
2491 spin_lock_init(&priv->rf_ps_lock);
2492 sema_init(&priv->wx_sem, 1);
2493 INIT_WORK(&priv->reset_wq, (void *)rtl8180_restart_wq);
2494 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,
2495 (void *)rtl8180_hw_wakeup_wq);
2496 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,
2497 (void *)rtl8180_hw_sleep_wq);
2498 INIT_WORK(&priv->ieee80211->wmm_param_update_wq,
2499 (void *)rtl8180_wmm_param_update);
2500 INIT_DELAYED_WORK(&priv->ieee80211->rate_adapter_wq,
2501 (void *)rtl8180_rate_adapter);
2502 INIT_DELAYED_WORK(&priv->ieee80211->hw_dig_wq,
2503 (void *)rtl8180_hw_dig_wq);
2504 INIT_DELAYED_WORK(&priv->ieee80211->tx_pw_wq,
2505 (void *)rtl8180_tx_pw_wq);
2506 INIT_DELAYED_WORK(&priv->ieee80211->GPIOChangeRFWorkItem,
2507 (void *) GPIOChangeRFWorkItemCallBack);
2508 tasklet_init(&priv->irq_rx_tasklet,
2509 (void(*)(unsigned long)) rtl8180_irq_rx_tasklet,
2510 (unsigned long)priv);
2512 init_timer(&priv->watch_dog_timer);
2513 priv->watch_dog_timer.data = (unsigned long)dev;
2514 priv->watch_dog_timer.function = watch_dog_adaptive;
2516 init_timer(&priv->rateadapter_timer);
2517 priv->rateadapter_timer.data = (unsigned long)dev;
2518 priv->rateadapter_timer.function = timer_rate_adaptive;
2519 priv->RateAdaptivePeriod = RATE_ADAPTIVE_TIMER_PERIOD;
2520 priv->bEnhanceTxPwr = false;
2522 priv->ieee80211->softmac_hard_start_xmit = rtl8180_hard_start_xmit;
2523 priv->ieee80211->set_chan = rtl8180_set_chan;
2524 priv->ieee80211->link_change = rtl8180_link_change;
2525 priv->ieee80211->softmac_data_hard_start_xmit = rtl8180_hard_data_xmit;
2526 priv->ieee80211->data_hard_stop = rtl8180_data_hard_stop;
2527 priv->ieee80211->data_hard_resume = rtl8180_data_hard_resume;
2529 priv->ieee80211->init_wmmparam_flag = 0;
2531 priv->ieee80211->start_send_beacons = rtl8180_start_tx_beacon;
2532 priv->ieee80211->stop_send_beacons = rtl8180_beacon_tx_disable;
2533 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2535 priv->ShortRetryLimit = 7;
2536 priv->LongRetryLimit = 7;
2537 priv->EarlyRxThreshold = 7;
2539 priv->TransmitConfig = (1<<TCR_DurProcMode_OFFSET) |
2540 (7<<TCR_MXDMA_OFFSET) |
2541 (priv->ShortRetryLimit<<TCR_SRL_OFFSET) |
2542 (priv->LongRetryLimit<<TCR_LRL_OFFSET);
2544 priv->ReceiveConfig = RCR_AMF | RCR_ADF | RCR_ACF |
2545 RCR_AB | RCR_AM | RCR_APM |
2546 (7<<RCR_MXDMA_OFFSET) |
2547 (priv->EarlyRxThreshold<<RCR_FIFO_OFFSET) |
2548 (priv->EarlyRxThreshold == 7 ?
2549 RCR_ONLYERLPKT : 0);
2551 priv->IntrMask = IMR_TMGDOK | IMR_TBDER | IMR_THPDER |
2552 IMR_THPDER | IMR_THPDOK |
2553 IMR_TVODER | IMR_TVODOK |
2554 IMR_TVIDER | IMR_TVIDOK |
2555 IMR_TBEDER | IMR_TBEDOK |
2556 IMR_TBKDER | IMR_TBKDOK |
2561 priv->InitialGain = 6;
2563 DMESG("MAC controller is a RTL8187SE b/g");
2565 priv->ieee80211->modulation |= IEEE80211_OFDM_MODULATION;
2566 priv->ieee80211->short_slot = 1;
2568 eeprom_93cx6_read(&eeprom, EEPROM_SW_REVD_OFFSET, &usValue);
2569 DMESG("usValue is %#hx\n", usValue);
2570 /* 3Read AntennaDiversity */
2572 /* SW Antenna Diversity. */
2573 priv->EEPROMSwAntennaDiversity = (usValue & EEPROM_SW_AD_MASK) ==
2574 EEPROM_SW_AD_ENABLE;
2576 /* Default Antenna to use. */
2577 priv->EEPROMDefaultAntenna1 = (usValue & EEPROM_DEF_ANT_MASK) ==
2580 if (priv->RegSwAntennaDiversityMechanism == 0) /* Auto */
2581 /* 0: default from EEPROM. */
2582 priv->bSwAntennaDiverity = priv->EEPROMSwAntennaDiversity;
2584 /* 1:disable antenna diversity, 2: enable antenna diversity. */
2585 priv->bSwAntennaDiverity = priv->RegSwAntennaDiversityMechanism == 2;
2587 if (priv->RegDefaultAntenna == 0)
2588 /* 0: default from EEPROM. */
2589 priv->bDefaultAntenna1 = priv->EEPROMDefaultAntenna1;
2591 /* 1: main, 2: aux. */
2592 priv->bDefaultAntenna1 = priv->RegDefaultAntenna == 2;
2594 priv->plcp_preamble_mode = 2;
2595 /* the eeprom type is stored in RCR register bit #6 */
2596 if (RCR_9356SEL & read_nic_dword(dev, RCR))
2597 priv->epromtype = EPROM_93c56;
2599 priv->epromtype = EPROM_93c46;
2601 eeprom_93cx6_multiread(&eeprom, 0x7, (__le16 *)
2604 for (i = 1, j = 0; i < 14; i += 2, j++) {
2605 eeprom_93cx6_read(&eeprom, EPROM_TXPW_CH1_2 + j, &word);
2606 priv->chtxpwr[i] = word & 0xff;
2607 priv->chtxpwr[i+1] = (word & 0xff00)>>8;
2609 for (i = 1, j = 0; i < 14; i += 2, j++) {
2610 eeprom_93cx6_read(&eeprom, EPROM_TXPW_OFDM_CH1_2 + j, &word);
2611 priv->chtxpwr_ofdm[i] = word & 0xff;
2612 priv->chtxpwr_ofdm[i+1] = (word & 0xff00) >> 8;
2615 /* 3Read crystal calibration and thermal meter indication on 87SE. */
2616 eeprom_93cx6_read(&eeprom, EEPROM_RSV>>1, &tmpu16);
2618 /* Crystal calibration for Xin and Xout resp. */
2619 priv->XtalCal_Xout = tmpu16 & EEPROM_XTAL_CAL_XOUT_MASK;
2620 priv->XtalCal_Xin = (tmpu16 & EEPROM_XTAL_CAL_XIN_MASK) >> 4;
2621 if ((tmpu16 & EEPROM_XTAL_CAL_ENABLE) >> 12)
2622 priv->bXtalCalibration = true;
2624 /* Thermal meter reference indication. */
2625 priv->ThermalMeter = (u8)((tmpu16 & EEPROM_THERMAL_METER_MASK) >> 8);
2626 if ((tmpu16 & EEPROM_THERMAL_METER_ENABLE) >> 13)
2627 priv->bTxPowerTrack = true;
2629 priv->rf_sleep = rtl8225z4_rf_sleep;
2630 priv->rf_wakeup = rtl8225z4_rf_wakeup;
2631 DMESGW("**PLEASE** REPORT SUCCESSFUL/UNSUCCESSFUL TO Realtek!");
2633 priv->rf_close = rtl8225z2_rf_close;
2634 priv->rf_init = rtl8225z2_rf_init;
2635 priv->rf_set_chan = rtl8225z2_rf_set_chan;
2636 priv->rf_set_sens = NULL;
2638 if (0 != alloc_rx_desc_ring(dev, priv->rxbuffersize, priv->rxringcount))
2641 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2642 TX_MANAGEPRIORITY_RING_ADDR))
2645 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2646 TX_BKPRIORITY_RING_ADDR))
2649 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2650 TX_BEPRIORITY_RING_ADDR))
2653 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2654 TX_VIPRIORITY_RING_ADDR))
2657 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2658 TX_VOPRIORITY_RING_ADDR))
2661 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2662 TX_HIGHPRIORITY_RING_ADDR))
2665 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txbeaconcount,
2666 TX_BEACON_RING_ADDR))
2669 if (request_irq(dev->irq, (void *)rtl8180_interrupt, IRQF_SHARED, dev->name, dev)) {
2670 DMESGE("Error allocating IRQ %d", dev->irq);
2673 priv->irq = dev->irq;
2674 DMESG("IRQ %d", dev->irq);
2680 void rtl8180_no_hw_wep(struct net_device *dev)
2684 void rtl8180_set_hw_wep(struct net_device *dev)
2686 struct r8180_priv *priv = ieee80211_priv(dev);
2691 pgreg = read_nic_byte(dev, PGSELECT);
2692 write_nic_byte(dev, PGSELECT, pgreg & ~(1<<PGSELECT_PG_SHIFT));
2694 key0_word4 = read_nic_dword(dev, KEY0+4+4+4);
2695 key0_word4 &= ~0xff;
2696 key0_word4 |= priv->key0[3] & 0xff;
2697 write_nic_dword(dev, KEY0, (priv->key0[0]));
2698 write_nic_dword(dev, KEY0+4, (priv->key0[1]));
2699 write_nic_dword(dev, KEY0+4+4, (priv->key0[2]));
2700 write_nic_dword(dev, KEY0+4+4+4, (key0_word4));
2702 security = read_nic_byte(dev, SECURITY);
2703 security |= (1<<SECURITY_WEP_TX_ENABLE_SHIFT);
2704 security |= (1<<SECURITY_WEP_RX_ENABLE_SHIFT);
2705 security &= ~SECURITY_ENCRYP_MASK;
2706 security |= (SECURITY_ENCRYP_104<<SECURITY_ENCRYP_SHIFT);
2708 write_nic_byte(dev, SECURITY, security);
2710 DMESG("key %x %x %x %x", read_nic_dword(dev, KEY0+4+4+4),
2711 read_nic_dword(dev, KEY0+4+4), read_nic_dword(dev, KEY0+4),
2712 read_nic_dword(dev, KEY0));
2716 void rtl8185_rf_pins_enable(struct net_device *dev)
2719 /* tmp = read_nic_word(dev, RFPinsEnable); */
2720 write_nic_word(dev, RFPinsEnable, 0x1fff); /* | tmp); */
2723 void rtl8185_set_anaparam2(struct net_device *dev, u32 a)
2727 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
2729 conf3 = read_nic_byte(dev, CONFIG3);
2730 write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
2731 write_nic_dword(dev, ANAPARAM2, a);
2733 conf3 = read_nic_byte(dev, CONFIG3);
2734 write_nic_byte(dev, CONFIG3, conf3 & ~(1<<CONFIG3_ANAPARAM_W_SHIFT));
2735 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
2738 void rtl8180_set_anaparam(struct net_device *dev, u32 a)
2742 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
2744 conf3 = read_nic_byte(dev, CONFIG3);
2745 write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
2746 write_nic_dword(dev, ANAPARAM, a);
2748 conf3 = read_nic_byte(dev, CONFIG3);
2749 write_nic_byte(dev, CONFIG3, conf3 & ~(1<<CONFIG3_ANAPARAM_W_SHIFT));
2750 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
2753 void rtl8185_tx_antenna(struct net_device *dev, u8 ant)
2755 write_nic_byte(dev, TX_ANTENNA, ant);
2756 force_pci_posting(dev);
2760 void rtl8185_write_phy(struct net_device *dev, u8 adr, u32 data)
2766 phyw = ((data<<8) | adr);
2768 /* Note that, we must write 0xff7c after 0x7d-0x7f to write BB register. */
2769 write_nic_byte(dev, 0x7f, ((phyw & 0xff000000) >> 24));
2770 write_nic_byte(dev, 0x7e, ((phyw & 0x00ff0000) >> 16));
2771 write_nic_byte(dev, 0x7d, ((phyw & 0x0000ff00) >> 8));
2772 write_nic_byte(dev, 0x7c, ((phyw & 0x000000ff)));
2774 /* this is ok to fail when we write AGC table. check for AGC table might be
2775 * done by masking with 0x7f instead of 0xff
2777 /* if (phyr != (data&0xff)) DMESGW("Phy write timeout %x %x %x", phyr, data, adr); */
2780 inline void write_phy_ofdm(struct net_device *dev, u8 adr, u32 data)
2783 rtl8185_write_phy(dev, adr, data);
2786 void write_phy_cck(struct net_device *dev, u8 adr, u32 data)
2789 rtl8185_write_phy(dev, adr, data | 0x10000);
2793 * This configures registers for beacon tx and enables it via
2794 * rtl8180_beacon_tx_enable(). rtl8180_beacon_tx_disable() might
2795 * be used to stop beacon transmission
2797 void rtl8180_start_tx_beacon(struct net_device *dev)
2801 DMESG("Enabling beacon TX");
2802 rtl8180_prepare_beacon(dev);
2803 rtl8180_irq_disable(dev);
2804 rtl8180_beacon_tx_enable(dev);
2806 word = read_nic_word(dev, AtimWnd) & ~AtimWnd_AtimWnd;
2807 write_nic_word(dev, AtimWnd, word); /* word |= */
2809 word = read_nic_word(dev, BintrItv);
2810 word &= ~BintrItv_BintrItv;
2811 word |= 1000; /* priv->ieee80211->current_network.beacon_interval *
2812 ((priv->txbeaconcount > 1)?(priv->txbeaconcount-1):1);
2813 // FIXME: check if correct ^^ worked with 0x3e8;
2815 write_nic_word(dev, BintrItv, word);
2817 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
2819 rtl8185b_irq_enable(dev);
2822 static struct net_device_stats *rtl8180_stats(struct net_device *dev)
2824 struct r8180_priv *priv = ieee80211_priv(dev);
2826 return &priv->ieee80211->stats;
2830 * Change current and default preamble mode.
2833 MgntActSet_802_11_PowerSaveMode(
2834 struct r8180_priv *priv,
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 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 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 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 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 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 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 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 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 *)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");
3271 pci_set_drvdata(pdev, NULL);
3275 static void rtl8180_pci_remove(struct pci_dev *pdev)
3277 struct r8180_priv *priv;
3278 struct net_device *dev = pci_get_drvdata(pdev);
3281 unregister_netdev(dev);
3283 priv = ieee80211_priv(dev);
3285 rtl8180_proc_remove_one(dev);
3287 priv->rf_close(dev);
3292 DMESG("Freeing irq %d", dev->irq);
3293 free_irq(dev->irq, dev);
3297 free_rx_desc_ring(dev);
3298 free_tx_desc_rings(dev);
3300 if (dev->mem_start != (unsigned long)NULL) {
3301 iounmap((void *)dev->mem_start);
3302 release_mem_region(pci_resource_start(pdev, 1),
3303 pci_resource_len(pdev, 1));
3306 free_ieee80211(dev);
3308 pci_disable_device(pdev);
3310 DMESG("wlan driver removed\n");
3313 /* fun with the built-in ieee80211 stack... */
3314 extern int ieee80211_crypto_init(void);
3315 extern void ieee80211_crypto_deinit(void);
3316 extern int ieee80211_crypto_tkip_init(void);
3317 extern void ieee80211_crypto_tkip_exit(void);
3318 extern int ieee80211_crypto_ccmp_init(void);
3319 extern void ieee80211_crypto_ccmp_exit(void);
3320 extern int ieee80211_crypto_wep_init(void);
3321 extern void ieee80211_crypto_wep_exit(void);
3323 static int __init rtl8180_pci_module_init(void)
3327 ret = ieee80211_crypto_init();
3329 pr_err("ieee80211_crypto_init() failed %d\n", ret);
3332 ret = ieee80211_crypto_tkip_init();
3334 pr_err("ieee80211_crypto_tkip_init() failed %d\n", ret);
3337 ret = ieee80211_crypto_ccmp_init();
3339 pr_err("ieee80211_crypto_ccmp_init() failed %d\n", ret);
3342 ret = ieee80211_crypto_wep_init();
3344 pr_err("ieee80211_crypto_wep_init() failed %d\n", ret);
3348 pr_info("\nLinux kernel driver for RTL8180 / RTL8185 based WLAN cards\n");
3349 pr_info("Copyright (c) 2004-2005, Andrea Merello\n");
3350 DMESG("Initializing module");
3351 DMESG("Wireless extensions version %d", WIRELESS_EXT);
3352 rtl8180_proc_module_init();
3354 if (pci_register_driver(&rtl8180_pci_driver)) {
3355 DMESG("No device found");
3361 static void __exit rtl8180_pci_module_exit(void)
3363 pci_unregister_driver(&rtl8180_pci_driver);
3364 rtl8180_proc_module_remove();
3365 ieee80211_crypto_tkip_exit();
3366 ieee80211_crypto_ccmp_exit();
3367 ieee80211_crypto_wep_exit();
3368 ieee80211_crypto_deinit();
3372 void rtl8180_try_wake_queue(struct net_device *dev, int pri)
3374 unsigned long flags;
3376 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3378 spin_lock_irqsave(&priv->tx_lock, flags);
3379 enough_desc = check_nic_enought_desc(dev, pri);
3380 spin_unlock_irqrestore(&priv->tx_lock, flags);
3383 ieee80211_rtl_wake_queue(priv->ieee80211);
3386 void rtl8180_tx_isr(struct net_device *dev, int pri, short error)
3388 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3389 u32 *tail; /* tail virtual addr */
3390 u32 *head; /* head virtual addr */
3391 u32 *begin; /* start of ring virtual addr */
3392 u32 *nicv; /* nic pointer virtual addr */
3393 u32 nic; /* nic pointer physical addr */
3394 u32 nicbegin; /* start of ring physical addr */
3396 /* physical addr are ok on 32 bits since we set DMA mask */
3401 priv->stats.txretry++; /* tony 20060601 */
3402 spin_lock_irqsave(&priv->tx_lock, flag);
3404 case MANAGE_PRIORITY:
3405 tail = priv->txmapringtail;
3406 begin = priv->txmapring;
3407 head = priv->txmapringhead;
3408 nic = read_nic_dword(dev, TX_MANAGEPRIORITY_RING_ADDR);
3409 nicbegin = priv->txmapringdma;
3412 tail = priv->txbkpringtail;
3413 begin = priv->txbkpring;
3414 head = priv->txbkpringhead;
3415 nic = read_nic_dword(dev, TX_BKPRIORITY_RING_ADDR);
3416 nicbegin = priv->txbkpringdma;
3419 tail = priv->txbepringtail;
3420 begin = priv->txbepring;
3421 head = priv->txbepringhead;
3422 nic = read_nic_dword(dev, TX_BEPRIORITY_RING_ADDR);
3423 nicbegin = priv->txbepringdma;
3426 tail = priv->txvipringtail;
3427 begin = priv->txvipring;
3428 head = priv->txvipringhead;
3429 nic = read_nic_dword(dev, TX_VIPRIORITY_RING_ADDR);
3430 nicbegin = priv->txvipringdma;
3433 tail = priv->txvopringtail;
3434 begin = priv->txvopring;
3435 head = priv->txvopringhead;
3436 nic = read_nic_dword(dev, TX_VOPRIORITY_RING_ADDR);
3437 nicbegin = priv->txvopringdma;
3440 tail = priv->txhpringtail;
3441 begin = priv->txhpring;
3442 head = priv->txhpringhead;
3443 nic = read_nic_dword(dev, TX_HIGHPRIORITY_RING_ADDR);
3444 nicbegin = priv->txhpringdma;
3448 spin_unlock_irqrestore(&priv->tx_lock, flag);
3452 nicv = (u32 *)((nic - nicbegin) + (u8 *)begin);
3453 if ((head <= tail && (nicv > tail || nicv < head)) ||
3454 (head > tail && (nicv > tail && nicv < head))) {
3455 DMESGW("nic has lost pointer");
3456 spin_unlock_irqrestore(&priv->tx_lock, flag);
3457 rtl8180_restart(dev);
3462 * We check all the descriptors between the head and the nic,
3463 * but not the currently pointed by the nic (the next to be txed)
3464 * and the previous of the pointed (might be in process ??)
3466 offs = (nic - nicbegin);
3467 offs = offs / 8 / 4;
3468 hd = (head - begin) / 8;
3473 j = offs + (priv->txringcount-1-hd);
3479 for (i = 0; i < j; i++) {
3480 if ((*head) & (1<<31))
3482 if (((*head)&(0x10000000)) != 0) {
3483 priv->CurrRetryCnt += (u16)((*head) & (0x000000ff));
3485 priv->NumTxOkTotal++;
3489 priv->NumTxOkBytesTotal += (*(head+3)) & (0x00000fff);
3491 *head = *head & ~(1<<31);
3493 if ((head - begin)/8 == priv->txringcount-1)
3500 * The head has been moved to the last certainly TXed
3501 * (or at least processed by the nic) packet.
3502 * The driver take forcefully owning of all these packets
3503 * If the packet previous of the nic pointer has been
3504 * processed this doesn't matter: it will be checked
3505 * here at the next round. Anyway if no more packet are
3506 * TXed no memory leak occur at all.
3510 case MANAGE_PRIORITY:
3511 priv->txmapringhead = head;
3513 if (priv->ack_tx_to_ieee) {
3514 if (rtl8180_is_tx_queue_empty(dev)) {
3515 priv->ack_tx_to_ieee = 0;
3516 ieee80211_ps_tx_ack(priv->ieee80211, !error);
3521 priv->txbkpringhead = head;
3524 priv->txbepringhead = head;
3527 priv->txvipringhead = head;
3530 priv->txvopringhead = head;
3533 priv->txhpringhead = head;
3537 spin_unlock_irqrestore(&priv->tx_lock, flag);
3540 irqreturn_t rtl8180_interrupt(int irq, void *netdev, struct pt_regs *regs)
3542 struct net_device *dev = (struct net_device *) netdev;
3543 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3544 unsigned long flags;
3547 /* We should return IRQ_NONE, but for now let me keep this */
3548 if (priv->irq_enabled == 0)
3551 spin_lock_irqsave(&priv->irq_th_lock, flags);
3554 inta = read_nic_dword(dev, ISR); /* & priv->IntrMask; */
3555 write_nic_dword(dev, ISR, inta); /* reset int situation */
3557 priv->stats.shints++;
3560 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3563 * most probably we can safely return IRQ_NONE,
3564 * but for now is better to avoid problems
3568 if (inta == 0xffff) {
3569 /* HW disappeared */
3570 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3576 if (!netif_running(dev)) {
3577 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3581 if (inta & ISR_TimeOut)
3582 write_nic_dword(dev, TimerInt, 0);
3584 if (inta & ISR_TBDOK)
3585 priv->stats.txbeacon++;
3587 if (inta & ISR_TBDER)
3588 priv->stats.txbeaconerr++;
3590 if (inta & IMR_TMGDOK)
3591 rtl8180_tx_isr(dev, MANAGE_PRIORITY, 0);
3593 if (inta & ISR_THPDER) {
3594 priv->stats.txhperr++;
3595 rtl8180_tx_isr(dev, HI_PRIORITY, 1);
3596 priv->ieee80211->stats.tx_errors++;
3599 if (inta & ISR_THPDOK) { /* High priority tx ok */
3600 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3601 priv->stats.txhpokint++;
3602 rtl8180_tx_isr(dev, HI_PRIORITY, 0);
3606 priv->stats.rxerr++;
3608 if (inta & ISR_TBKDER) { /* corresponding to BK_PRIORITY */
3609 priv->stats.txbkperr++;
3610 priv->ieee80211->stats.tx_errors++;
3611 rtl8180_tx_isr(dev, BK_PRIORITY, 1);
3612 rtl8180_try_wake_queue(dev, BK_PRIORITY);
3615 if (inta & ISR_TBEDER) { /* corresponding to BE_PRIORITY */
3616 priv->stats.txbeperr++;
3617 priv->ieee80211->stats.tx_errors++;
3618 rtl8180_tx_isr(dev, BE_PRIORITY, 1);
3619 rtl8180_try_wake_queue(dev, BE_PRIORITY);
3621 if (inta & ISR_TNPDER) { /* corresponding to VO_PRIORITY */
3622 priv->stats.txnperr++;
3623 priv->ieee80211->stats.tx_errors++;
3624 rtl8180_tx_isr(dev, NORM_PRIORITY, 1);
3625 rtl8180_try_wake_queue(dev, NORM_PRIORITY);
3628 if (inta & ISR_TLPDER) { /* corresponding to VI_PRIORITY */
3629 priv->stats.txlperr++;
3630 priv->ieee80211->stats.tx_errors++;
3631 rtl8180_tx_isr(dev, LOW_PRIORITY, 1);
3632 rtl8180_try_wake_queue(dev, LOW_PRIORITY);
3635 if (inta & ISR_ROK) {
3636 priv->stats.rxint++;
3637 tasklet_schedule(&priv->irq_rx_tasklet);
3640 if (inta & ISR_RQoSOK) {
3641 priv->stats.rxint++;
3642 tasklet_schedule(&priv->irq_rx_tasklet);
3645 if (inta & ISR_BcnInt)
3646 rtl8180_prepare_beacon(dev);
3648 if (inta & ISR_RDU) {
3649 DMESGW("No RX descriptor available");
3650 priv->stats.rxrdu++;
3651 tasklet_schedule(&priv->irq_rx_tasklet);
3654 if (inta & ISR_RXFOVW) {
3655 priv->stats.rxoverflow++;
3656 tasklet_schedule(&priv->irq_rx_tasklet);
3659 if (inta & ISR_TXFOVW)
3660 priv->stats.txoverflow++;
3662 if (inta & ISR_TNPDOK) { /* Normal priority tx ok */
3663 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3664 priv->stats.txnpokint++;
3665 rtl8180_tx_isr(dev, NORM_PRIORITY, 0);
3666 rtl8180_try_wake_queue(dev, NORM_PRIORITY);
3669 if (inta & ISR_TLPDOK) { /* Low priority tx ok */
3670 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3671 priv->stats.txlpokint++;
3672 rtl8180_tx_isr(dev, LOW_PRIORITY, 0);
3673 rtl8180_try_wake_queue(dev, LOW_PRIORITY);
3676 if (inta & ISR_TBKDOK) { /* corresponding to BK_PRIORITY */
3677 priv->stats.txbkpokint++;
3678 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3679 rtl8180_tx_isr(dev, BK_PRIORITY, 0);
3680 rtl8180_try_wake_queue(dev, BE_PRIORITY);
3683 if (inta & ISR_TBEDOK) { /* corresponding to BE_PRIORITY */
3684 priv->stats.txbeperr++;
3685 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3686 rtl8180_tx_isr(dev, BE_PRIORITY, 0);
3687 rtl8180_try_wake_queue(dev, BE_PRIORITY);
3689 force_pci_posting(dev);
3690 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3695 void rtl8180_irq_rx_tasklet(struct r8180_priv *priv)
3697 rtl8180_rx(priv->dev);
3700 void GPIOChangeRFWorkItemCallBack(struct work_struct *work)
3702 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, GPIOChangeRFWorkItem.work);
3703 struct net_device *dev = ieee->dev;
3704 struct r8180_priv *priv = ieee80211_priv(dev);
3707 RT_RF_POWER_STATE eRfPowerStateToSet;
3708 bool bActuallySet = false;
3711 static char *RadioPowerPath = "/etc/acpi/events/RadioPower.sh";
3712 static char *envp[] = {"HOME=/", "TERM=linux", "PATH=/usr/bin:/bin", NULL};
3713 static int readf_count;
3715 readf_count = (readf_count+1)%0xffff;
3716 /* We should turn off LED before polling FF51[4]. */
3719 btPSR = read_nic_byte(dev, PSR);
3720 write_nic_byte(dev, PSR, (btPSR & ~BIT3));
3722 /* It need to delay 4us suggested by Jong, 2008-01-16 */
3725 /* HW radio On/Off according to the value of FF51[4](config0) */
3726 btConfig0 = btPSR = read_nic_byte(dev, CONFIG0);
3728 eRfPowerStateToSet = (btConfig0 & BIT4) ? eRfOn : eRfOff;
3730 /* Turn LED back on when radio enabled */
3731 if (eRfPowerStateToSet == eRfOn)
3732 write_nic_byte(dev, PSR, btPSR | BIT3);
3734 if ((priv->ieee80211->bHwRadioOff == true) &&
3735 (eRfPowerStateToSet == eRfOn)) {
3736 priv->ieee80211->bHwRadioOff = false;
3737 bActuallySet = true;
3738 } else if ((priv->ieee80211->bHwRadioOff == false) &&
3739 (eRfPowerStateToSet == eRfOff)) {
3740 priv->ieee80211->bHwRadioOff = true;
3741 bActuallySet = true;
3745 MgntActSet_RF_State(dev, eRfPowerStateToSet, RF_CHANGE_BY_HW);
3747 /* To update the UI status for Power status changed */
3748 if (priv->ieee80211->bHwRadioOff == true)
3752 argv[0] = RadioPowerPath;
3755 call_usermodehelper(RadioPowerPath, argv, envp, UMH_WAIT_PROC);
3759 module_init(rtl8180_pci_module_init);
3760 module_exit(rtl8180_pci_module_exit);