2 This is part of rtl818x pci OpenSource driver - v 0.1
3 Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it>
4 Released under the terms of GPL (General Public License)
6 Parts of this driver are based on the GPL part of the official
9 Parts of this driver are based on the rtl8180 driver skeleton
10 from Patric Schenke & Andres Salomon.
12 Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver.
14 Parts of BB/RF code are derived from David Young rtl8180 netbsd driver.
16 RSSI calc function from 'The Deuce'
18 Some ideas borrowed from the 8139too.c driver included in linux kernel.
20 We (I?) want to thanks the Authors of those projecs and also the
21 Ndiswrapper's project Authors.
23 A big big thanks goes also to Realtek corp. for their help in my attempt to
24 add RTL8185 and RTL8225 support, and to David Young also.
26 Power management interface routines.
27 Written by Mariusz Matuszek.
30 #undef RX_DONT_PASS_UL
33 #include <linux/slab.h>
34 #include <linux/syscalls.h>
35 #include <linux/eeprom_93cx6.h>
36 #include <linux/interrupt.h>
40 #include "r8180_rtl8225.h" /* RTL8225 Radio frontend */
41 #include "r8180_93cx6.h" /* Card EEPROM */
45 #include "ieee80211/dot11d.h"
47 static struct pci_device_id rtl8180_pci_id_tbl[] __devinitdata = {
49 .vendor = PCI_VENDOR_ID_REALTEK,
51 .subvendor = PCI_ANY_ID,
52 .subdevice = PCI_ANY_ID,
65 static char ifname[IFNAMSIZ] = "wlan%d";
66 static int hwseqnum = 0;
68 static int channels = 0x3fff;
70 MODULE_LICENSE("GPL");
71 MODULE_DEVICE_TABLE(pci, rtl8180_pci_id_tbl);
72 MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
73 MODULE_DESCRIPTION("Linux driver for Realtek RTL8180 / RTL8185 WiFi cards");
76 module_param_string(ifname, ifname, sizeof(ifname), S_IRUGO|S_IWUSR);
77 module_param(hwseqnum, int, S_IRUGO|S_IWUSR);
78 module_param(hwwep, int, S_IRUGO|S_IWUSR);
79 module_param(channels, int, S_IRUGO|S_IWUSR);
81 MODULE_PARM_DESC(devname, " Net interface name, wlan%d=default");
82 MODULE_PARM_DESC(hwseqnum, " Try to use hardware 802.11 header sequence numbers. Zero=default");
83 MODULE_PARM_DESC(hwwep, " Try to use hardware WEP support. Still broken and not available on all cards");
84 MODULE_PARM_DESC(channels, " Channel bitmask for specific locales. NYI");
87 static int __devinit rtl8180_pci_probe(struct pci_dev *pdev,
88 const struct pci_device_id *id);
90 static void __devexit rtl8180_pci_remove(struct pci_dev *pdev);
92 static void rtl8180_shutdown(struct pci_dev *pdev)
94 struct net_device *dev = pci_get_drvdata(pdev);
95 if (dev->netdev_ops->ndo_stop)
96 dev->netdev_ops->ndo_stop(dev);
97 pci_disable_device(pdev);
100 static int rtl8180_suspend(struct pci_dev *pdev, pm_message_t state)
102 struct net_device *dev = pci_get_drvdata(pdev);
104 if (!netif_running(dev))
105 goto out_pci_suspend;
107 if (dev->netdev_ops->ndo_stop)
108 dev->netdev_ops->ndo_stop(dev);
110 netif_device_detach(dev);
113 pci_save_state(pdev);
114 pci_disable_device(pdev);
115 pci_set_power_state(pdev, pci_choose_state(pdev, state));
119 static int rtl8180_resume(struct pci_dev *pdev)
121 struct net_device *dev = pci_get_drvdata(pdev);
125 pci_set_power_state(pdev, PCI_D0);
127 err = pci_enable_device(pdev);
129 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
135 pci_restore_state(pdev);
138 * Suspend/Resume resets the PCI configuration space, so we have to
139 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
140 * from interfering with C3 CPU state. pci_restore_state won't help
141 * here since it only restores the first 64 bytes pci config header.
143 pci_read_config_dword(pdev, 0x40, &val);
144 if ((val & 0x0000ff00) != 0)
145 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
147 if (!netif_running(dev))
150 if (dev->netdev_ops->ndo_open)
151 dev->netdev_ops->ndo_open(dev);
153 netif_device_attach(dev);
158 static struct pci_driver rtl8180_pci_driver = {
159 .name = RTL8180_MODULE_NAME,
160 .id_table = rtl8180_pci_id_tbl,
161 .probe = rtl8180_pci_probe,
162 .remove = __devexit_p(rtl8180_pci_remove),
163 .suspend = rtl8180_suspend,
164 .resume = rtl8180_resume,
165 .shutdown = rtl8180_shutdown,
168 u8 read_nic_byte(struct net_device *dev, int x)
170 return 0xff&readb((u8 *)dev->mem_start + x);
173 u32 read_nic_dword(struct net_device *dev, int x)
175 return readl((u8 *)dev->mem_start + x);
178 u16 read_nic_word(struct net_device *dev, int x)
180 return readw((u8 *)dev->mem_start + x);
183 void write_nic_byte(struct net_device *dev, int x, u8 y)
185 writeb(y, (u8 *)dev->mem_start + x);
189 void write_nic_dword(struct net_device *dev, int x, u32 y)
191 writel(y, (u8 *)dev->mem_start + x);
195 void write_nic_word(struct net_device *dev, int x, u16 y)
197 writew(y, (u8 *)dev->mem_start + x);
201 inline void force_pci_posting(struct net_device *dev)
203 read_nic_byte(dev, EPROM_CMD);
207 irqreturn_t rtl8180_interrupt(int irq, void *netdev, struct pt_regs *regs);
208 void set_nic_rxring(struct net_device *dev);
209 void set_nic_txring(struct net_device *dev);
210 static struct net_device_stats *rtl8180_stats(struct net_device *dev);
211 void rtl8180_commit(struct net_device *dev);
212 void rtl8180_start_tx_beacon(struct net_device *dev);
214 static struct proc_dir_entry *rtl8180_proc = NULL;
216 static int proc_get_registers(char *page, char **start,
217 off_t offset, int count,
218 int *eof, void *data)
220 struct net_device *dev = data;
225 /* This dump the current register page */
226 for (n = 0; n <= max;) {
227 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
229 for (i = 0; i < 16 && n <= max; i++, n++)
230 len += snprintf(page + len, count - len, "%2x ",
231 read_nic_byte(dev, n));
233 len += snprintf(page + len, count - len, "\n");
239 int get_curr_tx_free_desc(struct net_device *dev, int priority);
241 static int proc_get_stats_hw(char *page, char **start,
242 off_t offset, int count,
243 int *eof, void *data)
251 static int proc_get_stats_rx(char *page, char **start,
252 off_t offset, int count,
253 int *eof, void *data)
255 struct net_device *dev = data;
256 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
260 len += snprintf(page + len, count - len,
263 "RX CRC Error(0-500): %lu\n"
264 "RX CRC Error(500-1000): %lu\n"
265 "RX CRC Error(>1000): %lu\n"
266 "RX ICV Error: %lu\n",
269 priv->stats.rxcrcerrmin,
270 priv->stats.rxcrcerrmid,
271 priv->stats.rxcrcerrmax,
279 static int proc_get_stats_tx(char *page, char **start,
280 off_t offset, int count,
281 int *eof, void *data)
283 struct net_device *dev = data;
284 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
287 unsigned long totalOK;
289 totalOK = priv->stats.txnpokint+priv->stats.txhpokint+priv->stats.txlpokint;
290 len += snprintf(page + len, count - len,
294 "TX beacon OK: %lu\n"
295 "TX beacon error: %lu\n",
297 priv->stats.txnperr+priv->stats.txhperr+priv->stats.txlperr,
299 priv->stats.txbeacon,
300 priv->stats.txbeaconerr
307 void rtl8180_proc_module_init(void)
309 DMESG("Initializing proc filesystem");
310 rtl8180_proc = proc_mkdir(RTL8180_MODULE_NAME, init_net.proc_net);
313 void rtl8180_proc_module_remove(void)
315 remove_proc_entry(RTL8180_MODULE_NAME, init_net.proc_net);
318 void rtl8180_proc_remove_one(struct net_device *dev)
320 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
322 remove_proc_entry("stats-hw", priv->dir_dev);
323 remove_proc_entry("stats-tx", priv->dir_dev);
324 remove_proc_entry("stats-rx", priv->dir_dev);
325 remove_proc_entry("registers", priv->dir_dev);
326 remove_proc_entry(dev->name, rtl8180_proc);
327 priv->dir_dev = NULL;
331 void rtl8180_proc_init_one(struct net_device *dev)
333 struct proc_dir_entry *e;
334 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
336 priv->dir_dev = rtl8180_proc;
337 if (!priv->dir_dev) {
338 DMESGE("Unable to initialize /proc/net/r8180/%s\n",
343 e = create_proc_read_entry("stats-hw", S_IFREG | S_IRUGO,
344 priv->dir_dev, proc_get_stats_hw, dev);
346 DMESGE("Unable to initialize "
347 "/proc/net/r8180/%s/stats-hw\n",
351 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
352 priv->dir_dev, proc_get_stats_rx, dev);
354 DMESGE("Unable to initialize "
355 "/proc/net/r8180/%s/stats-rx\n",
360 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
361 priv->dir_dev, proc_get_stats_tx, dev);
363 DMESGE("Unable to initialize "
364 "/proc/net/r8180/%s/stats-tx\n",
368 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
369 priv->dir_dev, proc_get_registers, dev);
371 DMESGE("Unable to initialize "
372 "/proc/net/r8180/%s/registers\n",
378 FIXME: check if we can use some standard already-existent
379 data type+functions in kernel
382 short buffer_add(struct buffer **buffer, u32 *buf, dma_addr_t dma,
383 struct buffer **bufferhead)
389 *buffer = kmalloc(sizeof(struct buffer), GFP_KERNEL);
391 if (*buffer == NULL) {
392 DMESGE("Failed to kmalloc head of TX/RX struct");
395 (*buffer)->next = *buffer;
396 (*buffer)->buf = buf;
397 (*buffer)->dma = dma;
398 if (bufferhead != NULL)
399 (*bufferhead) = (*buffer);
404 while (tmp->next != (*buffer))
406 tmp->next = kmalloc(sizeof(struct buffer), GFP_KERNEL);
407 if (tmp->next == NULL) {
408 DMESGE("Failed to kmalloc TX/RX struct");
411 tmp->next->buf = buf;
412 tmp->next->dma = dma;
413 tmp->next->next = *buffer;
418 void buffer_free(struct net_device *dev, struct buffer **buffer, int len, short consistent)
421 struct buffer *tmp, *next;
422 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
423 struct pci_dev *pdev = priv->pdev;
433 pci_free_consistent(pdev, len,
436 pci_unmap_single(pdev, tmp->dma,
437 len, PCI_DMA_FROMDEVICE);
443 while (next != *buffer);
448 void print_buffer(u32 *buffer, int len)
451 u8 *buf = (u8 *)buffer;
453 printk("ASCII BUFFER DUMP (len: %x):\n", len);
455 for (i = 0; i < len; i++)
456 printk("%c", buf[i]);
458 printk("\nBINARY BUFFER DUMP (len: %x):\n", len);
460 for (i = 0; i < len; i++)
461 printk("%02x", buf[i]);
466 int get_curr_tx_free_desc(struct net_device *dev, int priority)
468 struct r8180_priv *priv = ieee80211_priv(dev);
474 case MANAGE_PRIORITY:
475 head = priv->txmapringhead;
476 tail = priv->txmapringtail;
479 head = priv->txbkpringhead;
480 tail = priv->txbkpringtail;
483 head = priv->txbepringhead;
484 tail = priv->txbepringtail;
487 head = priv->txvipringhead;
488 tail = priv->txvipringtail;
491 head = priv->txvopringhead;
492 tail = priv->txvopringtail;
495 head = priv->txhpringhead;
496 tail = priv->txhpringtail;
503 ret = priv->txringcount - (tail - head)/8;
505 ret = (head - tail)/8;
507 if (ret > priv->txringcount)
513 short check_nic_enought_desc(struct net_device *dev, int priority)
515 struct r8180_priv *priv = ieee80211_priv(dev);
516 struct ieee80211_device *ieee = netdev_priv(dev);
517 int requiredbyte, required;
519 requiredbyte = priv->ieee80211->fts + sizeof(struct ieee80211_header_data);
521 if (ieee->current_network.QoS_Enable)
524 required = requiredbyte / (priv->txbuffsize-4);
526 if (requiredbyte % priv->txbuffsize)
529 /* for now we keep two free descriptor as a safety boundary
530 * between the tail and the head
533 return (required+2 < get_curr_tx_free_desc(dev, priority));
536 void fix_tx_fifo(struct net_device *dev)
538 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
542 for (tmp = priv->txmapring, i = 0;
543 i < priv->txringcount;
545 *tmp = *tmp & ~(1<<31);
548 for (tmp = priv->txbkpring, i = 0;
549 i < priv->txringcount;
551 *tmp = *tmp & ~(1<<31);
554 for (tmp = priv->txbepring, i = 0;
555 i < priv->txringcount;
557 *tmp = *tmp & ~(1<<31);
559 for (tmp = priv->txvipring, i = 0;
560 i < priv->txringcount;
562 *tmp = *tmp & ~(1<<31);
565 for (tmp = priv->txvopring, i = 0;
566 i < priv->txringcount;
568 *tmp = *tmp & ~(1<<31);
571 for (tmp = priv->txhpring, i = 0;
572 i < priv->txringcount;
574 *tmp = *tmp & ~(1<<31);
577 for (tmp = priv->txbeaconring, i = 0;
578 i < priv->txbeaconcount;
580 *tmp = *tmp & ~(1<<31);
583 priv->txmapringtail = priv->txmapring;
584 priv->txmapringhead = priv->txmapring;
585 priv->txmapbufstail = priv->txmapbufs;
587 priv->txbkpringtail = priv->txbkpring;
588 priv->txbkpringhead = priv->txbkpring;
589 priv->txbkpbufstail = priv->txbkpbufs;
591 priv->txbepringtail = priv->txbepring;
592 priv->txbepringhead = priv->txbepring;
593 priv->txbepbufstail = priv->txbepbufs;
595 priv->txvipringtail = priv->txvipring;
596 priv->txvipringhead = priv->txvipring;
597 priv->txvipbufstail = priv->txvipbufs;
599 priv->txvopringtail = priv->txvopring;
600 priv->txvopringhead = priv->txvopring;
601 priv->txvopbufstail = priv->txvopbufs;
603 priv->txhpringtail = priv->txhpring;
604 priv->txhpringhead = priv->txhpring;
605 priv->txhpbufstail = priv->txhpbufs;
607 priv->txbeaconringtail = priv->txbeaconring;
608 priv->txbeaconbufstail = priv->txbeaconbufs;
611 ieee80211_reset_queue(priv->ieee80211);
612 priv->ack_tx_to_ieee = 0;
615 void fix_rx_fifo(struct net_device *dev)
617 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
619 struct buffer *rxbuf;
622 rx_desc_size = 8; /* 4*8 = 32 bytes */
624 for (tmp = priv->rxring, rxbuf = priv->rxbufferhead;
625 (tmp < (priv->rxring)+(priv->rxringcount)*rx_desc_size);
626 tmp += rx_desc_size, rxbuf = rxbuf->next) {
627 *(tmp+2) = rxbuf->dma;
628 *tmp = *tmp & ~0xfff;
629 *tmp = *tmp | priv->rxbuffersize;
633 priv->rxringtail = priv->rxring;
634 priv->rxbuffer = priv->rxbufferhead;
635 priv->rx_skb_complete = 1;
639 unsigned char QUALITY_MAP[] = {
640 0x64, 0x64, 0x64, 0x63, 0x63, 0x62, 0x62, 0x61,
641 0x61, 0x60, 0x60, 0x5f, 0x5f, 0x5e, 0x5d, 0x5c,
642 0x5b, 0x5a, 0x59, 0x57, 0x56, 0x54, 0x52, 0x4f,
643 0x4c, 0x49, 0x45, 0x41, 0x3c, 0x37, 0x31, 0x29,
644 0x24, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
645 0x22, 0x22, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20,
646 0x20, 0x20, 0x20, 0x1f, 0x1f, 0x1e, 0x1e, 0x1e,
647 0x1d, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a, 0x19, 0x19,
648 0x18, 0x17, 0x16, 0x15, 0x14, 0x12, 0x11, 0x0f,
649 0x0e, 0x0c, 0x0a, 0x08, 0x06, 0x04, 0x01, 0x00
652 unsigned char STRENGTH_MAP[] = {
653 0x64, 0x64, 0x63, 0x62, 0x61, 0x60, 0x5f, 0x5e,
654 0x5d, 0x5c, 0x5b, 0x5a, 0x57, 0x54, 0x52, 0x50,
655 0x4e, 0x4c, 0x4a, 0x48, 0x46, 0x44, 0x41, 0x3f,
656 0x3c, 0x3a, 0x37, 0x36, 0x36, 0x1c, 0x1c, 0x1b,
657 0x1b, 0x1a, 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17,
658 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13,
659 0x13, 0x12, 0x12, 0x11, 0x11, 0x10, 0x10, 0x0f,
660 0x0f, 0x0e, 0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0b,
661 0x0b, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x07,
662 0x07, 0x06, 0x06, 0x05, 0x04, 0x03, 0x02, 0x00
665 void rtl8180_RSSI_calc(struct net_device *dev, u8 *rssi, u8 *qual)
675 _rssi = 0; /* avoid gcc complains.. */
678 temp = QUALITY_MAP[q];
699 void rtl8180_irq_enable(struct net_device *dev)
701 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
703 priv->irq_enabled = 1;
704 write_nic_word(dev, INTA_MASK, priv->irq_mask);
707 void rtl8180_irq_disable(struct net_device *dev)
709 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
711 write_nic_dword(dev, IMR, 0);
712 force_pci_posting(dev);
713 priv->irq_enabled = 0;
716 void rtl8180_set_mode(struct net_device *dev, int mode)
720 ecmd = read_nic_byte(dev, EPROM_CMD);
721 ecmd = ecmd & ~EPROM_CMD_OPERATING_MODE_MASK;
722 ecmd = ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
723 ecmd = ecmd & ~(1<<EPROM_CS_SHIFT);
724 ecmd = ecmd & ~(1<<EPROM_CK_SHIFT);
725 write_nic_byte(dev, EPROM_CMD, ecmd);
728 void rtl8180_adapter_start(struct net_device *dev);
729 void rtl8180_beacon_tx_enable(struct net_device *dev);
731 void rtl8180_update_msr(struct net_device *dev)
733 struct r8180_priv *priv = ieee80211_priv(dev);
737 msr = read_nic_byte(dev, MSR);
738 msr &= ~MSR_LINK_MASK;
740 rxconf = read_nic_dword(dev, RX_CONF);
742 if (priv->ieee80211->state == IEEE80211_LINKED) {
743 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
744 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
745 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
746 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
747 else if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
748 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
750 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
751 rxconf |= (1<<RX_CHECK_BSSID_SHIFT);
754 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
755 rxconf &= ~(1<<RX_CHECK_BSSID_SHIFT);
758 write_nic_byte(dev, MSR, msr);
759 write_nic_dword(dev, RX_CONF, rxconf);
762 void rtl8180_set_chan(struct net_device *dev, short ch)
764 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
766 if ((ch > 14) || (ch < 1)) {
767 printk("In %s: Invalid chnanel %d\n", __func__, ch);
772 priv->rf_set_chan(dev, priv->chan);
775 void rtl8180_rx_enable(struct net_device *dev)
779 /* for now we accept data, management & ctl frame*/
780 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
782 rxconf = read_nic_dword(dev, RX_CONF);
783 rxconf = rxconf & ~MAC_FILTER_MASK;
784 rxconf = rxconf | (1<<ACCEPT_MNG_FRAME_SHIFT);
785 rxconf = rxconf | (1<<ACCEPT_DATA_FRAME_SHIFT);
786 rxconf = rxconf | (1<<ACCEPT_BCAST_FRAME_SHIFT);
787 rxconf = rxconf | (1<<ACCEPT_MCAST_FRAME_SHIFT);
788 if (dev->flags & IFF_PROMISC)
789 DMESG("NIC in promisc mode");
791 if (priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
792 dev->flags & IFF_PROMISC) {
793 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
795 rxconf = rxconf | (1<<ACCEPT_NICMAC_FRAME_SHIFT);
798 if (priv->ieee80211->iw_mode == IW_MODE_MONITOR) {
799 rxconf = rxconf | (1<<ACCEPT_CTL_FRAME_SHIFT);
800 rxconf = rxconf | (1<<ACCEPT_ICVERR_FRAME_SHIFT);
801 rxconf = rxconf | (1<<ACCEPT_PWR_FRAME_SHIFT);
804 if (priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
805 rxconf = rxconf | (1<<ACCEPT_CRCERR_FRAME_SHIFT);
807 rxconf = rxconf & ~RX_FIFO_THRESHOLD_MASK;
808 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE << RX_FIFO_THRESHOLD_SHIFT);
810 rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
811 rxconf = rxconf & ~MAX_RX_DMA_MASK;
812 rxconf = rxconf | (MAX_RX_DMA_2048<<MAX_RX_DMA_SHIFT);
814 rxconf = rxconf | RCR_ONLYERLPKT;
816 rxconf = rxconf & ~RCR_CS_MASK;
818 write_nic_dword(dev, RX_CONF, rxconf);
822 cmd = read_nic_byte(dev, CMD);
823 write_nic_byte(dev, CMD, cmd | (1<<CMD_RX_ENABLE_SHIFT));
826 void set_nic_txring(struct net_device *dev)
828 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
830 write_nic_dword(dev, TX_MANAGEPRIORITY_RING_ADDR, priv->txmapringdma);
831 write_nic_dword(dev, TX_BKPRIORITY_RING_ADDR, priv->txbkpringdma);
832 write_nic_dword(dev, TX_BEPRIORITY_RING_ADDR, priv->txbepringdma);
833 write_nic_dword(dev, TX_VIPRIORITY_RING_ADDR, priv->txvipringdma);
834 write_nic_dword(dev, TX_VOPRIORITY_RING_ADDR, priv->txvopringdma);
835 write_nic_dword(dev, TX_HIGHPRIORITY_RING_ADDR, priv->txhpringdma);
836 write_nic_dword(dev, TX_BEACON_RING_ADDR, priv->txbeaconringdma);
839 void rtl8180_conttx_enable(struct net_device *dev)
843 txconf = read_nic_dword(dev, TX_CONF);
844 txconf = txconf & ~TX_LOOPBACK_MASK;
845 txconf = txconf | (TX_LOOPBACK_CONTINUE<<TX_LOOPBACK_SHIFT);
846 write_nic_dword(dev, TX_CONF, txconf);
849 void rtl8180_conttx_disable(struct net_device *dev)
853 txconf = read_nic_dword(dev, TX_CONF);
854 txconf = txconf & ~TX_LOOPBACK_MASK;
855 txconf = txconf | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT);
856 write_nic_dword(dev, TX_CONF, txconf);
859 void rtl8180_tx_enable(struct net_device *dev)
865 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
867 txconf = read_nic_dword(dev, TX_CONF);
869 byte = read_nic_byte(dev, CW_CONF);
870 byte &= ~(1<<CW_CONF_PERPACKET_CW_SHIFT);
871 byte &= ~(1<<CW_CONF_PERPACKET_RETRY_SHIFT);
872 write_nic_byte(dev, CW_CONF, byte);
874 tx_agc_ctl = read_nic_byte(dev, TX_AGC_CTL);
875 tx_agc_ctl &= ~(1<<TX_AGC_CTL_PERPACKET_GAIN_SHIFT);
876 tx_agc_ctl &= ~(1<<TX_AGC_CTL_PERPACKET_ANTSEL_SHIFT);
877 tx_agc_ctl |= (1<<TX_AGC_CTL_FEEDBACK_ANT);
878 write_nic_byte(dev, TX_AGC_CTL, tx_agc_ctl);
879 write_nic_byte(dev, 0xec, 0x3f); /* Disable early TX */
881 txconf = txconf & ~(1<<TCR_PROBE_NOTIMESTAMP_SHIFT);
883 txconf = txconf & ~TX_LOOPBACK_MASK;
884 txconf = txconf | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT);
885 txconf = txconf & ~TCR_DPRETRY_MASK;
886 txconf = txconf & ~TCR_RTSRETRY_MASK;
887 txconf = txconf | (priv->retry_data<<TX_DPRETRY_SHIFT);
888 txconf = txconf | (priv->retry_rts<<TX_RTSRETRY_SHIFT);
889 txconf = txconf & ~(1<<TX_NOCRC_SHIFT);
891 if (priv->hw_plcp_len)
892 txconf = txconf & ~TCR_PLCP_LEN;
894 txconf = txconf | TCR_PLCP_LEN;
896 txconf = txconf & ~TCR_MXDMA_MASK;
897 txconf = txconf | (TCR_MXDMA_2048<<TCR_MXDMA_SHIFT);
898 txconf = txconf | TCR_CWMIN;
899 txconf = txconf | TCR_DISCW;
901 txconf = txconf | (1 << TX_NOICV_SHIFT);
903 write_nic_dword(dev, TX_CONF, txconf);
907 cmd = read_nic_byte(dev, CMD);
908 write_nic_byte(dev, CMD, cmd | (1<<CMD_TX_ENABLE_SHIFT));
910 write_nic_dword(dev, TX_CONF, txconf);
913 void rtl8180_beacon_tx_enable(struct net_device *dev)
915 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
917 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
918 priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_BQ);
919 write_nic_byte(dev, TPPollStop, priv->dma_poll_mask);
920 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
923 void rtl8180_beacon_tx_disable(struct net_device *dev)
925 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
927 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
928 priv->dma_poll_stop_mask |= TPPOLLSTOP_BQ;
929 write_nic_byte(dev, TPPollStop, priv->dma_poll_stop_mask);
930 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
934 void rtl8180_rtx_disable(struct net_device *dev)
937 struct r8180_priv *priv = ieee80211_priv(dev);
939 cmd = read_nic_byte(dev, CMD);
940 write_nic_byte(dev, CMD, cmd & ~\
941 ((1<<CMD_RX_ENABLE_SHIFT)|(1<<CMD_TX_ENABLE_SHIFT)));
942 force_pci_posting(dev);
945 if (!priv->rx_skb_complete)
946 dev_kfree_skb_any(priv->rx_skb);
949 short alloc_tx_desc_ring(struct net_device *dev, int bufsize, int count,
955 dma_addr_t dma_desc, dma_tmp;
956 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
957 struct pci_dev *pdev = priv->pdev;
960 if ((bufsize & 0xfff) != bufsize) {
961 DMESGE("TX buffer allocation too large");
964 desc = (u32 *)pci_alloc_consistent(pdev,
965 sizeof(u32)*8*count+256, &dma_desc);
971 * descriptor's buffer must be 256 byte aligned
972 * we shouldn't be here, since we set DMA mask !
974 WARN(1, "DMA buffer is not aligned\n");
978 for (i = 0; i < count; i++) {
979 buf = (void *)pci_alloc_consistent(pdev, bufsize, &dma_tmp);
984 case TX_MANAGEPRIORITY_RING_ADDR:
985 if (-1 == buffer_add(&(priv->txmapbufs), buf, dma_tmp, NULL)) {
986 DMESGE("Unable to allocate mem for buffer NP");
990 case TX_BKPRIORITY_RING_ADDR:
991 if (-1 == buffer_add(&(priv->txbkpbufs), buf, dma_tmp, NULL)) {
992 DMESGE("Unable to allocate mem for buffer LP");
996 case TX_BEPRIORITY_RING_ADDR:
997 if (-1 == buffer_add(&(priv->txbepbufs), buf, dma_tmp, NULL)) {
998 DMESGE("Unable to allocate mem for buffer NP");
1002 case TX_VIPRIORITY_RING_ADDR:
1003 if (-1 == buffer_add(&(priv->txvipbufs), buf, dma_tmp, NULL)) {
1004 DMESGE("Unable to allocate mem for buffer LP");
1008 case TX_VOPRIORITY_RING_ADDR:
1009 if (-1 == buffer_add(&(priv->txvopbufs), buf, dma_tmp, NULL)) {
1010 DMESGE("Unable to allocate mem for buffer NP");
1014 case TX_HIGHPRIORITY_RING_ADDR:
1015 if (-1 == buffer_add(&(priv->txhpbufs), buf, dma_tmp, NULL)) {
1016 DMESGE("Unable to allocate mem for buffer HP");
1020 case TX_BEACON_RING_ADDR:
1021 if (-1 == buffer_add(&(priv->txbeaconbufs), buf, dma_tmp, NULL)) {
1022 DMESGE("Unable to allocate mem for buffer BP");
1027 *tmp = *tmp & ~(1<<31); /* descriptor empty, owned by the drv */
1028 *(tmp+2) = (u32)dma_tmp;
1032 *(tmp+4) = (u32)dma_desc+((i+1)*8*4);
1034 *(tmp+4) = (u32)dma_desc;
1040 case TX_MANAGEPRIORITY_RING_ADDR:
1041 priv->txmapringdma = dma_desc;
1042 priv->txmapring = desc;
1044 case TX_BKPRIORITY_RING_ADDR:
1045 priv->txbkpringdma = dma_desc;
1046 priv->txbkpring = desc;
1048 case TX_BEPRIORITY_RING_ADDR:
1049 priv->txbepringdma = dma_desc;
1050 priv->txbepring = desc;
1052 case TX_VIPRIORITY_RING_ADDR:
1053 priv->txvipringdma = dma_desc;
1054 priv->txvipring = desc;
1056 case TX_VOPRIORITY_RING_ADDR:
1057 priv->txvopringdma = dma_desc;
1058 priv->txvopring = desc;
1060 case TX_HIGHPRIORITY_RING_ADDR:
1061 priv->txhpringdma = dma_desc;
1062 priv->txhpring = desc;
1064 case TX_BEACON_RING_ADDR:
1065 priv->txbeaconringdma = dma_desc;
1066 priv->txbeaconring = desc;
1074 void free_tx_desc_rings(struct net_device *dev)
1076 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1077 struct pci_dev *pdev = priv->pdev;
1078 int count = priv->txringcount;
1080 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1081 priv->txmapring, priv->txmapringdma);
1082 buffer_free(dev, &(priv->txmapbufs), priv->txbuffsize, 1);
1084 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1085 priv->txbkpring, priv->txbkpringdma);
1086 buffer_free(dev, &(priv->txbkpbufs), priv->txbuffsize, 1);
1088 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1089 priv->txbepring, priv->txbepringdma);
1090 buffer_free(dev, &(priv->txbepbufs), priv->txbuffsize, 1);
1092 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1093 priv->txvipring, priv->txvipringdma);
1094 buffer_free(dev, &(priv->txvipbufs), priv->txbuffsize, 1);
1096 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1097 priv->txvopring, priv->txvopringdma);
1098 buffer_free(dev, &(priv->txvopbufs), priv->txbuffsize, 1);
1100 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1101 priv->txhpring, priv->txhpringdma);
1102 buffer_free(dev, &(priv->txhpbufs), priv->txbuffsize, 1);
1104 count = priv->txbeaconcount;
1105 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1106 priv->txbeaconring, priv->txbeaconringdma);
1107 buffer_free(dev, &(priv->txbeaconbufs), priv->txbuffsize, 1);
1110 void free_rx_desc_ring(struct net_device *dev)
1112 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1113 struct pci_dev *pdev = priv->pdev;
1114 int count = priv->rxringcount;
1116 pci_free_consistent(pdev, sizeof(u32)*8*count+256,
1117 priv->rxring, priv->rxringdma);
1119 buffer_free(dev, &(priv->rxbuffer), priv->rxbuffersize, 0);
1122 short alloc_rx_desc_ring(struct net_device *dev, u16 bufsize, int count)
1127 dma_addr_t dma_desc, dma_tmp;
1128 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1129 struct pci_dev *pdev = priv->pdev;
1133 rx_desc_size = 8; /* 4*8 = 32 bytes */
1135 if ((bufsize & 0xfff) != bufsize) {
1136 DMESGE("RX buffer allocation too large");
1140 desc = (u32 *)pci_alloc_consistent(pdev, sizeof(u32)*rx_desc_size*count+256,
1143 if (dma_desc & 0xff)
1145 * descriptor's buffer must be 256 byte aligned
1146 * should never happen since we specify the DMA mask
1148 WARN(1, "DMA buffer is not aligned\n");
1150 priv->rxring = desc;
1151 priv->rxringdma = dma_desc;
1154 for (i = 0; i < count; i++) {
1155 buf = kmalloc(bufsize * sizeof(u8), GFP_ATOMIC);
1157 DMESGE("Failed to kmalloc RX buffer");
1161 dma_tmp = pci_map_single(pdev, buf, bufsize * sizeof(u8),
1162 PCI_DMA_FROMDEVICE);
1164 if (-1 == buffer_add(&(priv->rxbuffer), buf, dma_tmp,
1165 &(priv->rxbufferhead))) {
1166 DMESGE("Unable to allocate mem RX buf");
1169 *tmp = 0; /* zero pads the header of the descriptor */
1170 *tmp = *tmp | (bufsize&0xfff);
1171 *(tmp+2) = (u32)dma_tmp;
1172 *tmp = *tmp | (1<<31); /* descriptor void, owned by the NIC */
1174 tmp = tmp+rx_desc_size;
1177 *(tmp-rx_desc_size) = *(tmp-rx_desc_size) | (1<<30); /* this is the last descriptor */
1183 void set_nic_rxring(struct net_device *dev)
1186 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1188 pgreg = read_nic_byte(dev, PGSELECT);
1189 write_nic_byte(dev, PGSELECT, pgreg & ~(1<<PGSELECT_PG_SHIFT));
1191 write_nic_dword(dev, RXRING_ADDR, priv->rxringdma);
1194 void rtl8180_reset(struct net_device *dev)
1198 rtl8180_irq_disable(dev);
1200 cr = read_nic_byte(dev, CMD);
1202 cr = cr | (1<<CMD_RST_SHIFT);
1203 write_nic_byte(dev, CMD, cr);
1205 force_pci_posting(dev);
1209 if (read_nic_byte(dev, CMD) & (1<<CMD_RST_SHIFT))
1210 DMESGW("Card reset timeout!");
1212 DMESG("Card successfully reset");
1214 rtl8180_set_mode(dev, EPROM_CMD_LOAD);
1215 force_pci_posting(dev);
1219 inline u16 ieeerate2rtlrate(int rate)
1251 static u16 rtl_rate[] = {10, 20, 55, 110, 60, 90, 120, 180, 240, 360, 480, 540, 720};
1253 inline u16 rtl8180_rate2rate(short rate)
1257 return rtl_rate[rate];
1260 inline u8 rtl8180_IsWirelessBMode(u16 rate)
1262 if (((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220))
1268 u16 N_DBPSOfRate(u16 DataRate);
1270 u16 ComputeTxTime(u16 FrameLength, u16 DataRate, u8 bManagementFrame,
1277 if (rtl8180_IsWirelessBMode(DataRate)) {
1278 if (bManagementFrame || !bShortPreamble || DataRate == 10)
1280 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1282 /* short preamble */
1283 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1285 if ((FrameLength*8 % (DataRate/10)) != 0) /* get the ceilling */
1287 } else { /* 802.11g DSSS-OFDM PLCP length field calculation. */
1288 N_DBPS = N_DBPSOfRate(DataRate);
1289 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1290 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1291 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1296 u16 N_DBPSOfRate(u16 DataRate)
1333 * For Netgear case, they want good-looking singal strength.
1335 long NetgearSignalStrengthTranslate(long LastSS, long CurrSS)
1339 /* Step 1. Scale mapping. */
1340 if (CurrSS >= 71 && CurrSS <= 100)
1341 RetSS = 90 + ((CurrSS - 70) / 3);
1342 else if (CurrSS >= 41 && CurrSS <= 70)
1343 RetSS = 78 + ((CurrSS - 40) / 3);
1344 else if (CurrSS >= 31 && CurrSS <= 40)
1345 RetSS = 66 + (CurrSS - 30);
1346 else if (CurrSS >= 21 && CurrSS <= 30)
1347 RetSS = 54 + (CurrSS - 20);
1348 else if (CurrSS >= 5 && CurrSS <= 20)
1349 RetSS = 42 + (((CurrSS - 5) * 2) / 3);
1350 else if (CurrSS == 4)
1352 else if (CurrSS == 3)
1354 else if (CurrSS == 2)
1356 else if (CurrSS == 1)
1361 /* Step 2. Smoothing. */
1363 RetSS = ((LastSS * 5) + (RetSS) + 5) / 6;
1369 * Translate 0-100 signal strength index into dBm.
1371 long TranslateToDbm8185(u8 SignalStrengthIndex)
1375 /* Translate to dBm (x=0.5y-95). */
1376 SignalPower = (long)((SignalStrengthIndex + 1) >> 1);
1383 * Perform signal smoothing for dynamic mechanism.
1384 * This is different with PerformSignalSmoothing8185 in smoothing fomula.
1385 * No dramatic adjustion is apply because dynamic mechanism need some degree
1386 * of correctness. Ported from 8187B.
1388 void PerformUndecoratedSignalSmoothing8185(struct r8180_priv *priv,
1391 /* Determin the current packet is CCK rate. */
1392 priv->bCurCCKPkt = bCckRate;
1394 if (priv->UndecoratedSmoothedSS >= 0)
1395 priv->UndecoratedSmoothedSS = ((priv->UndecoratedSmoothedSS * 5) + (priv->SignalStrength * 10)) / 6;
1397 priv->UndecoratedSmoothedSS = priv->SignalStrength * 10;
1399 priv->UndercorateSmoothedRxPower = ((priv->UndercorateSmoothedRxPower * 50) + (priv->RxPower * 11)) / 60;
1402 priv->CurCCKRSSI = priv->RSSI;
1404 priv->CurCCKRSSI = 0;
1409 * This is rough RX isr handling routine
1411 void rtl8180_rx(struct net_device *dev)
1413 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1414 struct sk_buff *tmp_skb;
1418 unsigned char quality, signal;
1427 u8 LNA_gain[4] = {02, 17, 29, 39};
1429 struct ieee80211_hdr_4addr *hdr;
1431 u8 bHwError = 0, bCRC = 0, bICV = 0;
1432 bool bCckRate = false;
1434 long SignalStrengthIndex = 0;
1435 struct ieee80211_rx_stats stats = {
1439 .freq = IEEE80211_24GHZ_BAND,
1442 stats.nic_type = NIC_8185B;
1445 if ((*(priv->rxringtail)) & (1<<31)) {
1446 /* we have got an RX int, but the descriptor
1447 * we are pointing is empty */
1449 priv->stats.rxnodata++;
1450 priv->ieee80211->stats.rx_errors++;
1453 tmp = priv->rxringtail;
1455 if (tmp == priv->rxring)
1456 tmp = priv->rxring + (priv->rxringcount - 1)*rx_desc_size;
1458 tmp -= rx_desc_size;
1460 if (!(*tmp & (1<<31)))
1462 } while (tmp != priv->rxring);
1465 priv->rxringtail = tmp2;
1468 /* while there are filled descriptors */
1469 while (!(*(priv->rxringtail) & (1<<31))) {
1470 if (*(priv->rxringtail) & (1<<26))
1471 DMESGW("RX buffer overflow");
1472 if (*(priv->rxringtail) & (1<<12))
1473 priv->stats.rxicverr++;
1475 if (*(priv->rxringtail) & (1<<27)) {
1476 priv->stats.rxdmafail++;
1477 /* DMESG("EE: RX DMA FAILED at buffer pointed by descriptor %x",(u32)priv->rxringtail); */
1481 pci_dma_sync_single_for_cpu(priv->pdev,
1482 priv->rxbuffer->dma,
1483 priv->rxbuffersize * \
1485 PCI_DMA_FROMDEVICE);
1487 first = *(priv->rxringtail) & (1<<29) ? 1 : 0;
1489 priv->rx_prevlen = 0;
1491 last = *(priv->rxringtail) & (1<<28) ? 1 : 0;
1493 lastlen = ((*priv->rxringtail) & 0xfff);
1495 /* if the last descriptor (that should
1496 * tell us the total packet len) tell
1497 * us something less than the descriptors
1498 * len we had until now, then there is some
1500 * workaround to prevent kernel panic
1502 if (lastlen < priv->rx_prevlen)
1505 len = lastlen-priv->rx_prevlen;
1507 if (*(priv->rxringtail) & (1<<13)) {
1508 if ((*(priv->rxringtail) & 0xfff) < 500)
1509 priv->stats.rxcrcerrmin++;
1510 else if ((*(priv->rxringtail) & 0x0fff) > 1000)
1511 priv->stats.rxcrcerrmax++;
1513 priv->stats.rxcrcerrmid++;
1518 len = priv->rxbuffersize;
1521 if (first && last) {
1522 padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
1524 padding = ((*(priv->rxringtail+3))&(0x04000000))>>26;
1531 priv->rx_prevlen += len;
1533 if (priv->rx_prevlen > MAX_FRAG_THRESHOLD + 100) {
1534 /* HW is probably passing several buggy frames
1535 * without FD or LD flag set.
1536 * Throw this garbage away to prevent skb
1539 if (!priv->rx_skb_complete)
1540 dev_kfree_skb_any(priv->rx_skb);
1541 priv->rx_skb_complete = 1;
1544 signal = (unsigned char)(((*(priv->rxringtail+3)) & (0x00ff0000))>>16);
1545 signal = (signal & 0xfe) >> 1;
1547 quality = (unsigned char)((*(priv->rxringtail+3)) & (0xff));
1549 stats.mac_time[0] = *(priv->rxringtail+1);
1550 stats.mac_time[1] = *(priv->rxringtail+2);
1551 rxpower = ((char)(((*(priv->rxringtail+4)) & (0x00ff0000))>>16))/2 - 42;
1552 RSSI = ((u8)(((*(priv->rxringtail+3)) & (0x0000ff00))>>8)) & (0x7f);
1554 rate = ((*(priv->rxringtail)) &
1555 ((1<<23)|(1<<22)|(1<<21)|(1<<20)))>>20;
1557 stats.rate = rtl8180_rate2rate(rate);
1558 Antenna = (((*(priv->rxringtail+3)) & (0x00008000)) == 0) ? 0 : 1;
1559 if (!rtl8180_IsWirelessBMode(stats.rate)) { /* OFDM rate. */
1560 RxAGC_dBm = rxpower+1; /* bias */
1561 } else { /* CCK rate. */
1562 RxAGC_dBm = signal; /* bit 0 discard */
1564 LNA = (u8) (RxAGC_dBm & 0x60) >> 5; /* bit 6~ bit 5 */
1565 BB = (u8) (RxAGC_dBm & 0x1F); /* bit 4 ~ bit 0 */
1567 RxAGC_dBm = -(LNA_gain[LNA] + (BB*2)); /* Pin_11b=-(LNA_gain+BB_gain) (dBm) */
1569 RxAGC_dBm += 4; /* bias */
1572 if (RxAGC_dBm & 0x80) /* absolute value */
1573 RXAGC = ~(RxAGC_dBm)+1;
1574 bCckRate = rtl8180_IsWirelessBMode(stats.rate);
1575 /* Translate RXAGC into 1-100. */
1576 if (!rtl8180_IsWirelessBMode(stats.rate)) { /* OFDM rate. */
1579 else if (RXAGC < 25)
1581 RXAGC = (90-RXAGC)*100/65;
1582 } else { /* CCK rate. */
1585 else if (RXAGC < 30)
1587 RXAGC = (95-RXAGC)*100/65;
1589 priv->SignalStrength = (u8)RXAGC;
1590 priv->RecvSignalPower = RxAGC_dBm;
1591 priv->RxPower = rxpower;
1593 /* SQ translation formula is provided by SD3 DZ. 2006.06.27 */
1595 quality = 1; /*0; */ /* 0 will cause epc to show signal zero , walk around now; */
1596 else if (quality < 27)
1599 quality = 127 - quality;
1600 priv->SignalQuality = quality;
1602 stats.signal = (u8)quality; /*priv->wstats.qual.level = priv->SignalStrength; */
1603 stats.signalstrength = RXAGC;
1604 if (stats.signalstrength > 100)
1605 stats.signalstrength = 100;
1606 stats.signalstrength = (stats.signalstrength * 70)/100 + 30;
1607 /* printk("==========================>rx : RXAGC is %d,signalstrength is %d\n",RXAGC,stats.signalstrength); */
1608 stats.rssi = priv->wstats.qual.qual = priv->SignalQuality;
1609 stats.noise = priv->wstats.qual.noise = 100 - priv->wstats.qual.qual;
1610 bHwError = (((*(priv->rxringtail)) & (0x00000fff)) == 4080) | (((*(priv->rxringtail)) & (0x04000000)) != 0)
1611 | (((*(priv->rxringtail)) & (0x08000000)) != 0) | (((~(*(priv->rxringtail))) & (0x10000000)) != 0) | (((~(*(priv->rxringtail))) & (0x20000000)) != 0);
1612 bCRC = ((*(priv->rxringtail)) & (0x00002000)) >> 13;
1613 bICV = ((*(priv->rxringtail)) & (0x00001000)) >> 12;
1614 hdr = (struct ieee80211_hdr_4addr *)priv->rxbuffer->buf;
1615 fc = le16_to_cpu(hdr->frame_ctl);
1616 type = WLAN_FC_GET_TYPE(fc);
1618 if ((IEEE80211_FTYPE_CTL != type) &&
1619 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS) ? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS) ? hdr->addr2 : hdr->addr3))
1620 && (!bHwError) && (!bCRC) && (!bICV)) {
1621 /* Perform signal smoothing for dynamic
1622 * mechanism on demand. This is different
1623 * with PerformSignalSmoothing8185 in smoothing
1624 * fomula. No dramatic adjustion is apply
1625 * because dynamic mechanism need some degree
1626 * of correctness. */
1627 PerformUndecoratedSignalSmoothing8185(priv, bCckRate);
1629 /* For good-looking singal strength. */
1630 SignalStrengthIndex = NetgearSignalStrengthTranslate(
1631 priv->LastSignalStrengthInPercent,
1632 priv->SignalStrength);
1634 priv->LastSignalStrengthInPercent = SignalStrengthIndex;
1635 priv->Stats_SignalStrength = TranslateToDbm8185((u8)SignalStrengthIndex);
1637 * We need more correct power of received packets and the "SignalStrength" of RxStats is beautified,
1638 * so we record the correct power here.
1640 priv->Stats_SignalQuality = (long)(priv->Stats_SignalQuality * 5 + (long)priv->SignalQuality + 5) / 6;
1641 priv->Stats_RecvSignalPower = (long)(priv->Stats_RecvSignalPower * 5 + priv->RecvSignalPower - 1) / 6;
1643 /* Figure out which antenna that received the lasted packet. */
1644 priv->LastRxPktAntenna = Antenna ? 1 : 0; /* 0: aux, 1: main. */
1645 SwAntennaDiversityRxOk8185(dev, priv->SignalStrength);
1649 if (!priv->rx_skb_complete) {
1650 /* seems that HW sometimes fails to reiceve and
1651 doesn't provide the last descriptor */
1652 dev_kfree_skb_any(priv->rx_skb);
1653 priv->stats.rxnolast++;
1655 /* support for prism header has been originally added by Christian */
1656 if (priv->prism_hdr && priv->ieee80211->iw_mode == IW_MODE_MONITOR) {
1659 priv->rx_skb = dev_alloc_skb(len+2);
1664 priv->rx_skb_complete = 0;
1665 priv->rx_skb->dev = dev;
1667 /* if we are here we should have already RXed
1669 * If we get here and the skb is not allocated then
1670 * we have just throw out garbage (skb not allocated)
1671 * and we are still rxing garbage....
1673 if (!priv->rx_skb_complete) {
1675 tmp_skb = dev_alloc_skb(priv->rx_skb->len+len+2);
1682 memcpy(skb_put(tmp_skb, priv->rx_skb->len),
1686 dev_kfree_skb_any(priv->rx_skb);
1688 priv->rx_skb = tmp_skb;
1692 if (!priv->rx_skb_complete) {
1694 memcpy(skb_put(priv->rx_skb, len),
1695 (((unsigned char *)priv->rxbuffer->buf) + 2), len);
1697 memcpy(skb_put(priv->rx_skb, len),
1698 priv->rxbuffer->buf, len);
1702 if (last && !priv->rx_skb_complete) {
1703 if (priv->rx_skb->len > 4)
1704 skb_trim(priv->rx_skb, priv->rx_skb->len-4);
1705 if (!ieee80211_rtl_rx(priv->ieee80211,
1706 priv->rx_skb, &stats))
1707 dev_kfree_skb_any(priv->rx_skb);
1708 priv->rx_skb_complete = 1;
1711 pci_dma_sync_single_for_device(priv->pdev,
1712 priv->rxbuffer->dma,
1713 priv->rxbuffersize * \
1715 PCI_DMA_FROMDEVICE);
1717 drop: /* this is used when we have not enough mem */
1718 /* restore the descriptor */
1719 *(priv->rxringtail+2) = priv->rxbuffer->dma;
1720 *(priv->rxringtail) = *(priv->rxringtail) & ~0xfff;
1721 *(priv->rxringtail) =
1722 *(priv->rxringtail) | priv->rxbuffersize;
1724 *(priv->rxringtail) =
1725 *(priv->rxringtail) | (1<<31);
1727 priv->rxringtail += rx_desc_size;
1728 if (priv->rxringtail >=
1729 (priv->rxring)+(priv->rxringcount)*rx_desc_size)
1730 priv->rxringtail = priv->rxring;
1732 priv->rxbuffer = (priv->rxbuffer->next);
1737 void rtl8180_dma_kick(struct net_device *dev, int priority)
1739 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1741 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1742 write_nic_byte(dev, TX_DMA_POLLING,
1743 (1 << (priority + 1)) | priv->dma_poll_mask);
1744 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1746 force_pci_posting(dev);
1749 void rtl8180_data_hard_stop(struct net_device *dev)
1751 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1753 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1754 priv->dma_poll_stop_mask |= TPPOLLSTOP_AC_VIQ;
1755 write_nic_byte(dev, TPPollStop, priv->dma_poll_stop_mask);
1756 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1759 void rtl8180_data_hard_resume(struct net_device *dev)
1761 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1763 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
1764 priv->dma_poll_stop_mask &= ~(TPPOLLSTOP_AC_VIQ);
1765 write_nic_byte(dev, TPPollStop, priv->dma_poll_stop_mask);
1766 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
1770 * This function TX data frames when the ieee80211 stack requires this.
1771 * It checks also if we need to stop the ieee tx queue, eventually do it
1773 void rtl8180_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int
1775 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1777 struct ieee80211_hdr_3addr *h = (struct ieee80211_hdr_3addr *) skb->data;
1778 short morefrag = (h->frame_control) & IEEE80211_FCTL_MOREFRAGS;
1779 unsigned long flags;
1782 mode = priv->ieee80211->iw_mode;
1784 rate = ieeerate2rtlrate(rate);
1786 * This function doesn't require lock because we make
1787 * sure it's called with the tx_lock already acquired.
1788 * this come from the kernel's hard_xmit callback (through
1789 * the ieee stack, or from the try_wake_queue (again through
1792 priority = AC2Q(skb->priority);
1793 spin_lock_irqsave(&priv->tx_lock, flags);
1795 if (priv->ieee80211->bHwRadioOff) {
1796 spin_unlock_irqrestore(&priv->tx_lock, flags);
1801 if (!check_nic_enought_desc(dev, priority)) {
1802 DMESGW("Error: no descriptor left by previous TX (avail %d) ",
1803 get_curr_tx_free_desc(dev, priority));
1804 ieee80211_rtl_stop_queue(priv->ieee80211);
1806 rtl8180_tx(dev, skb->data, skb->len, priority, morefrag, 0, rate);
1807 if (!check_nic_enought_desc(dev, priority))
1808 ieee80211_rtl_stop_queue(priv->ieee80211);
1810 spin_unlock_irqrestore(&priv->tx_lock, flags);
1814 * This is a rough attempt to TX a frame
1815 * This is called by the ieee 80211 stack to TX management frames.
1816 * If the ring is full packet are dropped (for data frame the queue
1817 * is stopped before this can happen). For this reason it is better
1818 * if the descriptors are larger than the largest management frame
1819 * we intend to TX: i'm unsure what the HW does if it will not found
1820 * the last fragment of a frame because it has been dropped...
1821 * Since queues for Management and Data frames are different we
1822 * might use a different lock than tx_lock (for example mgmt_tx_lock)
1824 /* these function may loops if invoked with 0 descriptors or 0 len buffer */
1825 int rtl8180_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1827 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1828 unsigned long flags;
1831 priority = MANAGE_PRIORITY;
1833 spin_lock_irqsave(&priv->tx_lock, flags);
1835 if (priv->ieee80211->bHwRadioOff) {
1836 spin_unlock_irqrestore(&priv->tx_lock, flags);
1837 dev_kfree_skb_any(skb);
1838 return NETDEV_TX_OK;
1841 rtl8180_tx(dev, skb->data, skb->len, priority,
1842 0, 0, ieeerate2rtlrate(priv->ieee80211->basic_rate));
1844 priv->ieee80211->stats.tx_bytes += skb->len;
1845 priv->ieee80211->stats.tx_packets++;
1846 spin_unlock_irqrestore(&priv->tx_lock, flags);
1848 dev_kfree_skb_any(skb);
1849 return NETDEV_TX_OK;
1852 /* longpre 144+48 shortpre 72+24 */
1853 u16 rtl8180_len2duration(u32 len, short rate, short *ext)
1862 duration = ((len+4)<<4) / 0x2;
1863 drift = ((len+4)<<4) % 0x2;
1870 duration = ((len+4)<<4) / 0x4;
1871 drift = ((len+4)<<4) % 0x4;
1876 case 2: /* 5.5mbps */
1878 duration = ((len+4)<<4) / 0xb;
1879 drift = ((len+4)<<4) % 0xb;
1885 case 3: /* 11mbps */
1887 duration = ((len+4)<<4) / 0x16;
1888 drift = ((len+4)<<4) % 0x16;
1901 void rtl8180_prepare_beacon(struct net_device *dev)
1903 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
1904 struct sk_buff *skb;
1906 u16 word = read_nic_word(dev, BcnItv);
1907 word &= ~BcnItv_BcnItv; /* clear Bcn_Itv */
1908 word |= cpu_to_le16(priv->ieee80211->current_network.beacon_interval); /* 0x64; */
1909 write_nic_word(dev, BcnItv, word);
1911 skb = ieee80211_get_beacon(priv->ieee80211);
1913 rtl8180_tx(dev, skb->data, skb->len, BEACON_PRIORITY,
1914 0, 0, ieeerate2rtlrate(priv->ieee80211->basic_rate));
1915 dev_kfree_skb_any(skb);
1920 * This function do the real dirty work: it enqueues a TX command
1921 * descriptor in the ring buffer, copyes the frame in a TX buffer
1922 * and kicks the NIC to ensure it does the DMA transfer.
1924 short rtl8180_tx(struct net_device *dev, u8* txbuf, int len, int priority,
1925 short morefrag, short descfrag, int rate)
1927 struct r8180_priv *priv = ieee80211_priv(dev);
1928 u32 *tail, *temp_tail;
1937 struct buffer *buflist;
1938 struct ieee80211_hdr_3addr *frag_hdr = (struct ieee80211_hdr_3addr *)txbuf;
1940 u8 bUseShortPreamble = 0;
1945 u16 ThisFrameTime = 0;
1946 u16 TxDescDuration = 0;
1947 u8 ownbit_flag = false;
1950 case MANAGE_PRIORITY:
1951 tail = priv->txmapringtail;
1952 begin = priv->txmapring;
1953 buflist = priv->txmapbufstail;
1954 count = priv->txringcount;
1957 tail = priv->txbkpringtail;
1958 begin = priv->txbkpring;
1959 buflist = priv->txbkpbufstail;
1960 count = priv->txringcount;
1963 tail = priv->txbepringtail;
1964 begin = priv->txbepring;
1965 buflist = priv->txbepbufstail;
1966 count = priv->txringcount;
1969 tail = priv->txvipringtail;
1970 begin = priv->txvipring;
1971 buflist = priv->txvipbufstail;
1972 count = priv->txringcount;
1975 tail = priv->txvopringtail;
1976 begin = priv->txvopring;
1977 buflist = priv->txvopbufstail;
1978 count = priv->txringcount;
1981 tail = priv->txhpringtail;
1982 begin = priv->txhpring;
1983 buflist = priv->txhpbufstail;
1984 count = priv->txringcount;
1986 case BEACON_PRIORITY:
1987 tail = priv->txbeaconringtail;
1988 begin = priv->txbeaconring;
1989 buflist = priv->txbeaconbufstail;
1990 count = priv->txbeaconcount;
1997 memcpy(&dest, frag_hdr->addr1, ETH_ALEN);
1998 if (is_multicast_ether_addr(dest) ||
1999 is_broadcast_ether_addr(dest)) {
2005 ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate), 0, bUseShortPreamble);
2006 TxDescDuration = ThisFrameTime;
2007 } else { /* Unicast packet */
2010 /* YJ,add,080828,for Keep alive */
2011 priv->NumTxUnicast++;
2013 /* Figure out ACK rate according to BSS basic rate
2015 AckTime = ComputeTxTime(14, 10, 0, 0); /* AckCTSLng = 14 use 1M bps send */
2017 if (((len + sCrcLng) > priv->rts) && priv->rts) { /* RTS/CTS. */
2018 u16 RtsTime, CtsTime;
2023 /* Rate and time required for RTS. */
2024 RtsTime = ComputeTxTime(sAckCtsLng/8, priv->ieee80211->basic_rate, 0, 0);
2025 /* Rate and time required for CTS. */
2026 CtsTime = ComputeTxTime(14, 10, 0, 0); /* AckCTSLng = 14 use 1M bps send */
2028 /* Figure out time required to transmit this frame. */
2029 ThisFrameTime = ComputeTxTime(len + sCrcLng,
2030 rtl8180_rate2rate(rate),
2034 /* RTS-CTS-ThisFrame-ACK. */
2035 RtsDur = CtsTime + ThisFrameTime + AckTime + 3*aSifsTime;
2037 TxDescDuration = RtsTime + RtsDur;
2038 } else { /* Normal case. */
2043 ThisFrameTime = ComputeTxTime(len + sCrcLng, rtl8180_rate2rate(rate), 0, bUseShortPreamble);
2044 TxDescDuration = ThisFrameTime + aSifsTime + AckTime;
2047 if (!(frag_hdr->frame_control & IEEE80211_FCTL_MOREFRAGS)) {
2048 /* ThisFrame-ACK. */
2049 Duration = aSifsTime + AckTime;
2050 } else { /* One or more fragments remained. */
2052 NextFragTime = ComputeTxTime(len + sCrcLng, /* pretend following packet length equal current packet */
2053 rtl8180_rate2rate(rate),
2057 /* ThisFrag-ACk-NextFrag-ACK. */
2058 Duration = NextFragTime + 3*aSifsTime + 2*AckTime;
2061 } /* End of Unicast packet */
2063 frag_hdr->duration_id = Duration;
2065 buflen = priv->txbuffsize;
2069 while (remain != 0) {
2072 DMESGE("TX buffer error, cannot TX frames. pri %d.", priority);
2077 if ((*tail & (1 << 31)) && (priority != BEACON_PRIORITY)) {
2078 DMESGW("No more TX desc, returning %x of %x",
2080 priv->stats.txrdu++;
2084 *tail = 0; /* zeroes header */
2091 /* FIXME: this should be triggered by HW encryption parameters.*/
2092 *tail |= (1<<15); /* no encrypt */
2094 if (remain == len && !descfrag) {
2095 ownbit_flag = false;
2096 *tail = *tail | (1<<29) ; /* fist segment of the packet */
2097 *tail = *tail | (len);
2102 for (i = 0; i < buflen && remain > 0; i++, remain--) {
2103 ((u8 *)buf)[i] = txbuf[i]; /* copy data into descriptor pointed DMAble buffer */
2104 if (remain == 4 && i+4 >= buflen)
2106 /* ensure the last desc has at least 4 bytes payload */
2110 *(tail+3) = *(tail+3) & ~0xfff;
2111 *(tail+3) = *(tail+3) | i; /* buffer length */
2112 /* Use short preamble or not */
2113 if (priv->ieee80211->current_network.capability&WLAN_CAPABILITY_SHORT_PREAMBLE)
2114 if (priv->plcp_preamble_mode == 1 && rate != 0) /* short mode now, not long! */
2115 ; /* *tail |= (1<<16); */ /* enable short preamble mode. */
2120 if (bRTSEnable) { /* rts enable */
2121 *tail |= ((ieeerate2rtlrate(priv->ieee80211->basic_rate))<<19); /* RTS RATE */
2122 *tail |= (1<<23); /* rts enable */
2123 *(tail+1) |= (RtsDur&0xffff); /* RTS Duration */
2125 *(tail+3) |= ((TxDescDuration&0xffff)<<16); /* DURATION */
2126 /* *(tail+3) |= (0xe6<<16); */
2127 *(tail+5) |= (11<<8); /* (priv->retry_data<<8); */ /* retry lim; */
2129 *tail = *tail | ((rate&0xf) << 24);
2131 /* hw_plcp_len is not used for rtl8180 chip */
2133 if (!priv->hw_plcp_len) {
2134 duration = rtl8180_len2duration(len, rate, &ext);
2135 *(tail+1) = *(tail+1) | ((duration & 0x7fff)<<16);
2137 *(tail+1) = *(tail+1) | (1<<31); /* plcp length extension */
2141 *tail = (*tail) | (1<<17); /* more fragment */
2143 *tail = (*tail) | (1<<28); /* last segment of frame */
2145 *(tail+5) = *(tail+5)|(2<<27);
2146 *(tail+7) = *(tail+7)|(1<<4);
2150 *tail = *tail | (1<<31); /* descriptor ready to be txed */
2152 if ((tail - begin)/8 == count-1)
2157 buflist = buflist->next;
2162 case MANAGE_PRIORITY:
2163 priv->txmapringtail = tail;
2164 priv->txmapbufstail = buflist;
2167 priv->txbkpringtail = tail;
2168 priv->txbkpbufstail = buflist;
2171 priv->txbepringtail = tail;
2172 priv->txbepbufstail = buflist;
2175 priv->txvipringtail = tail;
2176 priv->txvipbufstail = buflist;
2179 priv->txvopringtail = tail;
2180 priv->txvopbufstail = buflist;
2183 priv->txhpringtail = tail;
2184 priv->txhpbufstail = buflist;
2186 case BEACON_PRIORITY:
2188 * The HW seems to be happy with the 1st
2189 * descriptor filled and the 2nd empty...
2190 * So always update descriptor 1 and never
2196 *temp_tail = *temp_tail | (1<<31); /* descriptor ready to be txed */
2197 rtl8180_dma_kick(dev, priority);
2202 void rtl8180_irq_rx_tasklet(struct r8180_priv *priv);
2204 void rtl8180_link_change(struct net_device *dev)
2206 struct r8180_priv *priv = ieee80211_priv(dev);
2207 u16 beacon_interval;
2208 struct ieee80211_network *net = &priv->ieee80211->current_network;
2210 rtl8180_update_msr(dev);
2212 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
2214 write_nic_dword(dev, BSSID, ((u32 *)net->bssid)[0]);
2215 write_nic_word(dev, BSSID+4, ((u16 *)net->bssid)[2]);
2217 beacon_interval = read_nic_dword(dev, BEACON_INTERVAL);
2218 beacon_interval &= ~BEACON_INTERVAL_MASK;
2219 beacon_interval |= net->beacon_interval;
2220 write_nic_dword(dev, BEACON_INTERVAL, beacon_interval);
2222 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
2224 rtl8180_set_chan(dev, priv->chan);
2227 void rtl8180_rq_tx_ack(struct net_device *dev)
2230 struct r8180_priv *priv = ieee80211_priv(dev);
2232 write_nic_byte(dev, CONFIG4, read_nic_byte(dev, CONFIG4) | CONFIG4_PWRMGT);
2233 priv->ack_tx_to_ieee = 1;
2236 short rtl8180_is_tx_queue_empty(struct net_device *dev)
2239 struct r8180_priv *priv = ieee80211_priv(dev);
2242 for (d = priv->txmapring;
2243 d < priv->txmapring + priv->txringcount; d += 8)
2247 for (d = priv->txbkpring;
2248 d < priv->txbkpring + priv->txringcount; d += 8)
2252 for (d = priv->txbepring;
2253 d < priv->txbepring + priv->txringcount; d += 8)
2257 for (d = priv->txvipring;
2258 d < priv->txvipring + priv->txringcount; d += 8)
2262 for (d = priv->txvopring;
2263 d < priv->txvopring + priv->txringcount; d += 8)
2267 for (d = priv->txhpring;
2268 d < priv->txhpring + priv->txringcount; d += 8)
2273 /* FIXME FIXME 5msecs is random */
2274 #define HW_WAKE_DELAY 5
2276 void rtl8180_hw_wakeup(struct net_device *dev)
2278 unsigned long flags;
2279 struct r8180_priv *priv = ieee80211_priv(dev);
2281 spin_lock_irqsave(&priv->ps_lock, flags);
2282 write_nic_byte(dev, CONFIG4, read_nic_byte(dev, CONFIG4) & ~CONFIG4_PWRMGT);
2283 if (priv->rf_wakeup)
2284 priv->rf_wakeup(dev);
2285 spin_unlock_irqrestore(&priv->ps_lock, flags);
2288 void rtl8180_hw_sleep_down(struct net_device *dev)
2290 unsigned long flags;
2291 struct r8180_priv *priv = ieee80211_priv(dev);
2293 spin_lock_irqsave(&priv->ps_lock, flags);
2295 priv->rf_sleep(dev);
2296 spin_unlock_irqrestore(&priv->ps_lock, flags);
2299 void rtl8180_hw_sleep(struct net_device *dev, u32 th, u32 tl)
2301 struct r8180_priv *priv = ieee80211_priv(dev);
2303 unsigned long flags;
2305 spin_lock_irqsave(&priv->ps_lock, flags);
2308 * Writing HW register with 0 equals to disable
2309 * the timer, that is not really what we want
2311 tl -= MSECS(4+16+7);
2314 * If the interval in witch we are requested to sleep is too
2315 * short then give up and remain awake
2317 if (((tl >= rb) && (tl-rb) <= MSECS(MIN_SLEEP_TIME))
2318 || ((rb > tl) && (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
2319 spin_unlock_irqrestore(&priv->ps_lock, flags);
2320 printk("too short to sleep\n");
2325 u32 tmp = (tl > rb) ? (tl-rb) : (rb-tl);
2327 priv->DozePeriodInPast2Sec += jiffies_to_msecs(tmp);
2329 queue_delayed_work(priv->ieee80211->wq, &priv->ieee80211->hw_wakeup_wq, tmp); /* as tl may be less than rb */
2332 * If we suspect the TimerInt is gone beyond tl
2333 * while setting it, then give up
2336 if (((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME))) ||
2337 ((tl < rb) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))) {
2338 spin_unlock_irqrestore(&priv->ps_lock, flags);
2342 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_sleep_wq);
2343 spin_unlock_irqrestore(&priv->ps_lock, flags);
2346 void rtl8180_wmm_param_update(struct work_struct *work)
2348 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, wmm_param_update_wq);
2349 struct net_device *dev = ieee->dev;
2350 u8 *ac_param = (u8 *)(ieee->current_network.wmm_param);
2351 u8 mode = ieee->current_network.mode;
2357 if (!ieee->current_network.QoS_Enable) {
2358 /* legacy ac_xx_param update */
2359 AcParam.longData = 0;
2360 AcParam.f.AciAifsn.f.AIFSN = 2; /* Follow 802.11 DIFS. */
2361 AcParam.f.AciAifsn.f.ACM = 0;
2362 AcParam.f.Ecw.f.ECWmin = 3; /* Follow 802.11 CWmin. */
2363 AcParam.f.Ecw.f.ECWmax = 7; /* Follow 802.11 CWmax. */
2364 AcParam.f.TXOPLimit = 0;
2365 for (eACI = 0; eACI < AC_MAX; eACI++) {
2366 AcParam.f.AciAifsn.f.ACI = (u8)eACI;
2370 pAcParam = (PAC_PARAM)(&AcParam);
2371 /* Retrive paramters to udpate. */
2372 u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN * (((mode&IEEE_G) == IEEE_G) ? 9 : 20) + aSifsTime;
2373 u4bAcParam = ((((u32)(pAcParam->f.TXOPLimit))<<AC_PARAM_TXOP_LIMIT_OFFSET)|
2374 (((u32)(pAcParam->f.Ecw.f.ECWmax))<<AC_PARAM_ECW_MAX_OFFSET)|
2375 (((u32)(pAcParam->f.Ecw.f.ECWmin))<<AC_PARAM_ECW_MIN_OFFSET)|
2376 (((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
2379 write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
2382 write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
2385 write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
2388 write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
2391 printk(KERN_WARNING "SetHwReg8185():invalid ACI: %d!\n", eACI);
2399 for (i = 0; i < AC_MAX; i++) {
2400 /* AcParam.longData = 0; */
2401 pAcParam = (AC_PARAM *)ac_param;
2407 /* Retrive paramters to udpate. */
2408 eACI = pAcParam->f.AciAifsn.f.ACI;
2409 /* Mode G/A: slotTimeTimer = 9; Mode B: 20 */
2410 u1bAIFS = pAcParam->f.AciAifsn.f.AIFSN * (((mode&IEEE_G) == IEEE_G) ? 9 : 20) + aSifsTime;
2411 u4bAcParam = ((((u32)(pAcParam->f.TXOPLimit)) << AC_PARAM_TXOP_LIMIT_OFFSET) |
2412 (((u32)(pAcParam->f.Ecw.f.ECWmax)) << AC_PARAM_ECW_MAX_OFFSET) |
2413 (((u32)(pAcParam->f.Ecw.f.ECWmin)) << AC_PARAM_ECW_MIN_OFFSET) |
2414 (((u32)u1bAIFS) << AC_PARAM_AIFS_OFFSET));
2418 write_nic_dword(dev, AC_BK_PARAM, u4bAcParam);
2421 write_nic_dword(dev, AC_BE_PARAM, u4bAcParam);
2424 write_nic_dword(dev, AC_VI_PARAM, u4bAcParam);
2427 write_nic_dword(dev, AC_VO_PARAM, u4bAcParam);
2430 printk(KERN_WARNING "SetHwReg8185(): invalid ACI: %d !\n", eACI);
2434 ac_param += (sizeof(AC_PARAM));
2438 void rtl8180_tx_irq_wq(struct work_struct *work);
2439 void rtl8180_restart_wq(struct work_struct *work);
2440 /* void rtl8180_rq_tx_ack(struct work_struct *work); */
2441 void rtl8180_watch_dog_wq(struct work_struct *work);
2442 void rtl8180_hw_wakeup_wq(struct work_struct *work);
2443 void rtl8180_hw_sleep_wq(struct work_struct *work);
2444 void rtl8180_sw_antenna_wq(struct work_struct *work);
2445 void rtl8180_watch_dog(struct net_device *dev);
2447 void watch_dog_adaptive(unsigned long data)
2449 struct r8180_priv* priv = ieee80211_priv((struct net_device *)data);
2452 DMESG("<----watch_dog_adaptive():driver is not up!\n");
2456 /* Tx High Power Mechanism. */
2457 if (CheckHighPower((struct net_device *)data))
2458 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->tx_pw_wq);
2460 /* Tx Power Tracking on 87SE. */
2461 if (CheckTxPwrTracking((struct net_device *)data))
2462 TxPwrTracking87SE((struct net_device *)data);
2464 /* Perform DIG immediately. */
2465 if (CheckDig((struct net_device *)data) == true)
2466 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_dig_wq);
2467 rtl8180_watch_dog((struct net_device *)data);
2469 queue_work(priv->ieee80211->wq, (void *)&priv->ieee80211->GPIOChangeRFWorkItem);
2471 priv->watch_dog_timer.expires = jiffies + MSECS(IEEE80211_WATCH_DOG_TIME);
2472 add_timer(&priv->watch_dog_timer);
2475 static CHANNEL_LIST ChannelPlan[] = {
2476 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64},19}, /* FCC */
2477 {{1,2,3,4,5,6,7,8,9,10,11},11}, /* IC */
2478 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, /* ETSI */
2479 {{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. */
2480 {{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. */
2481 {{14,36,40,44,48,52,56,60,64},9}, /* MKK */
2482 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14, 36,40,44,48,52,56,60,64},22},/* MKK1 */
2483 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, /* Israel. */
2484 {{1,2,3,4,5,6,7,8,9,10,11,12,13,34,38,42,46},17}, /* For 11a , TELEC */
2485 {{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 */
2486 {{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 */
2489 static void rtl8180_set_channel_map(u8 channel_plan, struct ieee80211_device *ieee)
2493 /* lzm add 080826 */
2494 ieee->MinPassiveChnlNum = MAX_CHANNEL_NUMBER+1;
2495 ieee->IbssStartChnl = 0;
2497 switch (channel_plan) {
2498 case COUNTRY_CODE_FCC:
2499 case COUNTRY_CODE_IC:
2500 case COUNTRY_CODE_ETSI:
2501 case COUNTRY_CODE_SPAIN:
2502 case COUNTRY_CODE_FRANCE:
2503 case COUNTRY_CODE_MKK:
2504 case COUNTRY_CODE_MKK1:
2505 case COUNTRY_CODE_ISRAEL:
2506 case COUNTRY_CODE_TELEC:
2509 ieee->bGlobalDomain = false;
2510 if (ChannelPlan[channel_plan].Len != 0) {
2511 /* Clear old channel map */
2512 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
2513 /* Set new channel map */
2514 for (i = 0; i < ChannelPlan[channel_plan].Len; i++) {
2515 if (ChannelPlan[channel_plan].Channel[i] <= 14)
2516 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
2521 case COUNTRY_CODE_GLOBAL_DOMAIN:
2523 GET_DOT11D_INFO(ieee)->bEnabled = 0;
2525 ieee->bGlobalDomain = true;
2528 case COUNTRY_CODE_WORLD_WIDE_13_INDEX:/* lzm add 080826 */
2530 ieee->MinPassiveChnlNum = 12;
2531 ieee->IbssStartChnl = 10;
2537 ieee->bGlobalDomain = false;
2538 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
2539 for (i = 1; i <= 14; i++)
2540 GET_DOT11D_INFO(ieee)->channel_map[i] = 1;
2546 void GPIOChangeRFWorkItemCallBack(struct work_struct *work);
2549 static void rtl8180_statistics_init(struct Stats *pstats)
2551 memset(pstats, 0, sizeof(struct Stats));
2554 static void rtl8180_link_detect_init(plink_detect_t plink_detect)
2556 memset(plink_detect, 0, sizeof(link_detect_t));
2557 plink_detect->SlotNum = DEFAULT_SLOT_NUM;
2560 /* YJ,add,080828,end */
2561 static void rtl8187se_eeprom_register_read(struct eeprom_93cx6 *eeprom)
2563 struct net_device *dev = eeprom->data;
2564 u8 reg = read_nic_byte(dev, EPROM_CMD);
2566 eeprom->reg_data_in = reg & RTL818X_EEPROM_CMD_WRITE;
2567 eeprom->reg_data_out = reg & RTL818X_EEPROM_CMD_READ;
2568 eeprom->reg_data_clock = reg & RTL818X_EEPROM_CMD_CK;
2569 eeprom->reg_chip_select = reg & RTL818X_EEPROM_CMD_CS;
2572 static void rtl8187se_eeprom_register_write(struct eeprom_93cx6 *eeprom)
2574 struct net_device *dev = eeprom->data;
2577 if (eeprom->reg_data_in)
2578 reg |= RTL818X_EEPROM_CMD_WRITE;
2579 if (eeprom->reg_data_out)
2580 reg |= RTL818X_EEPROM_CMD_READ;
2581 if (eeprom->reg_data_clock)
2582 reg |= RTL818X_EEPROM_CMD_CK;
2583 if (eeprom->reg_chip_select)
2584 reg |= RTL818X_EEPROM_CMD_CS;
2586 write_nic_byte(dev, EPROM_CMD, reg);
2587 read_nic_byte(dev, EPROM_CMD);
2591 short rtl8180_init(struct net_device *dev)
2593 struct r8180_priv *priv = ieee80211_priv(dev);
2599 struct eeprom_93cx6 eeprom;
2603 eeprom.register_read = rtl8187se_eeprom_register_read;
2604 eeprom.register_write = rtl8187se_eeprom_register_write;
2605 eeprom.width = PCI_EEPROM_WIDTH_93C46;
2607 eeprom_93cx6_read(&eeprom, EEPROM_COUNTRY_CODE>>1, &eeprom_val);
2608 priv->channel_plan = eeprom_val & 0xFF;
2609 if (priv->channel_plan > COUNTRY_CODE_GLOBAL_DOMAIN) {
2610 printk("rtl8180_init:Error channel plan! Set to default.\n");
2611 priv->channel_plan = 0;
2614 DMESG("Channel plan is %d\n", priv->channel_plan);
2615 rtl8180_set_channel_map(priv->channel_plan, priv->ieee80211);
2617 /* FIXME: these constants are placed in a bad pleace. */
2618 priv->txbuffsize = 2048; /* 1024; */
2619 priv->txringcount = 32; /* 32; */
2620 priv->rxbuffersize = 2048; /* 1024; */
2621 priv->rxringcount = 64; /* 32; */
2622 priv->txbeaconcount = 2;
2623 priv->rx_skb_complete = 1;
2625 priv->RFChangeInProgress = false;
2626 priv->SetRFPowerStateInProgress = false;
2627 priv->RFProgType = 0;
2628 priv->bInHctTest = false;
2630 priv->irq_enabled = 0;
2632 rtl8180_statistics_init(&priv->stats);
2633 rtl8180_link_detect_init(&priv->link_detect);
2635 priv->ack_tx_to_ieee = 0;
2636 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2637 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2638 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2639 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2640 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;
2641 priv->ieee80211->active_scan = 1;
2642 priv->ieee80211->rate = 110; /* 11 mbps */
2643 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION;
2644 priv->ieee80211->host_encrypt = 1;
2645 priv->ieee80211->host_decrypt = 1;
2646 priv->ieee80211->sta_wake_up = rtl8180_hw_wakeup;
2647 priv->ieee80211->ps_request_tx_ack = rtl8180_rq_tx_ack;
2648 priv->ieee80211->enter_sleep_state = rtl8180_hw_sleep;
2649 priv->ieee80211->ps_is_queue_empty = rtl8180_is_tx_queue_empty;
2651 priv->hw_wep = hwwep;
2652 priv->prism_hdr = 0;
2654 priv->retry_rts = DEFAULT_RETRY_RTS;
2655 priv->retry_data = DEFAULT_RETRY_DATA;
2656 priv->RFChangeInProgress = false;
2657 priv->SetRFPowerStateInProgress = false;
2658 priv->RFProgType = 0;
2659 priv->bInHctTest = false;
2660 priv->bInactivePs = true; /* false; */
2661 priv->ieee80211->bInactivePs = priv->bInactivePs;
2662 priv->bSwRfProcessing = false;
2663 priv->eRFPowerState = eRfOff;
2664 priv->RfOffReason = 0;
2665 priv->LedStrategy = SW_LED_MODE0;
2666 priv->TxPollingTimes = 0; /* lzm add 080826 */
2667 priv->bLeisurePs = true;
2668 priv->dot11PowerSaveMode = eActive;
2669 priv->AdMinCheckPeriod = 5;
2670 priv->AdMaxCheckPeriod = 10;
2671 priv->AdMaxRxSsThreshold = 30; /* 60->30 */
2672 priv->AdRxSsThreshold = 20; /* 50->20 */
2673 priv->AdCheckPeriod = priv->AdMinCheckPeriod;
2674 priv->AdTickCount = 0;
2675 priv->AdRxSignalStrength = -1;
2676 priv->RegSwAntennaDiversityMechanism = 0;
2677 priv->RegDefaultAntenna = 0;
2678 priv->SignalStrength = 0;
2679 priv->AdRxOkCnt = 0;
2680 priv->CurrAntennaIndex = 0;
2681 priv->AdRxSsBeforeSwitched = 0;
2682 init_timer(&priv->SwAntennaDiversityTimer);
2683 priv->SwAntennaDiversityTimer.data = (unsigned long)dev;
2684 priv->SwAntennaDiversityTimer.function = (void *)SwAntennaDiversityTimerCallback;
2685 priv->bDigMechanism = 1;
2686 priv->InitialGain = 6;
2687 priv->bXtalCalibration = false;
2688 priv->XtalCal_Xin = 0;
2689 priv->XtalCal_Xout = 0;
2690 priv->bTxPowerTrack = false;
2691 priv->ThermalMeter = 0;
2692 priv->FalseAlarmRegValue = 0;
2693 priv->RegDigOfdmFaUpTh = 0xc; /* Upper threhold of OFDM false alarm, which is used in DIG. */
2694 priv->DIG_NumberFallbackVote = 0;
2695 priv->DIG_NumberUpgradeVote = 0;
2696 priv->LastSignalStrengthInPercent = 0;
2697 priv->Stats_SignalStrength = 0;
2698 priv->LastRxPktAntenna = 0;
2699 priv->SignalQuality = 0; /* in 0-100 index. */
2700 priv->Stats_SignalQuality = 0;
2701 priv->RecvSignalPower = 0; /* in dBm. */
2702 priv->Stats_RecvSignalPower = 0;
2703 priv->AdMainAntennaRxOkCnt = 0;
2704 priv->AdAuxAntennaRxOkCnt = 0;
2705 priv->bHWAdSwitched = false;
2706 priv->bRegHighPowerMechanism = true;
2707 priv->RegHiPwrUpperTh = 77;
2708 priv->RegHiPwrLowerTh = 75;
2709 priv->RegRSSIHiPwrUpperTh = 70;
2710 priv->RegRSSIHiPwrLowerTh = 20;
2711 priv->bCurCCKPkt = false;
2712 priv->UndecoratedSmoothedSS = -1;
2713 priv->bToUpdateTxPwr = false;
2714 priv->CurCCKRSSI = 0;
2717 priv->NumTxOkTotal = 0;
2718 priv->NumTxUnicast = 0;
2719 priv->keepAliveLevel = DEFAULT_KEEP_ALIVE_LEVEL;
2720 priv->PowerProfile = POWER_PROFILE_AC;
2721 priv->CurrRetryCnt = 0;
2722 priv->LastRetryCnt = 0;
2723 priv->LastTxokCnt = 0;
2724 priv->LastRxokCnt = 0;
2725 priv->LastRetryRate = 0;
2726 priv->bTryuping = 0;
2727 priv->CurrTxRate = 0;
2728 priv->CurrRetryRate = 0;
2729 priv->TryupingCount = 0;
2730 priv->TryupingCountNoData = 0;
2731 priv->TryDownCountLowData = 0;
2732 priv->LastTxOKBytes = 0;
2733 priv->LastFailTxRate = 0;
2734 priv->LastFailTxRateSS = 0;
2735 priv->FailTxRateCount = 0;
2736 priv->LastTxThroughput = 0;
2737 priv->NumTxOkBytesTotal = 0;
2738 priv->ForcedDataRate = 0;
2739 priv->RegBModeGainStage = 1;
2741 priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
2742 spin_lock_init(&priv->irq_lock);
2743 spin_lock_init(&priv->irq_th_lock);
2744 spin_lock_init(&priv->tx_lock);
2745 spin_lock_init(&priv->ps_lock);
2746 spin_lock_init(&priv->rf_ps_lock);
2747 sema_init(&priv->wx_sem, 1);
2748 sema_init(&priv->rf_state, 1);
2749 INIT_WORK(&priv->reset_wq, (void *)rtl8180_restart_wq);
2750 INIT_WORK(&priv->tx_irq_wq, (void *)rtl8180_tx_irq_wq);
2751 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,
2752 (void *)rtl8180_hw_wakeup_wq);
2753 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,
2754 (void *)rtl8180_hw_sleep_wq);
2755 INIT_WORK(&priv->ieee80211->wmm_param_update_wq,
2756 (void *)rtl8180_wmm_param_update);
2757 INIT_DELAYED_WORK(&priv->ieee80211->rate_adapter_wq,
2758 (void *)rtl8180_rate_adapter);
2759 INIT_DELAYED_WORK(&priv->ieee80211->hw_dig_wq,
2760 (void *)rtl8180_hw_dig_wq);
2761 INIT_DELAYED_WORK(&priv->ieee80211->tx_pw_wq,
2762 (void *)rtl8180_tx_pw_wq);
2763 INIT_DELAYED_WORK(&priv->ieee80211->GPIOChangeRFWorkItem,
2764 (void *) GPIOChangeRFWorkItemCallBack);
2765 tasklet_init(&priv->irq_rx_tasklet,
2766 (void(*)(unsigned long)) rtl8180_irq_rx_tasklet,
2767 (unsigned long)priv);
2769 init_timer(&priv->watch_dog_timer);
2770 priv->watch_dog_timer.data = (unsigned long)dev;
2771 priv->watch_dog_timer.function = watch_dog_adaptive;
2773 init_timer(&priv->rateadapter_timer);
2774 priv->rateadapter_timer.data = (unsigned long)dev;
2775 priv->rateadapter_timer.function = timer_rate_adaptive;
2776 priv->RateAdaptivePeriod = RATE_ADAPTIVE_TIMER_PERIOD;
2777 priv->bEnhanceTxPwr = false;
2779 priv->ieee80211->softmac_hard_start_xmit = rtl8180_hard_start_xmit;
2780 priv->ieee80211->set_chan = rtl8180_set_chan;
2781 priv->ieee80211->link_change = rtl8180_link_change;
2782 priv->ieee80211->softmac_data_hard_start_xmit = rtl8180_hard_data_xmit;
2783 priv->ieee80211->data_hard_stop = rtl8180_data_hard_stop;
2784 priv->ieee80211->data_hard_resume = rtl8180_data_hard_resume;
2786 priv->ieee80211->init_wmmparam_flag = 0;
2788 priv->ieee80211->start_send_beacons = rtl8180_start_tx_beacon;
2789 priv->ieee80211->stop_send_beacons = rtl8180_beacon_tx_disable;
2790 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2792 priv->MWIEnable = 0;
2794 priv->ShortRetryLimit = 7;
2795 priv->LongRetryLimit = 7;
2796 priv->EarlyRxThreshold = 7;
2798 priv->CSMethod = (0x01 << 29);
2800 priv->TransmitConfig = TCR_DurProcMode_OFFSET |
2801 (7<<TCR_MXDMA_OFFSET) |
2802 (priv->ShortRetryLimit<<TCR_SRL_OFFSET) |
2803 (priv->LongRetryLimit<<TCR_LRL_OFFSET) |
2806 priv->ReceiveConfig = RCR_AMF | RCR_ADF | RCR_ACF |
2807 RCR_AB | RCR_AM | RCR_APM |
2808 (7<<RCR_MXDMA_OFFSET) |
2809 (priv->EarlyRxThreshold<<RCR_FIFO_OFFSET) |
2810 (priv->EarlyRxThreshold == 7 ?
2811 RCR_ONLYERLPKT : 0);
2813 priv->IntrMask = IMR_TMGDOK | IMR_TBDER | IMR_THPDER |
2814 IMR_THPDER | IMR_THPDOK |
2815 IMR_TVODER | IMR_TVODOK |
2816 IMR_TVIDER | IMR_TVIDOK |
2817 IMR_TBEDER | IMR_TBEDOK |
2818 IMR_TBKDER | IMR_TBKDOK |
2823 priv->InitialGain = 6;
2825 DMESG("MAC controller is a RTL8187SE b/g");
2828 priv->ieee80211->modulation |= IEEE80211_OFDM_MODULATION;
2829 priv->ieee80211->short_slot = 1;
2831 /* just for sync 85 */
2832 priv->enable_gpio0 = 0;
2834 eeprom_93cx6_read(&eeprom, EEPROM_SW_REVD_OFFSET, &eeprom_val);
2835 usValue = eeprom_val;
2836 DMESG("usValue is 0x%x\n", usValue);
2837 /* 3Read AntennaDiversity */
2839 /* SW Antenna Diversity. */
2840 if ((usValue & EEPROM_SW_AD_MASK) != EEPROM_SW_AD_ENABLE)
2841 priv->EEPROMSwAntennaDiversity = false;
2843 priv->EEPROMSwAntennaDiversity = true;
2845 /* Default Antenna to use. */
2846 if ((usValue & EEPROM_DEF_ANT_MASK) != EEPROM_DEF_ANT_1)
2847 priv->EEPROMDefaultAntenna1 = false;
2849 priv->EEPROMDefaultAntenna1 = true;
2851 if (priv->RegSwAntennaDiversityMechanism == 0) /* Auto */
2852 /* 0: default from EEPROM. */
2853 priv->bSwAntennaDiverity = priv->EEPROMSwAntennaDiversity;
2855 /* 1:disable antenna diversity, 2: enable antenna diversity. */
2856 priv->bSwAntennaDiverity = ((priv->RegSwAntennaDiversityMechanism == 1) ? false : true);
2858 if (priv->RegDefaultAntenna == 0)
2859 /* 0: default from EEPROM. */
2860 priv->bDefaultAntenna1 = priv->EEPROMDefaultAntenna1;
2862 /* 1: main, 2: aux. */
2863 priv->bDefaultAntenna1 = ((priv->RegDefaultAntenna == 2) ? true : false);
2865 /* rtl8185 can calc plcp len in HW. */
2866 priv->hw_plcp_len = 1;
2868 priv->plcp_preamble_mode = 2;
2869 /* the eeprom type is stored in RCR register bit #6 */
2870 if (RCR_9356SEL & read_nic_dword(dev, RCR))
2871 priv->epromtype = EPROM_93c56;
2873 priv->epromtype = EPROM_93c46;
2875 eeprom_93cx6_multiread(&eeprom, 0x7, (__le16 *)
2878 for (i = 1, j = 0; i < 14; i += 2, j++) {
2879 eeprom_93cx6_read(&eeprom, EPROM_TXPW_CH1_2 + j, &word);
2880 priv->chtxpwr[i] = word & 0xff;
2881 priv->chtxpwr[i+1] = (word & 0xff00)>>8;
2883 for (i = 1, j = 0; i < 14; i += 2, j++) {
2884 eeprom_93cx6_read(&eeprom, EPROM_TXPW_OFDM_CH1_2 + j, &word);
2885 priv->chtxpwr_ofdm[i] = word & 0xff;
2886 priv->chtxpwr_ofdm[i+1] = (word & 0xff00) >> 8;
2889 /* 3Read crystal calibtration and thermal meter indication on 87SE. */
2890 eeprom_93cx6_read(&eeprom, EEPROM_RSV>>1, &tmpu16);
2892 /* Crystal calibration for Xin and Xout resp. */
2893 priv->XtalCal_Xout = tmpu16 & EEPROM_XTAL_CAL_XOUT_MASK;
2894 priv->XtalCal_Xin = (tmpu16 & EEPROM_XTAL_CAL_XIN_MASK) >> 4;
2895 if ((tmpu16 & EEPROM_XTAL_CAL_ENABLE) >> 12)
2896 priv->bXtalCalibration = true;
2898 /* Thermal meter reference indication. */
2899 priv->ThermalMeter = (u8)((tmpu16 & EEPROM_THERMAL_METER_MASK) >> 8);
2900 if ((tmpu16 & EEPROM_THERMAL_METER_ENABLE) >> 13)
2901 priv->bTxPowerTrack = true;
2903 eeprom_93cx6_read(&eeprom, EPROM_TXPW_BASE, &word);
2904 priv->cck_txpwr_base = word & 0xf;
2905 priv->ofdm_txpwr_base = (word>>4) & 0xf;
2907 eeprom_93cx6_read(&eeprom, EPROM_VERSION, &version);
2908 DMESG("EEPROM version %x", version);
2909 priv->rcr_csense = 3;
2911 eeprom_93cx6_read(&eeprom, ENERGY_TRESHOLD, &eeprom_val);
2912 priv->cs_treshold = (eeprom_val & 0xff00) >> 8;
2914 eeprom_93cx6_read(&eeprom, RFCHIPID, &eeprom_val);
2915 priv->rf_sleep = rtl8225z4_rf_sleep;
2916 priv->rf_wakeup = rtl8225z4_rf_wakeup;
2917 DMESGW("**PLEASE** REPORT SUCCESSFUL/UNSUCCESSFUL TO Realtek!");
2919 priv->rf_close = rtl8225z2_rf_close;
2920 priv->rf_init = rtl8225z2_rf_init;
2921 priv->rf_set_chan = rtl8225z2_rf_set_chan;
2922 priv->rf_set_sens = NULL;
2924 if (0 != alloc_rx_desc_ring(dev, priv->rxbuffersize, priv->rxringcount))
2927 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2928 TX_MANAGEPRIORITY_RING_ADDR))
2931 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2932 TX_BKPRIORITY_RING_ADDR))
2935 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2936 TX_BEPRIORITY_RING_ADDR))
2939 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2940 TX_VIPRIORITY_RING_ADDR))
2943 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2944 TX_VOPRIORITY_RING_ADDR))
2947 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
2948 TX_HIGHPRIORITY_RING_ADDR))
2951 if (0 != alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txbeaconcount,
2952 TX_BEACON_RING_ADDR))
2955 if (request_irq(dev->irq, (void *)rtl8180_interrupt, IRQF_SHARED, dev->name, dev)) {
2956 DMESGE("Error allocating IRQ %d", dev->irq);
2959 priv->irq = dev->irq;
2960 DMESG("IRQ %d", dev->irq);
2966 void rtl8180_no_hw_wep(struct net_device *dev)
2970 void rtl8180_set_hw_wep(struct net_device *dev)
2972 struct r8180_priv *priv = ieee80211_priv(dev);
2977 pgreg = read_nic_byte(dev, PGSELECT);
2978 write_nic_byte(dev, PGSELECT, pgreg & ~(1<<PGSELECT_PG_SHIFT));
2980 key0_word4 = read_nic_dword(dev, KEY0+4+4+4);
2981 key0_word4 &= ~0xff;
2982 key0_word4 |= priv->key0[3] & 0xff;
2983 write_nic_dword(dev, KEY0, (priv->key0[0]));
2984 write_nic_dword(dev, KEY0+4, (priv->key0[1]));
2985 write_nic_dword(dev, KEY0+4+4, (priv->key0[2]));
2986 write_nic_dword(dev, KEY0+4+4+4, (key0_word4));
2988 security = read_nic_byte(dev, SECURITY);
2989 security |= (1<<SECURITY_WEP_TX_ENABLE_SHIFT);
2990 security |= (1<<SECURITY_WEP_RX_ENABLE_SHIFT);
2991 security &= ~SECURITY_ENCRYP_MASK;
2992 security |= (SECURITY_ENCRYP_104<<SECURITY_ENCRYP_SHIFT);
2994 write_nic_byte(dev, SECURITY, security);
2996 DMESG("key %x %x %x %x", read_nic_dword(dev, KEY0+4+4+4),
2997 read_nic_dword(dev, KEY0+4+4), read_nic_dword(dev, KEY0+4),
2998 read_nic_dword(dev, KEY0));
3002 void rtl8185_rf_pins_enable(struct net_device *dev)
3005 /* tmp = read_nic_word(dev, RFPinsEnable); */
3006 write_nic_word(dev, RFPinsEnable, 0x1fff); /* | tmp); */
3009 void rtl8185_set_anaparam2(struct net_device *dev, u32 a)
3013 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3015 conf3 = read_nic_byte(dev, CONFIG3);
3016 write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
3017 write_nic_dword(dev, ANAPARAM2, a);
3019 conf3 = read_nic_byte(dev, CONFIG3);
3020 write_nic_byte(dev, CONFIG3, conf3 & ~(1<<CONFIG3_ANAPARAM_W_SHIFT));
3021 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3024 void rtl8180_set_anaparam(struct net_device *dev, u32 a)
3028 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3030 conf3 = read_nic_byte(dev, CONFIG3);
3031 write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
3032 write_nic_dword(dev, ANAPARAM, a);
3034 conf3 = read_nic_byte(dev, CONFIG3);
3035 write_nic_byte(dev, CONFIG3, conf3 & ~(1<<CONFIG3_ANAPARAM_W_SHIFT));
3036 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3039 void rtl8185_tx_antenna(struct net_device *dev, u8 ant)
3041 write_nic_byte(dev, TX_ANTENNA, ant);
3042 force_pci_posting(dev);
3046 void rtl8185_write_phy(struct net_device *dev, u8 adr, u32 data)
3052 phyw = ((data<<8) | adr);
3054 /* Note that, we must write 0xff7c after 0x7d-0x7f to write BB register. */
3055 write_nic_byte(dev, 0x7f, ((phyw & 0xff000000) >> 24));
3056 write_nic_byte(dev, 0x7e, ((phyw & 0x00ff0000) >> 16));
3057 write_nic_byte(dev, 0x7d, ((phyw & 0x0000ff00) >> 8));
3058 write_nic_byte(dev, 0x7c, ((phyw & 0x000000ff)));
3060 /* this is ok to fail when we write AGC table. check for AGC table might be
3061 * done by masking with 0x7f instead of 0xff
3063 /* if (phyr != (data&0xff)) DMESGW("Phy write timeout %x %x %x", phyr, data, adr); */
3066 inline void write_phy_ofdm(struct net_device *dev, u8 adr, u32 data)
3069 rtl8185_write_phy(dev, adr, data);
3072 void write_phy_cck(struct net_device *dev, u8 adr, u32 data)
3075 rtl8185_write_phy(dev, adr, data | 0x10000);
3078 void rtl8185_set_rate(struct net_device *dev)
3082 int basic_rate, min_rr_rate, max_rr_rate;
3084 basic_rate = ieeerate2rtlrate(240);
3085 min_rr_rate = ieeerate2rtlrate(60);
3086 max_rr_rate = ieeerate2rtlrate(240);
3088 write_nic_byte(dev, RESP_RATE,
3089 max_rr_rate<<MAX_RESP_RATE_SHIFT | min_rr_rate<<MIN_RESP_RATE_SHIFT);
3091 word = read_nic_word(dev, BRSR);
3092 word &= ~BRSR_MBR_8185;
3094 for (i = 0; i <= basic_rate; i++)
3097 write_nic_word(dev, BRSR, word);
3100 void rtl8180_adapter_start(struct net_device *dev)
3102 struct r8180_priv *priv = ieee80211_priv(dev);
3104 rtl8180_rtx_disable(dev);
3107 /* enable beacon timeout, beacon TX ok and err
3108 * LP tx ok and err, HP TX ok and err, NP TX ok and err,
3109 * RX ok and ERR, and GP timer
3111 priv->irq_mask = 0x6fcf;
3113 priv->dma_poll_mask = 0;
3115 rtl8180_beacon_tx_disable(dev);
3117 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3118 write_nic_dword(dev, MAC0, ((u32 *)dev->dev_addr)[0]);
3119 write_nic_word(dev, MAC4, ((u32 *)dev->dev_addr)[1] & 0xffff);
3120 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3122 rtl8180_update_msr(dev);
3124 /* These might be unnecessary since we do in rx_enable / tx_enable */
3128 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3131 * The following is very strange. seems to be that 1 means test mode,
3132 * but we need to acknolwledges the nic when a packet is ready
3133 * although we set it to 0
3137 CONFIG2, read_nic_byte(dev, CONFIG2) & ~\
3138 (1<<CONFIG2_DMA_POLLING_MODE_SHIFT));
3139 /* ^the nic isn't in test mode */
3141 CONFIG2, read_nic_byte(dev, CONFIG2)|(1<<4));
3143 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3145 write_nic_dword(dev, INT_TIMEOUT, 0);
3147 write_nic_byte(dev, WPA_CONFIG, 0);
3149 rtl8180_no_hw_wep(dev);
3151 rtl8185_set_rate(dev);
3152 write_nic_byte(dev, RATE_FALLBACK, 0x81);
3154 write_nic_byte(dev, GP_ENABLE, read_nic_byte(dev, GP_ENABLE) & ~(1<<6));
3156 /* FIXME cfg 3 ClkRun enable - isn't it ReadOnly ? */
3157 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
3158 write_nic_byte(dev, CONFIG3, read_nic_byte(dev, CONFIG3)
3159 | (1 << CONFIG3_CLKRUN_SHIFT));
3160 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3164 if (priv->rf_set_sens != NULL)
3165 priv->rf_set_sens(dev, priv->sens);
3166 rtl8180_irq_enable(dev);
3168 netif_start_queue(dev);
3172 * This configures registers for beacon tx and enables it via
3173 * rtl8180_beacon_tx_enable(). rtl8180_beacon_tx_disable() might
3174 * be used to stop beacon transmission
3176 void rtl8180_start_tx_beacon(struct net_device *dev)
3180 DMESG("Enabling beacon TX");
3181 rtl8180_prepare_beacon(dev);
3182 rtl8180_irq_disable(dev);
3183 rtl8180_beacon_tx_enable(dev);
3185 word = read_nic_word(dev, AtimWnd) & ~AtimWnd_AtimWnd;
3186 write_nic_word(dev, AtimWnd, word); /* word |= */
3188 word = read_nic_word(dev, BintrItv);
3189 word &= ~BintrItv_BintrItv;
3190 word |= 1000; /* priv->ieee80211->current_network.beacon_interval *
3191 ((priv->txbeaconcount > 1)?(priv->txbeaconcount-1):1);
3192 // FIXME: check if correct ^^ worked with 0x3e8;
3194 write_nic_word(dev, BintrItv, word);
3196 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
3198 rtl8185b_irq_enable(dev);
3201 static struct net_device_stats *rtl8180_stats(struct net_device *dev)
3203 struct r8180_priv *priv = ieee80211_priv(dev);
3205 return &priv->ieee80211->stats;
3209 * Change current and default preamble mode.
3212 MgntActSet_802_11_PowerSaveMode(
3213 struct r8180_priv *priv,
3217 /* Currently, we do not change power save mode on IBSS mode. */
3218 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3221 priv->ieee80211->ps = rtPsMode;
3226 void LeisurePSEnter(struct r8180_priv *priv)
3228 if (priv->bLeisurePs) {
3229 if (priv->ieee80211->ps == IEEE80211_PS_DISABLED)
3230 MgntActSet_802_11_PowerSaveMode(priv, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST); /* IEEE80211_PS_ENABLE */
3234 void LeisurePSLeave(struct r8180_priv *priv)
3236 if (priv->bLeisurePs) {
3237 if (priv->ieee80211->ps != IEEE80211_PS_DISABLED)
3238 MgntActSet_802_11_PowerSaveMode(priv, IEEE80211_PS_DISABLED);
3242 void rtl8180_hw_wakeup_wq(struct work_struct *work)
3244 struct delayed_work *dwork = to_delayed_work(work);
3245 struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, hw_wakeup_wq);
3246 struct net_device *dev = ieee->dev;
3248 rtl8180_hw_wakeup(dev);
3251 void rtl8180_hw_sleep_wq(struct work_struct *work)
3253 struct delayed_work *dwork = to_delayed_work(work);
3254 struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, hw_sleep_wq);
3255 struct net_device *dev = ieee->dev;
3257 rtl8180_hw_sleep_down(dev);
3260 static void MgntLinkKeepAlive(struct r8180_priv *priv)
3262 if (priv->keepAliveLevel == 0)
3265 if (priv->ieee80211->state == IEEE80211_LINKED) {
3270 if ((priv->keepAliveLevel == 2) ||
3271 (priv->link_detect.LastNumTxUnicast == priv->NumTxUnicast &&
3272 priv->link_detect.LastNumRxUnicast == priv->ieee80211->NumRxUnicast)
3274 priv->link_detect.IdleCount++;
3277 * Send a Keep-Alive packet packet to AP if we had been idle for a while.
3279 if (priv->link_detect.IdleCount >= ((KEEP_ALIVE_INTERVAL / CHECK_FOR_HANG_PERIOD)-1)) {
3280 priv->link_detect.IdleCount = 0;
3281 ieee80211_sta_ps_send_null_frame(priv->ieee80211, false);
3284 priv->link_detect.IdleCount = 0;
3286 priv->link_detect.LastNumTxUnicast = priv->NumTxUnicast;
3287 priv->link_detect.LastNumRxUnicast = priv->ieee80211->NumRxUnicast;
3291 static u8 read_acadapter_file(char *filename);
3293 void rtl8180_watch_dog(struct net_device *dev)
3295 struct r8180_priv *priv = ieee80211_priv(dev);
3296 bool bEnterPS = false;
3297 bool bBusyTraffic = false;
3301 if (priv->ieee80211->actscanning == false) {
3302 if ((priv->ieee80211->iw_mode != IW_MODE_ADHOC) && (priv->ieee80211->state == IEEE80211_NOLINK) && (priv->ieee80211->beinretry == false) && (priv->eRFPowerState == eRfOn))
3305 /* YJ,add,080828,for link state check */
3306 if ((priv->ieee80211->state == IEEE80211_LINKED) && (priv->ieee80211->iw_mode == IW_MODE_INFRA)) {
3307 SlotIndex = (priv->link_detect.SlotIndex++) % priv->link_detect.SlotNum;
3308 priv->link_detect.RxFrameNum[SlotIndex] = priv->ieee80211->NumRxDataInPeriod + priv->ieee80211->NumRxBcnInPeriod;
3309 for (i = 0; i < priv->link_detect.SlotNum; i++)
3310 TotalRxNum += priv->link_detect.RxFrameNum[i];
3312 if (TotalRxNum == 0) {
3313 priv->ieee80211->state = IEEE80211_ASSOCIATING;
3314 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
3318 /* YJ,add,080828,for KeepAlive */
3319 MgntLinkKeepAlive(priv);
3321 /* YJ,add,080828,for LPS */
3322 if (priv->PowerProfile == POWER_PROFILE_BATTERY)
3323 priv->bLeisurePs = true;
3324 else if (priv->PowerProfile == POWER_PROFILE_AC) {
3325 LeisurePSLeave(priv);
3326 priv->bLeisurePs = false;
3329 if (priv->ieee80211->state == IEEE80211_LINKED) {
3330 priv->link_detect.NumRxOkInPeriod = priv->ieee80211->NumRxDataInPeriod;
3331 if (priv->link_detect.NumRxOkInPeriod > 666 ||
3332 priv->link_detect.NumTxOkInPeriod > 666) {
3333 bBusyTraffic = true;
3335 if (((priv->link_detect.NumRxOkInPeriod + priv->link_detect.NumTxOkInPeriod) > 8)
3336 || (priv->link_detect.NumRxOkInPeriod > 2)) {
3342 LeisurePSEnter(priv);
3344 LeisurePSLeave(priv);
3346 LeisurePSLeave(priv);
3347 priv->link_detect.bBusyTraffic = bBusyTraffic;
3348 priv->link_detect.NumRxOkInPeriod = 0;
3349 priv->link_detect.NumTxOkInPeriod = 0;
3350 priv->ieee80211->NumRxDataInPeriod = 0;
3351 priv->ieee80211->NumRxBcnInPeriod = 0;
3354 int _rtl8180_up(struct net_device *dev)
3356 struct r8180_priv *priv = ieee80211_priv(dev);
3360 DMESG("Bringing up iface");
3361 rtl8185b_adapter_start(dev);
3362 rtl8185b_rx_enable(dev);
3363 rtl8185b_tx_enable(dev);
3364 if (priv->bInactivePs) {
3365 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3368 timer_rate_adaptive((unsigned long)dev);
3369 watch_dog_adaptive((unsigned long)dev);
3370 if (priv->bSwAntennaDiverity)
3371 SwAntennaDiversityTimerCallback(dev);
3372 ieee80211_softmac_start_protocol(priv->ieee80211);
3376 int rtl8180_open(struct net_device *dev)
3378 struct r8180_priv *priv = ieee80211_priv(dev);
3381 down(&priv->wx_sem);
3382 ret = rtl8180_up(dev);
3387 int rtl8180_up(struct net_device *dev)
3389 struct r8180_priv *priv = ieee80211_priv(dev);
3394 return _rtl8180_up(dev);
3397 int rtl8180_close(struct net_device *dev)
3399 struct r8180_priv *priv = ieee80211_priv(dev);
3402 down(&priv->wx_sem);
3403 ret = rtl8180_down(dev);
3409 int rtl8180_down(struct net_device *dev)
3411 struct r8180_priv *priv = ieee80211_priv(dev);
3418 ieee80211_softmac_stop_protocol(priv->ieee80211);
3420 if (!netif_queue_stopped(dev))
3421 netif_stop_queue(dev);
3422 rtl8180_rtx_disable(dev);
3423 rtl8180_irq_disable(dev);
3424 del_timer_sync(&priv->watch_dog_timer);
3425 del_timer_sync(&priv->rateadapter_timer);
3426 cancel_delayed_work(&priv->ieee80211->rate_adapter_wq);
3427 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
3428 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
3429 cancel_delayed_work(&priv->ieee80211->hw_dig_wq);
3430 cancel_delayed_work(&priv->ieee80211->tx_pw_wq);
3431 del_timer_sync(&priv->SwAntennaDiversityTimer);
3432 SetZebraRFPowerState8185(dev, eRfOff);
3433 memset(&(priv->ieee80211->current_network), 0, sizeof(struct ieee80211_network));
3434 priv->ieee80211->state = IEEE80211_NOLINK;
3438 void rtl8180_restart_wq(struct work_struct *work)
3440 struct r8180_priv *priv = container_of(work, struct r8180_priv, reset_wq);
3441 struct net_device *dev = priv->dev;
3443 down(&priv->wx_sem);
3445 rtl8180_commit(dev);
3450 void rtl8180_restart(struct net_device *dev)
3452 struct r8180_priv *priv = ieee80211_priv(dev);
3454 schedule_work(&priv->reset_wq);
3457 void rtl8180_commit(struct net_device *dev)
3459 struct r8180_priv *priv = ieee80211_priv(dev);
3464 del_timer_sync(&priv->watch_dog_timer);
3465 del_timer_sync(&priv->rateadapter_timer);
3466 cancel_delayed_work(&priv->ieee80211->rate_adapter_wq);
3467 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
3468 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
3469 cancel_delayed_work(&priv->ieee80211->hw_dig_wq);
3470 cancel_delayed_work(&priv->ieee80211->tx_pw_wq);
3471 del_timer_sync(&priv->SwAntennaDiversityTimer);
3472 ieee80211_softmac_stop_protocol(priv->ieee80211);
3473 rtl8180_irq_disable(dev);
3474 rtl8180_rtx_disable(dev);
3478 static void r8180_set_multicast(struct net_device *dev)
3480 struct r8180_priv *priv = ieee80211_priv(dev);
3483 promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
3485 if (promisc != priv->promisc)
3486 rtl8180_restart(dev);
3488 priv->promisc = promisc;
3491 int r8180_set_mac_adr(struct net_device *dev, void *mac)
3493 struct r8180_priv *priv = ieee80211_priv(dev);
3494 struct sockaddr *addr = mac;
3496 down(&priv->wx_sem);
3498 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
3500 if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
3501 memcpy(priv->ieee80211->current_network.bssid, dev->dev_addr, ETH_ALEN);
3513 /* based on ipw2200 driver */
3514 int rtl8180_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3516 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3517 struct iwreq *wrq = (struct iwreq *) rq;
3521 case RTL_IOCTL_WPA_SUPPLICANT:
3522 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
3531 static const struct net_device_ops rtl8180_netdev_ops = {
3532 .ndo_open = rtl8180_open,
3533 .ndo_stop = rtl8180_close,
3534 .ndo_get_stats = rtl8180_stats,
3535 .ndo_tx_timeout = rtl8180_restart,
3536 .ndo_do_ioctl = rtl8180_ioctl,
3537 .ndo_set_rx_mode = r8180_set_multicast,
3538 .ndo_set_mac_address = r8180_set_mac_adr,
3539 .ndo_validate_addr = eth_validate_addr,
3540 .ndo_change_mtu = eth_change_mtu,
3541 .ndo_start_xmit = ieee80211_rtl_xmit,
3544 static int __devinit rtl8180_pci_probe(struct pci_dev *pdev,
3545 const struct pci_device_id *id)
3547 unsigned long ioaddr = 0;
3548 struct net_device *dev = NULL;
3549 struct r8180_priv *priv = NULL;
3553 unsigned long pmem_start, pmem_len, pmem_flags;
3555 DMESG("Configuring chip resources");
3557 if (pci_enable_device(pdev)) {
3558 DMESG("Failed to enable PCI device");
3562 pci_set_master(pdev);
3563 pci_set_dma_mask(pdev, 0xffffff00ULL);
3564 pci_set_consistent_dma_mask(pdev, 0xffffff00ULL);
3565 dev = alloc_ieee80211(sizeof(struct r8180_priv));
3570 priv = ieee80211_priv(dev);
3571 priv->ieee80211 = netdev_priv(dev);
3573 pci_set_drvdata(pdev, dev);
3574 SET_NETDEV_DEV(dev, &pdev->dev);
3576 priv = ieee80211_priv(dev);
3579 pmem_start = pci_resource_start(pdev, 1);
3580 pmem_len = pci_resource_len(pdev, 1);
3581 pmem_flags = pci_resource_flags(pdev, 1);
3583 if (!(pmem_flags & IORESOURCE_MEM)) {
3584 DMESG("region #1 not a MMIO resource, aborting");
3588 if (!request_mem_region(pmem_start, pmem_len, RTL8180_MODULE_NAME)) {
3589 DMESG("request_mem_region failed!");
3593 ioaddr = (unsigned long)ioremap_nocache(pmem_start, pmem_len);
3594 if (ioaddr == (unsigned long)NULL) {
3595 DMESG("ioremap failed!");
3599 dev->mem_start = ioaddr; /* shared mem start */
3600 dev->mem_end = ioaddr + pci_resource_len(pdev, 0); /* shared mem end */
3602 pci_read_config_byte(pdev, 0x05, &unit);
3603 pci_write_config_byte(pdev, 0x05, unit & (~0x04));
3605 dev->irq = pdev->irq;
3608 dev->netdev_ops = &rtl8180_netdev_ops;
3609 dev->wireless_handlers = &r8180_wx_handlers_def;
3611 dev->type = ARPHRD_ETHER;
3612 dev->watchdog_timeo = HZ*3;
3614 if (dev_alloc_name(dev, ifname) < 0) {
3615 DMESG("Oops: devname already taken! Trying wlan%%d...\n");
3616 strcpy(ifname, "wlan%d");
3617 dev_alloc_name(dev, ifname);
3620 if (rtl8180_init(dev) != 0) {
3621 DMESG("Initialization failed");
3625 netif_carrier_off(dev);
3627 register_netdev(dev);
3629 rtl8180_proc_init_one(dev);
3631 DMESG("Driver probe completed\n");
3634 if (dev->mem_start != (unsigned long)NULL) {
3635 iounmap((void *)dev->mem_start);
3636 release_mem_region(pci_resource_start(pdev, 1),
3637 pci_resource_len(pdev, 1));
3642 free_irq(dev->irq, dev);
3645 free_ieee80211(dev);
3649 pci_disable_device(pdev);
3651 DMESG("wlan driver load failed\n");
3652 pci_set_drvdata(pdev, NULL);
3656 static void __devexit rtl8180_pci_remove(struct pci_dev *pdev)
3658 struct r8180_priv *priv;
3659 struct net_device *dev = pci_get_drvdata(pdev);
3662 unregister_netdev(dev);
3664 priv = ieee80211_priv(dev);
3666 rtl8180_proc_remove_one(dev);
3668 priv->rf_close(dev);
3673 DMESG("Freeing irq %d", dev->irq);
3674 free_irq(dev->irq, dev);
3678 free_rx_desc_ring(dev);
3679 free_tx_desc_rings(dev);
3681 if (dev->mem_start != (unsigned long)NULL) {
3682 iounmap((void *)dev->mem_start);
3683 release_mem_region(pci_resource_start(pdev, 1),
3684 pci_resource_len(pdev, 1));
3687 free_ieee80211(dev);
3689 pci_disable_device(pdev);
3691 DMESG("wlan driver removed\n");
3694 /* fun with the built-in ieee80211 stack... */
3695 extern int ieee80211_crypto_init(void);
3696 extern void ieee80211_crypto_deinit(void);
3697 extern int ieee80211_crypto_tkip_init(void);
3698 extern void ieee80211_crypto_tkip_exit(void);
3699 extern int ieee80211_crypto_ccmp_init(void);
3700 extern void ieee80211_crypto_ccmp_exit(void);
3701 extern int ieee80211_crypto_wep_init(void);
3702 extern void ieee80211_crypto_wep_exit(void);
3704 static int __init rtl8180_pci_module_init(void)
3708 ret = ieee80211_crypto_init();
3710 printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
3713 ret = ieee80211_crypto_tkip_init();
3715 printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n", ret);
3718 ret = ieee80211_crypto_ccmp_init();
3720 printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n", ret);
3723 ret = ieee80211_crypto_wep_init();
3725 printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
3729 printk(KERN_INFO "\nLinux kernel driver for RTL8180 / RTL8185 based WLAN cards\n");
3730 printk(KERN_INFO "Copyright (c) 2004-2005, Andrea Merello\n");
3731 DMESG("Initializing module");
3732 DMESG("Wireless extensions version %d", WIRELESS_EXT);
3733 rtl8180_proc_module_init();
3735 if (pci_register_driver(&rtl8180_pci_driver)) {
3736 DMESG("No device found");
3742 static void __exit rtl8180_pci_module_exit(void)
3744 pci_unregister_driver(&rtl8180_pci_driver);
3745 rtl8180_proc_module_remove();
3746 ieee80211_crypto_tkip_exit();
3747 ieee80211_crypto_ccmp_exit();
3748 ieee80211_crypto_wep_exit();
3749 ieee80211_crypto_deinit();
3753 void rtl8180_try_wake_queue(struct net_device *dev, int pri)
3755 unsigned long flags;
3757 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3759 spin_lock_irqsave(&priv->tx_lock, flags);
3760 enough_desc = check_nic_enought_desc(dev, pri);
3761 spin_unlock_irqrestore(&priv->tx_lock, flags);
3764 ieee80211_rtl_wake_queue(priv->ieee80211);
3767 void rtl8180_tx_isr(struct net_device *dev, int pri, short error)
3769 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3770 u32 *tail; /* tail virtual addr */
3771 u32 *head; /* head virtual addr */
3772 u32 *begin; /* start of ring virtual addr */
3773 u32 *nicv; /* nic pointer virtual addr */
3774 u32 nic; /* nic pointer physical addr */
3775 u32 nicbegin; /* start of ring physical addr */
3777 /* physical addr are ok on 32 bits since we set DMA mask */
3782 priv->stats.txretry++; /* tony 20060601 */
3783 spin_lock_irqsave(&priv->tx_lock, flag);
3785 case MANAGE_PRIORITY:
3786 tail = priv->txmapringtail;
3787 begin = priv->txmapring;
3788 head = priv->txmapringhead;
3789 nic = read_nic_dword(dev, TX_MANAGEPRIORITY_RING_ADDR);
3790 nicbegin = priv->txmapringdma;
3793 tail = priv->txbkpringtail;
3794 begin = priv->txbkpring;
3795 head = priv->txbkpringhead;
3796 nic = read_nic_dword(dev, TX_BKPRIORITY_RING_ADDR);
3797 nicbegin = priv->txbkpringdma;
3800 tail = priv->txbepringtail;
3801 begin = priv->txbepring;
3802 head = priv->txbepringhead;
3803 nic = read_nic_dword(dev, TX_BEPRIORITY_RING_ADDR);
3804 nicbegin = priv->txbepringdma;
3807 tail = priv->txvipringtail;
3808 begin = priv->txvipring;
3809 head = priv->txvipringhead;
3810 nic = read_nic_dword(dev, TX_VIPRIORITY_RING_ADDR);
3811 nicbegin = priv->txvipringdma;
3814 tail = priv->txvopringtail;
3815 begin = priv->txvopring;
3816 head = priv->txvopringhead;
3817 nic = read_nic_dword(dev, TX_VOPRIORITY_RING_ADDR);
3818 nicbegin = priv->txvopringdma;
3821 tail = priv->txhpringtail;
3822 begin = priv->txhpring;
3823 head = priv->txhpringhead;
3824 nic = read_nic_dword(dev, TX_HIGHPRIORITY_RING_ADDR);
3825 nicbegin = priv->txhpringdma;
3829 spin_unlock_irqrestore(&priv->tx_lock, flag);
3833 nicv = (u32 *)((nic - nicbegin) + (u8*)begin);
3834 if ((head <= tail && (nicv > tail || nicv < head)) ||
3835 (head > tail && (nicv > tail && nicv < head))) {
3836 DMESGW("nic has lost pointer");
3837 spin_unlock_irqrestore(&priv->tx_lock, flag);
3838 rtl8180_restart(dev);
3843 * We check all the descriptors between the head and the nic,
3844 * but not the currently pointed by the nic (the next to be txed)
3845 * and the previous of the pointed (might be in process ??)
3847 offs = (nic - nicbegin);
3848 offs = offs / 8 / 4;
3849 hd = (head - begin) / 8;
3854 j = offs + (priv->txringcount-1-hd);
3860 for (i = 0; i < j; i++) {
3861 if ((*head) & (1<<31))
3863 if (((*head)&(0x10000000)) != 0) {
3864 priv->CurrRetryCnt += (u16)((*head) & (0x000000ff));
3866 priv->NumTxOkTotal++;
3870 priv->NumTxOkBytesTotal += (*(head+3)) & (0x00000fff);
3872 *head = *head & ~(1<<31);
3874 if ((head - begin)/8 == priv->txringcount-1)
3881 * The head has been moved to the last certainly TXed
3882 * (or at least processed by the nic) packet.
3883 * The driver take forcefully owning of all these packets
3884 * If the packet previous of the nic pointer has been
3885 * processed this doesn't matter: it will be checked
3886 * here at the next round. Anyway if no more packet are
3887 * TXed no memory leak occur at all.
3891 case MANAGE_PRIORITY:
3892 priv->txmapringhead = head;
3894 if (priv->ack_tx_to_ieee) {
3895 if (rtl8180_is_tx_queue_empty(dev)) {
3896 priv->ack_tx_to_ieee = 0;
3897 ieee80211_ps_tx_ack(priv->ieee80211, !error);
3902 priv->txbkpringhead = head;
3905 priv->txbepringhead = head;
3908 priv->txvipringhead = head;
3911 priv->txvopringhead = head;
3914 priv->txhpringhead = head;
3918 spin_unlock_irqrestore(&priv->tx_lock, flag);
3921 void rtl8180_tx_irq_wq(struct work_struct *work)
3923 struct delayed_work *dwork = to_delayed_work(work);
3924 struct ieee80211_device * ieee = (struct ieee80211_device *)
3925 container_of(dwork, struct ieee80211_device, watch_dog_wq);
3926 struct net_device *dev = ieee->dev;
3928 rtl8180_tx_isr(dev, MANAGE_PRIORITY, 0);
3930 irqreturn_t rtl8180_interrupt(int irq, void *netdev, struct pt_regs *regs)
3932 struct net_device *dev = (struct net_device *) netdev;
3933 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3934 unsigned long flags;
3937 /* We should return IRQ_NONE, but for now let me keep this */
3938 if (priv->irq_enabled == 0)
3941 spin_lock_irqsave(&priv->irq_th_lock, flags);
3944 inta = read_nic_dword(dev, ISR); /* & priv->IntrMask; */
3945 write_nic_dword(dev, ISR, inta); /* reset int situation */
3947 priv->stats.shints++;
3950 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3953 * most probably we can safely return IRQ_NONE,
3954 * but for now is better to avoid problems
3958 if (inta == 0xffff) {
3960 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3966 if (!netif_running(dev)) {
3967 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
3971 if (inta & ISR_TimeOut)
3972 write_nic_dword(dev, TimerInt, 0);
3974 if (inta & ISR_TBDOK)
3975 priv->stats.txbeacon++;
3977 if (inta & ISR_TBDER)
3978 priv->stats.txbeaconerr++;
3980 if (inta & IMR_TMGDOK)
3981 rtl8180_tx_isr(dev, MANAGE_PRIORITY, 0);
3983 if (inta & ISR_THPDER) {
3984 priv->stats.txhperr++;
3985 rtl8180_tx_isr(dev, HI_PRIORITY, 1);
3986 priv->ieee80211->stats.tx_errors++;
3989 if (inta & ISR_THPDOK) { /* High priority tx ok */
3990 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
3991 priv->stats.txhpokint++;
3992 rtl8180_tx_isr(dev, HI_PRIORITY, 0);
3996 priv->stats.rxerr++;
3998 if (inta & ISR_TBKDER) { /* corresponding to BK_PRIORITY */
3999 priv->stats.txbkperr++;
4000 priv->ieee80211->stats.tx_errors++;
4001 rtl8180_tx_isr(dev, BK_PRIORITY, 1);
4002 rtl8180_try_wake_queue(dev, BE_PRIORITY);
4005 if (inta & ISR_TBEDER) { /* corresponding to BE_PRIORITY */
4006 priv->stats.txbeperr++;
4007 priv->ieee80211->stats.tx_errors++;
4008 rtl8180_tx_isr(dev, BE_PRIORITY, 1);
4009 rtl8180_try_wake_queue(dev, BE_PRIORITY);
4011 if (inta & ISR_TNPDER) { /* corresponding to VO_PRIORITY */
4012 priv->stats.txnperr++;
4013 priv->ieee80211->stats.tx_errors++;
4014 rtl8180_tx_isr(dev, NORM_PRIORITY, 1);
4015 rtl8180_try_wake_queue(dev, NORM_PRIORITY);
4018 if (inta & ISR_TLPDER) { /* corresponding to VI_PRIORITY */
4019 priv->stats.txlperr++;
4020 priv->ieee80211->stats.tx_errors++;
4021 rtl8180_tx_isr(dev, LOW_PRIORITY, 1);
4022 rtl8180_try_wake_queue(dev, LOW_PRIORITY);
4025 if (inta & ISR_ROK) {
4026 priv->stats.rxint++;
4027 tasklet_schedule(&priv->irq_rx_tasklet);
4030 if (inta & ISR_RQoSOK) {
4031 priv->stats.rxint++;
4032 tasklet_schedule(&priv->irq_rx_tasklet);
4035 if (inta & ISR_BcnInt)
4036 rtl8180_prepare_beacon(dev);
4038 if (inta & ISR_RDU) {
4039 DMESGW("No RX descriptor available");
4040 priv->stats.rxrdu++;
4041 tasklet_schedule(&priv->irq_rx_tasklet);
4044 if (inta & ISR_RXFOVW) {
4045 priv->stats.rxoverflow++;
4046 tasklet_schedule(&priv->irq_rx_tasklet);
4049 if (inta & ISR_TXFOVW)
4050 priv->stats.txoverflow++;
4052 if (inta & ISR_TNPDOK) { /* Normal priority tx ok */
4053 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
4054 priv->stats.txnpokint++;
4055 rtl8180_tx_isr(dev, NORM_PRIORITY, 0);
4058 if (inta & ISR_TLPDOK) { /* Low priority tx ok */
4059 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
4060 priv->stats.txlpokint++;
4061 rtl8180_tx_isr(dev, LOW_PRIORITY, 0);
4062 rtl8180_try_wake_queue(dev, LOW_PRIORITY);
4065 if (inta & ISR_TBKDOK) { /* corresponding to BK_PRIORITY */
4066 priv->stats.txbkpokint++;
4067 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
4068 rtl8180_tx_isr(dev, BK_PRIORITY, 0);
4069 rtl8180_try_wake_queue(dev, BE_PRIORITY);
4072 if (inta & ISR_TBEDOK) { /* corresponding to BE_PRIORITY */
4073 priv->stats.txbeperr++;
4074 priv->link_detect.NumTxOkInPeriod++; /* YJ,add,080828 */
4075 rtl8180_tx_isr(dev, BE_PRIORITY, 0);
4076 rtl8180_try_wake_queue(dev, BE_PRIORITY);
4078 force_pci_posting(dev);
4079 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
4084 void rtl8180_irq_rx_tasklet(struct r8180_priv *priv)
4086 rtl8180_rx(priv->dev);
4089 void GPIOChangeRFWorkItemCallBack(struct work_struct *work)
4091 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, GPIOChangeRFWorkItem.work);
4092 struct net_device *dev = ieee->dev;
4093 struct r8180_priv *priv = ieee80211_priv(dev);
4096 RT_RF_POWER_STATE eRfPowerStateToSet;
4097 bool bActuallySet = false;
4100 static char *RadioPowerPath = "/etc/acpi/events/RadioPower.sh";
4101 static char *envp[] = {"HOME=/", "TERM=linux", "PATH=/usr/bin:/bin", NULL};
4102 static int readf_count = 0;
4104 if (readf_count % 10 == 0)
4105 priv->PowerProfile = read_acadapter_file("/proc/acpi/ac_adapter/AC0/state");
4107 readf_count = (readf_count+1)%0xffff;
4108 /* We should turn off LED before polling FF51[4]. */
4111 btPSR = read_nic_byte(dev, PSR);
4112 write_nic_byte(dev, PSR, (btPSR & ~BIT3));
4114 /* It need to delay 4us suggested by Jong, 2008-01-16 */
4117 /* HW radio On/Off according to the value of FF51[4](config0) */
4118 btConfig0 = btPSR = read_nic_byte(dev, CONFIG0);
4120 eRfPowerStateToSet = (btConfig0 & BIT4) ? eRfOn : eRfOff;
4122 /* Turn LED back on when radio enabled */
4123 if (eRfPowerStateToSet == eRfOn)
4124 write_nic_byte(dev, PSR, btPSR | BIT3);
4126 if ((priv->ieee80211->bHwRadioOff == true) &&
4127 (eRfPowerStateToSet == eRfOn)) {
4128 priv->ieee80211->bHwRadioOff = false;
4129 bActuallySet = true;
4130 } else if ((priv->ieee80211->bHwRadioOff == false) &&
4131 (eRfPowerStateToSet == eRfOff)) {
4132 priv->ieee80211->bHwRadioOff = true;
4133 bActuallySet = true;
4137 MgntActSet_RF_State(dev, eRfPowerStateToSet, RF_CHANGE_BY_HW);
4139 /* To update the UI status for Power status changed */
4140 if (priv->ieee80211->bHwRadioOff == true)
4144 argv[0] = RadioPowerPath;
4147 call_usermodehelper(RadioPowerPath, argv, envp, 1);
4151 static u8 read_acadapter_file(char *filename)
4156 module_init(rtl8180_pci_module_init);
4157 module_exit(rtl8180_pci_module_exit);