1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 * Linux device driver for RTL8190P / RTL8192E
5 * Based on the r8180 driver, which is:
6 * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 * The full GNU General Public License is included in this distribution in the
21 * file called LICENSE.
23 * Contact Information:
24 * Jerry chuang <wlanfae@realtek.com>
28 #undef RX_DONT_PASS_UL
30 #undef DEBUG_RX_VERBOSE
36 #undef DEBUG_TX_FILLDESC
41 #undef DEBUG_REGISTERS
43 #undef DEBUG_IRQ_TASKLET
47 //#define CONFIG_RTL8192_IO_MAP
48 #include <linux/vmalloc.h>
49 #include <linux/slab.h>
50 #include <asm/uaccess.h>
51 #include "r8192E_hw.h"
53 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
54 #include "r8180_93cx6.h" /* Card EEPROM */
55 #include "r8192E_wx.h"
56 #include "r819xE_phy.h" //added by WB 4.30.2008
57 #include "r819xE_phyreg.h"
58 #include "r819xE_cmdpkt.h"
59 #include "r8192E_dm.h"
66 #include "ieee80211/dot11d.h"
69 //set here to open your trace code. //WB
70 u32 rt_global_debug_component =
88 // COMP_POWER_TRACKING |
90 COMP_ERR ; //always open err flags on
92 static DEFINE_PCI_DEVICE_TABLE(rtl8192_pci_id_tbl) = {
96 { PCI_DEVICE(0x10ec, 0x8190) },
98 { PCI_DEVICE(0x07aa, 0x0045) },
99 { PCI_DEVICE(0x07aa, 0x0046) },
102 { PCI_DEVICE(0x10ec, 0x8192) },
105 { PCI_DEVICE(0x07aa, 0x0044) },
106 { PCI_DEVICE(0x07aa, 0x0047) },
111 static char ifname[IFNAMSIZ] = "wlan%d";
112 static int hwwep = 1; //default use hw. set 0 to use software security
113 static int channels = 0x3fff;
115 MODULE_LICENSE("GPL");
116 MODULE_VERSION("V 1.1");
117 MODULE_DEVICE_TABLE(pci, rtl8192_pci_id_tbl);
118 //MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
119 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
122 module_param_string(ifname, ifname, sizeof(ifname), S_IRUGO|S_IWUSR);
123 module_param(hwwep,int, S_IRUGO|S_IWUSR);
124 module_param(channels,int, S_IRUGO|S_IWUSR);
126 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
127 MODULE_PARM_DESC(hwwep," Try to use hardware WEP support. Still broken and not available on all cards");
128 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
130 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
131 const struct pci_device_id *id);
132 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev);
134 static struct pci_driver rtl8192_pci_driver = {
135 .name = RTL819xE_MODULE_NAME, /* Driver name */
136 .id_table = rtl8192_pci_id_tbl, /* PCI_ID table */
137 .probe = rtl8192_pci_probe, /* probe fn */
138 .remove = __devexit_p(rtl8192_pci_disconnect), /* remove fn */
140 .suspend = rtl8192E_suspend, /* PM suspend fn */
141 .resume = rtl8192E_resume, /* PM resume fn */
143 .suspend = NULL, /* PM suspend fn */
144 .resume = NULL, /* PM resume fn */
148 static void rtl8192_start_beacon(struct net_device *dev);
149 static void rtl8192_stop_beacon(struct net_device *dev);
150 static void rtl819x_watchdog_wqcallback(struct work_struct *work);
151 static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
152 static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv);
153 static void rtl8192_prepare_beacon(struct r8192_priv *priv);
154 static irqreturn_t rtl8192_interrupt(int irq, void *netdev);
155 static void rtl8192_try_wake_queue(struct net_device *dev, int pri);
156 static void rtl819xE_tx_cmd(struct net_device *dev, struct sk_buff *skb);
157 static void rtl8192_update_ratr_table(struct net_device* dev);
158 static void rtl8192_restart(struct work_struct *work);
159 static void watch_dog_timer_callback(unsigned long data);
160 static int _rtl8192_up(struct net_device *dev);
161 static void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
165 typedef struct _CHANNEL_LIST
169 }CHANNEL_LIST, *PCHANNEL_LIST;
171 static const CHANNEL_LIST ChannelPlan[] = {
172 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64,149,153,157,161,165},24}, //FCC
173 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
174 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
175 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
176 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, //MKK //MKK
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
179 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
180 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, // For 11a , TELEC
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
182 {{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
185 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
187 int i, max_chan=-1, min_chan=-1;
188 struct ieee80211_device* ieee = priv->ieee80211;
189 switch (channel_plan)
191 case COUNTRY_CODE_FCC:
192 case COUNTRY_CODE_IC:
193 case COUNTRY_CODE_ETSI:
194 case COUNTRY_CODE_SPAIN:
195 case COUNTRY_CODE_FRANCE:
196 case COUNTRY_CODE_MKK:
197 case COUNTRY_CODE_MKK1:
198 case COUNTRY_CODE_ISRAEL:
199 case COUNTRY_CODE_TELEC:
200 case COUNTRY_CODE_MIC:
203 ieee->bGlobalDomain = false;
204 //acturally 8225 & 8256 rf chip only support B,G,24N mode
205 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256))
212 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
214 if (ChannelPlan[channel_plan].Len != 0){
215 // Clear old channel map
216 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
217 // Set new channel map
218 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
220 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
222 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
227 case COUNTRY_CODE_GLOBAL_DOMAIN:
229 GET_DOT11D_INFO(ieee)->bEnabled = 0; //this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain setting
231 ieee->bGlobalDomain = true;
240 static inline bool rx_hal_is_cck_rate(prx_fwinfo_819x_pci pdrvinfo)
242 return (pdrvinfo->RxRate == DESC90_RATE1M ||
243 pdrvinfo->RxRate == DESC90_RATE2M ||
244 pdrvinfo->RxRate == DESC90_RATE5_5M ||
245 pdrvinfo->RxRate == DESC90_RATE11M) &&
249 void CamResetAllEntry(struct net_device *dev)
251 write_nic_dword(dev, RWCAM, BIT31|BIT30);
255 void write_cam(struct net_device *dev, u8 addr, u32 data)
257 write_nic_dword(dev, WCAMI, data);
258 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
260 u32 read_cam(struct net_device *dev, u8 addr)
262 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
263 return read_nic_dword(dev, 0xa8);
266 #ifdef CONFIG_RTL8180_IO_MAP
268 u8 read_nic_byte(struct net_device *dev, int x)
270 return 0xff&inb(dev->base_addr +x);
273 u32 read_nic_dword(struct net_device *dev, int x)
275 return inl(dev->base_addr +x);
278 u16 read_nic_word(struct net_device *dev, int x)
280 return inw(dev->base_addr +x);
283 void write_nic_byte(struct net_device *dev, int x,u8 y)
285 outb(y&0xff,dev->base_addr +x);
288 void write_nic_word(struct net_device *dev, int x,u16 y)
290 outw(y,dev->base_addr +x);
293 void write_nic_dword(struct net_device *dev, int x,u32 y)
295 outl(y,dev->base_addr +x);
298 #else /* RTL_IO_MAP */
300 u8 read_nic_byte(struct net_device *dev, int x)
302 return 0xff&readb((u8*)dev->mem_start +x);
305 u32 read_nic_dword(struct net_device *dev, int x)
307 return readl((u8*)dev->mem_start +x);
310 u16 read_nic_word(struct net_device *dev, int x)
312 return readw((u8*)dev->mem_start +x);
315 void write_nic_byte(struct net_device *dev, int x,u8 y)
317 writeb(y,(u8*)dev->mem_start +x);
321 void write_nic_dword(struct net_device *dev, int x,u32 y)
323 writel(y,(u8*)dev->mem_start +x);
327 void write_nic_word(struct net_device *dev, int x,u16 y)
329 writew(y,(u8*)dev->mem_start +x);
333 #endif /* RTL_IO_MAP */
335 u8 rtl8192e_ap_sec_type(struct ieee80211_device *ieee)
337 static const u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
338 static const u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
339 int wpa_ie_len= ieee->wpa_ie_len;
340 struct ieee80211_crypt_data* crypt;
343 crypt = ieee->crypt[ieee->tx_keyidx];
345 encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY) ||
346 (ieee->host_encrypt && crypt && crypt->ops &&
347 (0 == strcmp(crypt->ops->name,"WEP")));
350 if(encrypt && (wpa_ie_len == 0)) {
351 // wep encryption, no N mode setting */
353 } else if((wpa_ie_len != 0)) {
354 // parse pairwise key type */
355 if (((ieee->wpa_ie[0] == 0xdd) && (!memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) ||
356 ((ieee->wpa_ie[0] == 0x30) && (!memcmp(&ieee->wpa_ie[10],ccmp_rsn_ie, 4))))
366 rtl8192e_SetHwReg(struct net_device *dev,u8 variable,u8* val)
368 struct r8192_priv* priv = ieee80211_priv(dev);
374 write_nic_dword(dev, BSSIDR, ((u32*)(val))[0]);
375 write_nic_word(dev, BSSIDR+2, ((u16*)(val+2))[0]);
378 case HW_VAR_MEDIA_STATUS:
380 RT_OP_MODE OpMode = *((RT_OP_MODE *)(val));
381 u8 btMsr = read_nic_byte(dev, MSR);
387 case RT_OP_MODE_INFRASTRUCTURE:
391 case RT_OP_MODE_IBSS:
404 write_nic_byte(dev, MSR, btMsr);
408 case HW_VAR_CECHK_BSSID:
412 Type = ((u8*)(val))[0];
413 RegRCR = read_nic_dword(dev,RCR);
414 priv->ReceiveConfig = RegRCR;
417 RegRCR |= (RCR_CBSSID);
418 else if (Type == false)
419 RegRCR &= (~RCR_CBSSID);
421 write_nic_dword(dev, RCR,RegRCR);
422 priv->ReceiveConfig = RegRCR;
427 case HW_VAR_SLOT_TIME:
429 priv->slot_time = val[0];
430 write_nic_byte(dev, SLOT_TIME, val[0]);
435 case HW_VAR_ACK_PREAMBLE:
438 priv->short_preamble = (bool)(*(u8*)val );
439 regTmp = priv->basic_rate;
440 if (priv->short_preamble)
441 regTmp |= BRSR_AckShortPmb;
442 write_nic_dword(dev, RRSR, regTmp);
447 write_nic_dword(dev, CPU_GEN, ((u32*)(val))[0]);
456 static struct proc_dir_entry *rtl8192_proc = NULL;
458 static int proc_get_stats_ap(char *page, char **start,
459 off_t offset, int count,
460 int *eof, void *data)
462 struct net_device *dev = data;
463 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
464 struct ieee80211_device *ieee = priv->ieee80211;
465 struct ieee80211_network *target;
468 list_for_each_entry(target, &ieee->network_list, list) {
470 len += snprintf(page + len, count - len,
471 "%s ", target->ssid);
473 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
474 len += snprintf(page + len, count - len,
478 len += snprintf(page + len, count - len,
488 static int proc_get_registers(char *page, char **start,
489 off_t offset, int count,
490 int *eof, void *data)
492 struct net_device *dev = data;
497 /* This dump the current register page */
498 len += snprintf(page + len, count - len,
499 "\n####################page 0##################\n ");
503 len += snprintf(page + len, count - len,
506 for(i=0;i<16 && n<=max;i++,n++)
507 len += snprintf(page + len, count - len,
508 "%2x ",read_nic_byte(dev,n));
510 len += snprintf(page + len, count - len,"\n");
511 len += snprintf(page + len, count - len,
512 "\n####################page 1##################\n ");
515 len += snprintf(page + len, count - len,
518 for(i=0;i<16 && n<=max;i++,n++)
519 len += snprintf(page + len, count - len,
520 "%2x ",read_nic_byte(dev,0x100|n));
523 len += snprintf(page + len, count - len,
524 "\n####################page 3##################\n ");
527 len += snprintf(page + len, count - len,
530 for(i=0;i<16 && n<=max;i++,n++)
531 len += snprintf(page + len, count - len,
532 "%2x ",read_nic_byte(dev,0x300|n));
540 static int proc_get_stats_tx(char *page, char **start,
541 off_t offset, int count,
542 int *eof, void *data)
544 struct net_device *dev = data;
545 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
549 len += snprintf(page + len, count - len,
550 "TX VI priority ok int: %lu\n"
551 // "TX VI priority error int: %lu\n"
552 "TX VO priority ok int: %lu\n"
553 // "TX VO priority error int: %lu\n"
554 "TX BE priority ok int: %lu\n"
555 // "TX BE priority error int: %lu\n"
556 "TX BK priority ok int: %lu\n"
557 // "TX BK priority error int: %lu\n"
558 "TX MANAGE priority ok int: %lu\n"
559 // "TX MANAGE priority error int: %lu\n"
560 "TX BEACON priority ok int: %lu\n"
561 "TX BEACON priority error int: %lu\n"
562 "TX CMDPKT priority ok int: %lu\n"
563 // "TX high priority ok int: %lu\n"
564 // "TX high priority failed error int: %lu\n"
565 // "TX queue resume: %lu\n"
566 "TX queue stopped?: %d\n"
567 "TX fifo overflow: %lu\n"
568 // "TX beacon: %lu\n"
569 // "TX VI queue: %d\n"
570 // "TX VO queue: %d\n"
571 // "TX BE queue: %d\n"
572 // "TX BK queue: %d\n"
573 // "TX HW queue: %d\n"
574 // "TX VI dropped: %lu\n"
575 // "TX VO dropped: %lu\n"
576 // "TX BE dropped: %lu\n"
577 // "TX BK dropped: %lu\n"
578 "TX total data packets %lu\n"
579 "TX total data bytes :%lu\n",
580 // "TX beacon aborted: %lu\n",
581 priv->stats.txviokint,
582 // priv->stats.txvierr,
583 priv->stats.txvookint,
584 // priv->stats.txvoerr,
585 priv->stats.txbeokint,
586 // priv->stats.txbeerr,
587 priv->stats.txbkokint,
588 // priv->stats.txbkerr,
589 priv->stats.txmanageokint,
590 // priv->stats.txmanageerr,
591 priv->stats.txbeaconokint,
592 priv->stats.txbeaconerr,
593 priv->stats.txcmdpktokint,
594 // priv->stats.txhpokint,
595 // priv->stats.txhperr,
596 // priv->stats.txresumed,
597 netif_queue_stopped(dev),
598 priv->stats.txoverflow,
599 // priv->stats.txbeacon,
600 // atomic_read(&(priv->tx_pending[VI_QUEUE])),
601 // atomic_read(&(priv->tx_pending[VO_QUEUE])),
602 // atomic_read(&(priv->tx_pending[BE_QUEUE])),
603 // atomic_read(&(priv->tx_pending[BK_QUEUE])),
604 // read_nic_byte(dev, TXFIFOCOUNT),
605 // priv->stats.txvidrop,
606 // priv->stats.txvodrop,
607 priv->ieee80211->stats.tx_packets,
608 priv->ieee80211->stats.tx_bytes
611 // priv->stats.txbedrop,
612 // priv->stats.txbkdrop
613 // priv->stats.txdatapkt
614 // priv->stats.txbeaconerr
623 static int proc_get_stats_rx(char *page, char **start,
624 off_t offset, int count,
625 int *eof, void *data)
627 struct net_device *dev = data;
628 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
632 len += snprintf(page + len, count - len,
635 "RX rx overflow error: %lu\n"
636 "RX invalid urb error: %lu\n",
639 priv->stats.rxoverflow,
640 priv->stats.rxurberr);
646 static void rtl8192_proc_module_init(void)
648 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
649 rtl8192_proc=create_proc_entry(RTL819xE_MODULE_NAME, S_IFDIR, init_net.proc_net);
653 static void rtl8192_proc_module_remove(void)
655 remove_proc_entry(RTL819xE_MODULE_NAME, init_net.proc_net);
659 static void rtl8192_proc_remove_one(struct net_device *dev)
661 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
663 printk("dev name=======> %s\n",dev->name);
666 // remove_proc_entry("stats-hw", priv->dir_dev);
667 remove_proc_entry("stats-tx", priv->dir_dev);
668 remove_proc_entry("stats-rx", priv->dir_dev);
669 // remove_proc_entry("stats-ieee", priv->dir_dev);
670 remove_proc_entry("stats-ap", priv->dir_dev);
671 remove_proc_entry("registers", priv->dir_dev);
672 // remove_proc_entry("cck-registers",priv->dir_dev);
673 // remove_proc_entry("ofdm-registers",priv->dir_dev);
674 //remove_proc_entry(dev->name, rtl8192_proc);
675 remove_proc_entry("wlan0", rtl8192_proc);
676 priv->dir_dev = NULL;
681 static void rtl8192_proc_init_one(struct net_device *dev)
683 struct proc_dir_entry *e;
684 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
685 priv->dir_dev = create_proc_entry(dev->name,
686 S_IFDIR | S_IRUGO | S_IXUGO,
688 if (!priv->dir_dev) {
689 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
693 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
694 priv->dir_dev, proc_get_stats_rx, dev);
697 RT_TRACE(COMP_ERR,"Unable to initialize "
698 "/proc/net/rtl8192/%s/stats-rx\n",
703 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
704 priv->dir_dev, proc_get_stats_tx, dev);
707 RT_TRACE(COMP_ERR, "Unable to initialize "
708 "/proc/net/rtl8192/%s/stats-tx\n",
712 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
713 priv->dir_dev, proc_get_stats_ap, dev);
716 RT_TRACE(COMP_ERR, "Unable to initialize "
717 "/proc/net/rtl8192/%s/stats-ap\n",
721 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
722 priv->dir_dev, proc_get_registers, dev);
724 RT_TRACE(COMP_ERR, "Unable to initialize "
725 "/proc/net/rtl8192/%s/registers\n",
730 short check_nic_enough_desc(struct net_device *dev, int prio)
732 struct r8192_priv *priv = ieee80211_priv(dev);
733 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
735 /* for now we reserve two free descriptor as a safety boundary
736 * between the tail and the head
738 return (ring->entries - skb_queue_len(&ring->queue) >= 2);
741 static void tx_timeout(struct net_device *dev)
743 struct r8192_priv *priv = ieee80211_priv(dev);
745 schedule_work(&priv->reset_wq);
749 static void rtl8192_irq_enable(struct net_device *dev)
751 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
752 priv->irq_enabled = 1;
753 write_nic_dword(dev,INTA_MASK, priv->irq_mask);
756 void rtl8192_irq_disable(struct net_device *dev)
758 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
760 write_nic_dword(dev,INTA_MASK,0);
761 priv->irq_enabled = 0;
764 void rtl8192_update_msr(struct net_device *dev)
766 struct r8192_priv *priv = ieee80211_priv(dev);
769 msr = read_nic_byte(dev, MSR);
770 msr &= ~ MSR_LINK_MASK;
772 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
773 * msr must be updated if the state is ASSOCIATING.
774 * this is intentional and make sense for ad-hoc and
775 * master (see the create BSS/IBSS func)
777 if (priv->ieee80211->state == IEEE80211_LINKED){
779 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
780 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
781 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
782 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
783 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
784 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
787 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
789 write_nic_byte(dev, MSR, msr);
792 void rtl8192_set_chan(struct net_device *dev,short ch)
794 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
798 /* need to implement rf set channel here WB */
800 if (priv->rf_set_chan)
801 priv->rf_set_chan(dev, priv->chan);
804 void rtl8192_rx_enable(struct net_device *dev)
806 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
808 write_nic_dword(dev, RDQDA,priv->rx_ring_dma);
811 /* the TX_DESC_BASE setting is according to the following queue index
820 * BEACON_QUEUE ===> 8
822 static const u32 TX_DESC_BASE[] = {BKQDA, BEQDA, VIQDA, VOQDA, HCCAQDA, CQDA, MQDA, HQDA, BQDA};
823 void rtl8192_tx_enable(struct net_device *dev)
825 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
828 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
829 write_nic_dword(dev, TX_DESC_BASE[i], priv->tx_ring[i].dma);
831 ieee80211_reset_queue(priv->ieee80211);
835 static void rtl8192_free_rx_ring(struct net_device *dev)
837 struct r8192_priv *priv = ieee80211_priv(dev);
840 for (i = 0; i < priv->rxringcount; i++) {
841 struct sk_buff *skb = priv->rx_buf[i];
845 pci_unmap_single(priv->pdev,
846 *((dma_addr_t *)skb->cb),
847 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
851 pci_free_consistent(priv->pdev, sizeof(*priv->rx_ring) * priv->rxringcount,
852 priv->rx_ring, priv->rx_ring_dma);
853 priv->rx_ring = NULL;
856 static void rtl8192_free_tx_ring(struct net_device *dev, unsigned int prio)
858 struct r8192_priv *priv = ieee80211_priv(dev);
859 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
861 while (skb_queue_len(&ring->queue)) {
862 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
863 struct sk_buff *skb = __skb_dequeue(&ring->queue);
865 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
866 skb->len, PCI_DMA_TODEVICE);
868 ring->idx = (ring->idx + 1) % ring->entries;
871 pci_free_consistent(priv->pdev, sizeof(*ring->desc)*ring->entries,
872 ring->desc, ring->dma);
876 void PHY_SetRtl8192eRfOff(struct net_device* dev)
878 //disable RF-Chip A/B
879 rtl8192_setBBreg(dev, rFPGA0_XA_RFInterfaceOE, BIT4, 0x0);
880 //analog to digital off, for power save
881 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0x300, 0x0);
882 //digital to analog off, for power save
883 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x18, 0x0);
885 rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, 0xf, 0x0);
887 rtl8192_setBBreg(dev, rOFDM1_TRxPathEnable, 0xf, 0x0);
888 //analog to digital part2 off, for power save
889 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x60, 0x0);
890 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x4, 0x0);
891 // Analog parameter!!Change bias and Lbus control.
892 write_nic_byte(dev, ANAPAR_FOR_8192PciE, 0x07);
896 void rtl8192_halt_adapter(struct net_device *dev, bool reset)
898 struct r8192_priv *priv = ieee80211_priv(dev);
903 OpMode = RT_OP_MODE_NO_LINK;
904 priv->ieee80211->SetHwRegHandler(dev, HW_VAR_MEDIA_STATUS, &OpMode);
906 if (!priv->ieee80211->bSupportRemoteWakeUp) {
908 * disable tx/rx. In 8185 we write 0x10 (Reset bit),
909 * but here we make reference to WMAC and wirte 0x0
911 write_nic_byte(dev, CMDR, 0);
920 priv->bHwRfOffAction = 2;
924 * Call MgntActSet_RF_State instead to
925 * prevent RF config race condition.
927 if (!priv->ieee80211->bSupportRemoteWakeUp) {
928 PHY_SetRtl8192eRfOff(dev);
929 ulRegRead = read_nic_dword(dev,CPU_GEN);
930 ulRegRead |= CPU_GEN_SYSTEM_RESET;
931 write_nic_dword(dev,CPU_GEN, ulRegRead);
934 write_nic_dword(dev, WFCRC0, 0xffffffff);
935 write_nic_dword(dev, WFCRC1, 0xffffffff);
936 write_nic_dword(dev, WFCRC2, 0xffffffff);
938 /* Write PMR register */
939 write_nic_byte(dev, PMR, 0x5);
940 /* Disable tx, enanble rx */
941 write_nic_byte(dev, MacBlkCtrl, 0xa);
945 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
946 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
948 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
949 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
952 skb_queue_purge(&priv->skb_queue);
955 static const u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
956 inline u16 rtl8192_rate2rate(short rate)
958 if (rate >11) return 0;
959 return rtl_rate[rate];
962 static void rtl8192_data_hard_stop(struct net_device *dev)
966 static void rtl8192_data_hard_resume(struct net_device *dev)
971 * this function TX data frames when the ieee80211 stack requires this.
972 * It checks also if we need to stop the ieee tx queue, eventually do it
974 static void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
976 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
978 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
979 u8 queue_index = tcb_desc->queue_index;
981 /* shall not be referred by command packet */
982 assert(queue_index != TXCMD_QUEUE);
984 if (priv->bHwRadioOff || (!priv->up))
990 memcpy(skb->cb, &dev, sizeof(dev));
992 skb_push(skb, priv->ieee80211->tx_headroom);
993 ret = rtl8192_tx(dev, skb);
998 if (queue_index != MGNT_QUEUE) {
999 priv->ieee80211->stats.tx_bytes += (skb->len - priv->ieee80211->tx_headroom);
1000 priv->ieee80211->stats.tx_packets++;
1005 * This is a rough attempt to TX a frame
1006 * This is called by the ieee 80211 stack to TX management frames.
1007 * If the ring is full packet are dropped (for data frame the queue
1008 * is stopped before this can happen).
1010 static int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1012 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1014 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1015 u8 queue_index = tcb_desc->queue_index;
1017 if (queue_index != TXCMD_QUEUE) {
1018 if (priv->bHwRadioOff || (!priv->up))
1025 memcpy(skb->cb, &dev, sizeof(dev));
1026 if (queue_index == TXCMD_QUEUE) {
1027 rtl819xE_tx_cmd(dev, skb);
1031 tcb_desc->RATRIndex = 7;
1032 tcb_desc->bTxDisableRateFallBack = 1;
1033 tcb_desc->bTxUseDriverAssingedRate = 1;
1034 tcb_desc->bTxEnableFwCalcDur = 1;
1035 skb_push(skb, priv->ieee80211->tx_headroom);
1036 ret = rtl8192_tx(dev, skb);
1046 static void rtl8192_tx_isr(struct net_device *dev, int prio)
1048 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1049 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
1051 while (skb_queue_len(&ring->queue)) {
1052 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1053 struct sk_buff *skb;
1056 * beacon packet will only use the first descriptor defaultly,
1057 * and the OWN may not be cleared by the hardware
1059 if (prio != BEACON_QUEUE) {
1062 ring->idx = (ring->idx + 1) % ring->entries;
1065 skb = __skb_dequeue(&ring->queue);
1066 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1067 skb->len, PCI_DMA_TODEVICE);
1071 if (prio == MGNT_QUEUE) {
1072 if (priv->ieee80211->ack_tx_to_ieee) {
1073 if (rtl8192_is_tx_queue_empty(dev)) {
1074 priv->ieee80211->ack_tx_to_ieee = 0;
1075 ieee80211_ps_tx_ack(priv->ieee80211, 1);
1080 if (prio != BEACON_QUEUE) {
1081 /* try to deal with the pending packets */
1082 tasklet_schedule(&priv->irq_tx_tasklet);
1086 static void rtl8192_stop_beacon(struct net_device *dev)
1090 static void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1092 struct r8192_priv *priv = ieee80211_priv(dev);
1093 struct ieee80211_network *net;
1094 u8 i=0, basic_rate = 0;
1095 net = & priv->ieee80211->current_network;
1097 for (i=0; i<net->rates_len; i++)
1099 basic_rate = net->rates[i]&0x7f;
1102 case MGN_1M: *rate_config |= RRSR_1M; break;
1103 case MGN_2M: *rate_config |= RRSR_2M; break;
1104 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1105 case MGN_11M: *rate_config |= RRSR_11M; break;
1106 case MGN_6M: *rate_config |= RRSR_6M; break;
1107 case MGN_9M: *rate_config |= RRSR_9M; break;
1108 case MGN_12M: *rate_config |= RRSR_12M; break;
1109 case MGN_18M: *rate_config |= RRSR_18M; break;
1110 case MGN_24M: *rate_config |= RRSR_24M; break;
1111 case MGN_36M: *rate_config |= RRSR_36M; break;
1112 case MGN_48M: *rate_config |= RRSR_48M; break;
1113 case MGN_54M: *rate_config |= RRSR_54M; break;
1116 for (i=0; i<net->rates_ex_len; i++)
1118 basic_rate = net->rates_ex[i]&0x7f;
1121 case MGN_1M: *rate_config |= RRSR_1M; break;
1122 case MGN_2M: *rate_config |= RRSR_2M; break;
1123 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1124 case MGN_11M: *rate_config |= RRSR_11M; break;
1125 case MGN_6M: *rate_config |= RRSR_6M; break;
1126 case MGN_9M: *rate_config |= RRSR_9M; break;
1127 case MGN_12M: *rate_config |= RRSR_12M; break;
1128 case MGN_18M: *rate_config |= RRSR_18M; break;
1129 case MGN_24M: *rate_config |= RRSR_24M; break;
1130 case MGN_36M: *rate_config |= RRSR_36M; break;
1131 case MGN_48M: *rate_config |= RRSR_48M; break;
1132 case MGN_54M: *rate_config |= RRSR_54M; break;
1138 #define SHORT_SLOT_TIME 9
1139 #define NON_SHORT_SLOT_TIME 20
1141 static void rtl8192_update_cap(struct net_device* dev, u16 cap)
1144 struct r8192_priv *priv = ieee80211_priv(dev);
1145 struct ieee80211_network *net = &priv->ieee80211->current_network;
1146 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1147 tmp = priv->basic_rate;
1148 if (priv->short_preamble)
1149 tmp |= BRSR_AckShortPmb;
1150 write_nic_dword(dev, RRSR, tmp);
1152 if (net->mode & (IEEE_G|IEEE_N_24G))
1155 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1157 slot_time = SHORT_SLOT_TIME;
1159 else //long slot time
1160 slot_time = NON_SHORT_SLOT_TIME;
1161 priv->slot_time = slot_time;
1162 write_nic_byte(dev, SLOT_TIME, slot_time);
1167 static void rtl8192_net_update(struct net_device *dev)
1169 struct r8192_priv *priv = ieee80211_priv(dev);
1170 struct ieee80211_network *net;
1171 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1172 u16 rate_config = 0;
1173 net = &priv->ieee80211->current_network;
1175 /* update Basic rate: RR, BRSR */
1176 rtl8192_config_rate(dev, &rate_config);
1179 * Select RRSR (in Legacy-OFDM and CCK)
1180 * For 8190, we select only 24M, 12M, 6M, 11M, 5.5M,
1181 * 2M, and 1M from the Basic rate.
1182 * We do not use other rates.
1184 priv->basic_rate = rate_config &= 0x15f;
1187 write_nic_dword(dev, BSSIDR, ((u32 *)net->bssid)[0]);
1188 write_nic_word(dev, BSSIDR+4, ((u16 *)net->bssid)[2]);
1190 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1192 write_nic_word(dev, ATIMWND, 2);
1193 write_nic_word(dev, BCN_DMATIME, 256);
1194 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1196 * BIT15 of BCN_DRV_EARLY_INT will indicate
1197 * whether software beacon or hw beacon is applied.
1199 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
1200 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1202 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1203 /* TODO: BcnIFS may required to be changed on ASIC */
1204 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1205 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1209 void rtl819xE_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1211 struct r8192_priv *priv = ieee80211_priv(dev);
1212 struct rtl8192_tx_ring *ring;
1213 tx_desc_819x_pci *entry;
1217 unsigned long flags;
1219 ring = &priv->tx_ring[TXCMD_QUEUE];
1220 mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1222 spin_lock_irqsave(&priv->irq_th_lock,flags);
1223 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1224 entry = &ring->desc[idx];
1226 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1228 entry->LINIP = tcb_desc->bLastIniPkt;
1229 entry->FirstSeg = 1;//first segment
1230 entry->LastSeg = 1; //last segment
1231 if(tcb_desc->bCmdOrInit == DESC_PACKET_TYPE_INIT) {
1232 entry->CmdInit = DESC_PACKET_TYPE_INIT;
1234 entry->CmdInit = DESC_PACKET_TYPE_NORMAL;
1235 entry->Offset = sizeof(TX_FWINFO_8190PCI) + 8;
1236 entry->PktSize = (u16)(tcb_desc->pkt_size + entry->Offset);
1237 entry->QueueSelect = QSLT_CMD;
1238 entry->TxFWInfoSize = 0x08;
1239 entry->RATid = (u8)DESC_PACKET_TYPE_INIT;
1241 entry->TxBufferSize = skb->len;
1242 entry->TxBuffAddr = cpu_to_le32(mapping);
1245 #ifdef JOHN_DUMP_TXDESC
1247 tx_desc_819x_pci *entry1 = &ring->desc[0];
1248 unsigned int *ptr= (unsigned int *)entry1;
1249 printk("<Tx descriptor>:\n");
1250 for (i = 0; i < 8; i++)
1251 printk("%8x ", ptr[i]);
1255 __skb_queue_tail(&ring->queue, skb);
1256 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1258 write_nic_byte(dev, TPPoll, TPPoll_CQ);
1264 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1265 * in TxFwInfo data structure
1267 static u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1273 QueueSelect = QSLT_BE;
1277 QueueSelect = QSLT_BK;
1281 QueueSelect = QSLT_VO;
1285 QueueSelect = QSLT_VI;
1289 QueueSelect = QSLT_MGNT;
1293 QueueSelect = QSLT_BEACON;
1297 QueueSelect = QSLT_CMD;
1302 RT_TRACE(COMP_ERR, "Impossible Queue Selection: %d\n", QueueID);
1308 static u8 MRateToHwRate8190Pci(u8 rate)
1310 u8 ret = DESC90_RATE1M;
1313 case MGN_1M: ret = DESC90_RATE1M; break;
1314 case MGN_2M: ret = DESC90_RATE2M; break;
1315 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
1316 case MGN_11M: ret = DESC90_RATE11M; break;
1317 case MGN_6M: ret = DESC90_RATE6M; break;
1318 case MGN_9M: ret = DESC90_RATE9M; break;
1319 case MGN_12M: ret = DESC90_RATE12M; break;
1320 case MGN_18M: ret = DESC90_RATE18M; break;
1321 case MGN_24M: ret = DESC90_RATE24M; break;
1322 case MGN_36M: ret = DESC90_RATE36M; break;
1323 case MGN_48M: ret = DESC90_RATE48M; break;
1324 case MGN_54M: ret = DESC90_RATE54M; break;
1326 // HT rate since here
1327 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
1328 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
1329 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
1330 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
1331 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
1332 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
1333 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
1334 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
1335 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
1336 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
1337 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1338 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1339 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1340 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1341 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1342 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1343 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1351 static u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1355 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1357 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1364 * The tx procedure is just as following,
1365 * skb->cb will contain all the following information,
1366 * priority, morefrag, rate, &dev.
1368 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
1370 struct r8192_priv *priv = ieee80211_priv(dev);
1371 struct rtl8192_tx_ring *ring;
1372 unsigned long flags;
1373 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1374 tx_desc_819x_pci *pdesc = NULL;
1375 TX_FWINFO_8190PCI *pTxFwInfo = NULL;
1377 bool multi_addr = false, broad_addr = false, uni_addr = false;
1378 u8 *pda_addr = NULL;
1381 if (priv->bdisable_nic) {
1382 RT_TRACE(COMP_ERR, "Nic is disabled! Can't tx packet len=%d qidx=%d!!!\n",
1383 skb->len, tcb_desc->queue_index);
1388 priv->ieee80211->bAwakePktSent = true;
1391 mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1393 /* collect the tx packets statitcs */
1394 pda_addr = ((u8 *)skb->data) + sizeof(TX_FWINFO_8190PCI);
1395 if (is_multicast_ether_addr(pda_addr))
1397 else if (is_broadcast_ether_addr(pda_addr))
1403 priv->stats.txbytesunicast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1404 else if (multi_addr)
1405 priv->stats.txbytesmulticast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1407 priv->stats.txbytesbroadcast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1409 /* fill tx firmware */
1410 pTxFwInfo = (PTX_FWINFO_8190PCI)skb->data;
1411 memset(pTxFwInfo, 0, sizeof(TX_FWINFO_8190PCI));
1412 pTxFwInfo->TxHT = (tcb_desc->data_rate&0x80) ? 1 : 0;
1413 pTxFwInfo->TxRate = MRateToHwRate8190Pci((u8)tcb_desc->data_rate);
1414 pTxFwInfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1415 pTxFwInfo->Short = QueryIsShort(pTxFwInfo->TxHT, pTxFwInfo->TxRate, tcb_desc);
1417 /* Aggregation related */
1418 if (tcb_desc->bAMPDUEnable) {
1419 pTxFwInfo->AllowAggregation = 1;
1420 pTxFwInfo->RxMF = tcb_desc->ampdu_factor;
1421 pTxFwInfo->RxAMD = tcb_desc->ampdu_density;
1423 pTxFwInfo->AllowAggregation = 0;
1424 pTxFwInfo->RxMF = 0;
1425 pTxFwInfo->RxAMD = 0;
1428 /* Protection mode related */
1429 pTxFwInfo->RtsEnable = (tcb_desc->bRTSEnable) ? 1 : 0;
1430 pTxFwInfo->CtsEnable = (tcb_desc->bCTSEnable) ? 1 : 0;
1431 pTxFwInfo->RtsSTBC = (tcb_desc->bRTSSTBC) ? 1 : 0;
1432 pTxFwInfo->RtsHT = (tcb_desc->rts_rate&0x80) ? 1 : 0;
1433 pTxFwInfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1434 pTxFwInfo->RtsBandwidth = 0;
1435 pTxFwInfo->RtsSubcarrier = tcb_desc->RTSSC;
1436 pTxFwInfo->RtsShort = (pTxFwInfo->RtsHT == 0) ? (tcb_desc->bRTSUseShortPreamble ? 1 : 0) : (tcb_desc->bRTSUseShortGI? 1 : 0);
1438 /* Set Bandwidth and sub-channel settings. */
1439 if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40) {
1440 if (tcb_desc->bPacketBW) {
1441 pTxFwInfo->TxBandwidth = 1;
1443 pTxFwInfo->TxSubCarrier = 3;
1445 /* use duplicated mode */
1446 pTxFwInfo->TxSubCarrier = 0;
1449 pTxFwInfo->TxBandwidth = 0;
1450 pTxFwInfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1453 pTxFwInfo->TxBandwidth = 0;
1454 pTxFwInfo->TxSubCarrier = 0;
1457 spin_lock_irqsave(&priv->irq_th_lock, flags);
1458 ring = &priv->tx_ring[tcb_desc->queue_index];
1459 if (tcb_desc->queue_index != BEACON_QUEUE)
1460 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1464 pdesc = &ring->desc[idx];
1465 if ((pdesc->OWN == 1) && (tcb_desc->queue_index != BEACON_QUEUE)) {
1466 RT_TRACE(COMP_ERR, "No more TX desc@%d, ring->idx = %d,idx = %d,%x",
1467 tcb_desc->queue_index, ring->idx, idx, skb->len);
1468 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1472 /* fill tx descriptor */
1473 memset(pdesc, 0, 12);
1478 pdesc->Offset = sizeof(TX_FWINFO_8190PCI) + 8; /* We must add 8!! */
1479 pdesc->PktSize = (u16)skb->len-sizeof(TX_FWINFO_8190PCI);
1482 pdesc->SecCAMID = 0;
1483 pdesc->RATid = tcb_desc->RATRIndex;
1486 pdesc->SecType = 0x0;
1487 if (tcb_desc->bHwSec) {
1488 switch (priv->ieee80211->pairwise_key_type) {
1489 case KEY_TYPE_WEP40:
1490 case KEY_TYPE_WEP104:
1491 pdesc->SecType = 0x1;
1495 pdesc->SecType = 0x2;
1499 pdesc->SecType = 0x3;
1503 pdesc->SecType = 0x0;
1512 pdesc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1513 pdesc->TxFWInfoSize = sizeof(TX_FWINFO_8190PCI);
1515 pdesc->DISFB = tcb_desc->bTxDisableRateFallBack;
1516 pdesc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1518 pdesc->FirstSeg = 1;
1520 pdesc->TxBufferSize = skb->len;
1522 pdesc->TxBuffAddr = cpu_to_le32(mapping);
1523 __skb_queue_tail(&ring->queue, skb);
1525 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1526 dev->trans_start = jiffies;
1527 write_nic_word(dev, TPPoll, 0x01<<tcb_desc->queue_index);
1531 static short rtl8192_alloc_rx_desc_ring(struct net_device *dev)
1533 struct r8192_priv *priv = ieee80211_priv(dev);
1534 rx_desc_819x_pci *entry = NULL;
1537 priv->rx_ring = pci_alloc_consistent(priv->pdev,
1538 sizeof(*priv->rx_ring) * priv->rxringcount, &priv->rx_ring_dma);
1540 if (!priv->rx_ring || (unsigned long)priv->rx_ring & 0xFF) {
1541 RT_TRACE(COMP_ERR,"Cannot allocate RX ring\n");
1545 memset(priv->rx_ring, 0, sizeof(*priv->rx_ring) * priv->rxringcount);
1548 for (i = 0; i < priv->rxringcount; i++) {
1549 struct sk_buff *skb = dev_alloc_skb(priv->rxbuffersize);
1550 dma_addr_t *mapping;
1551 entry = &priv->rx_ring[i];
1554 priv->rx_buf[i] = skb;
1555 mapping = (dma_addr_t *)skb->cb;
1556 *mapping = pci_map_single(priv->pdev, skb_tail_pointer(skb),
1557 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
1559 entry->BufferAddress = cpu_to_le32(*mapping);
1561 entry->Length = priv->rxbuffersize;
1569 static int rtl8192_alloc_tx_desc_ring(struct net_device *dev,
1570 unsigned int prio, unsigned int entries)
1572 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1573 tx_desc_819x_pci *ring;
1577 ring = pci_alloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma);
1578 if (!ring || (unsigned long)ring & 0xFF) {
1579 RT_TRACE(COMP_ERR, "Cannot allocate TX ring (prio = %d)\n", prio);
1583 memset(ring, 0, sizeof(*ring)*entries);
1584 priv->tx_ring[prio].desc = ring;
1585 priv->tx_ring[prio].dma = dma;
1586 priv->tx_ring[prio].idx = 0;
1587 priv->tx_ring[prio].entries = entries;
1588 skb_queue_head_init(&priv->tx_ring[prio].queue);
1590 for (i = 0; i < entries; i++)
1591 ring[i].NextDescAddress =
1592 cpu_to_le32((u32)dma + ((i + 1) % entries) * sizeof(*ring));
1597 static short rtl8192_pci_initdescring(struct net_device *dev)
1601 struct r8192_priv *priv = ieee80211_priv(dev);
1603 ret = rtl8192_alloc_rx_desc_ring(dev);
1607 /* general process for other queue */
1608 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1609 ret = rtl8192_alloc_tx_desc_ring(dev, i, priv->txringcount);
1611 goto err_free_rings;
1617 rtl8192_free_rx_ring(dev);
1618 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
1619 if (priv->tx_ring[i].desc)
1620 rtl8192_free_tx_ring(dev, i);
1624 static void rtl8192_pci_resetdescring(struct net_device *dev)
1626 struct r8192_priv *priv = ieee80211_priv(dev);
1629 /* force the rx_idx to the first one */
1631 rx_desc_819x_pci *entry = NULL;
1632 for (i = 0; i < priv->rxringcount; i++) {
1633 entry = &priv->rx_ring[i];
1639 /* after reset, release previous pending packet, and force the
1640 * tx idx to the first one */
1641 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1642 if (priv->tx_ring[i].desc) {
1643 struct rtl8192_tx_ring *ring = &priv->tx_ring[i];
1645 while (skb_queue_len(&ring->queue)) {
1646 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1647 struct sk_buff *skb = __skb_dequeue(&ring->queue);
1649 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1650 skb->len, PCI_DMA_TODEVICE);
1652 ring->idx = (ring->idx + 1) % ring->entries;
1659 static void rtl8192_link_change(struct net_device *dev)
1661 struct r8192_priv *priv = ieee80211_priv(dev);
1662 struct ieee80211_device* ieee = priv->ieee80211;
1663 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
1664 if (ieee->state == IEEE80211_LINKED)
1666 rtl8192_net_update(dev);
1667 rtl8192_update_ratr_table(dev);
1669 //add this as in pure N mode, wep encryption will use software way, but there is no chance to set this as wep will not set group key in wext. WB.2008.07.08
1670 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
1671 EnableHWSecurityConfig8192(dev);
1676 write_nic_byte(dev, 0x173, 0);
1678 /*update timing params*/
1679 //rtl8192_set_chan(dev, priv->chan);
1681 rtl8192_update_msr(dev);
1683 // 2007/10/16 MH MAC Will update TSF according to all received beacon, so we have
1684 // // To set CBSSID bit when link with any AP or STA.
1685 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
1688 reg = read_nic_dword(dev, RCR);
1689 if (priv->ieee80211->state == IEEE80211_LINKED)
1690 priv->ReceiveConfig = reg |= RCR_CBSSID;
1692 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
1693 write_nic_dword(dev, RCR, reg);
1698 static const struct ieee80211_qos_parameters def_qos_parameters = {
1699 {3,3,3,3},/* cw_min */
1700 {7,7,7,7},/* cw_max */
1701 {2,2,2,2},/* aifs */
1702 {0,0,0,0},/* flags */
1703 {0,0,0,0} /* tx_op_limit */
1706 static void rtl8192_update_beacon(struct work_struct * work)
1708 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
1709 struct net_device *dev = priv->ieee80211->dev;
1710 struct ieee80211_device* ieee = priv->ieee80211;
1711 struct ieee80211_network* net = &ieee->current_network;
1713 if (ieee->pHTInfo->bCurrentHTSupport)
1714 HTUpdateSelfAndPeerSetting(ieee, net);
1715 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
1716 rtl8192_update_cap(dev, net->capability);
1720 * background support to run QoS activate functionality
1722 static const int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
1723 static void rtl8192_qos_activate(struct work_struct * work)
1725 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
1726 struct net_device *dev = priv->ieee80211->dev;
1727 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
1728 u8 mode = priv->ieee80211->current_network.mode;
1733 mutex_lock(&priv->mutex);
1734 if(priv->ieee80211->state != IEEE80211_LINKED)
1736 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
1737 /* It better set slot time at first */
1738 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
1739 /* update the ac parameter to related registers */
1740 for(i = 0; i < QOS_QUEUE_NUM; i++) {
1741 //Mode G/A: slotTimeTimer = 9; Mode B: 20
1742 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
1743 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
1744 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
1745 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
1746 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
1747 //printk("===>u4bAcParam:%x, ", u4bAcParam);
1748 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
1749 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
1753 mutex_unlock(&priv->mutex);
1756 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
1758 struct ieee80211_network *network)
1761 u32 size = sizeof(struct ieee80211_qos_parameters);
1763 if(priv->ieee80211->state !=IEEE80211_LINKED)
1766 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1769 if (network->flags & NETWORK_HAS_QOS_MASK) {
1770 if (active_network &&
1771 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
1772 network->qos_data.active = network->qos_data.supported;
1774 if ((network->qos_data.active == 1) && (active_network == 1) &&
1775 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
1776 (network->qos_data.old_param_count !=
1777 network->qos_data.param_count)) {
1778 network->qos_data.old_param_count =
1779 network->qos_data.param_count;
1780 queue_work(priv->priv_wq, &priv->qos_activate);
1781 RT_TRACE (COMP_QOS, "QoS parameters change call "
1785 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1786 &def_qos_parameters, size);
1788 if ((network->qos_data.active == 1) && (active_network == 1)) {
1789 queue_work(priv->priv_wq, &priv->qos_activate);
1790 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
1792 network->qos_data.active = 0;
1793 network->qos_data.supported = 0;
1799 /* handle manage frame frame beacon and probe response */
1800 static int rtl8192_handle_beacon(struct net_device * dev,
1801 struct ieee80211_beacon * beacon,
1802 struct ieee80211_network * network)
1804 struct r8192_priv *priv = ieee80211_priv(dev);
1806 rtl8192_qos_handle_probe_response(priv,1,network);
1808 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
1814 * handling the beaconing responses. if we get different QoS setting
1815 * off the network from the associated setting, adjust the QoS setting
1817 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
1818 struct ieee80211_network *network)
1821 unsigned long flags;
1822 u32 size = sizeof(struct ieee80211_qos_parameters);
1823 int set_qos_param = 0;
1825 if ((priv == NULL) || (network == NULL))
1828 if (priv->ieee80211->state != IEEE80211_LINKED)
1831 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1834 spin_lock_irqsave(&priv->ieee80211->lock, flags);
1835 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
1836 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1837 &network->qos_data.parameters,
1838 sizeof(struct ieee80211_qos_parameters));
1839 priv->ieee80211->current_network.qos_data.active = 1;
1841 /* update qos parameter for current network */
1842 priv->ieee80211->current_network.qos_data.old_param_count =
1843 priv->ieee80211->current_network.qos_data.param_count;
1844 priv->ieee80211->current_network.qos_data.param_count =
1845 network->qos_data.param_count;
1848 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1849 &def_qos_parameters, size);
1850 priv->ieee80211->current_network.qos_data.active = 0;
1851 priv->ieee80211->current_network.qos_data.supported = 0;
1855 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
1857 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n", __FUNCTION__,
1858 network->flags, priv->ieee80211->current_network.qos_data.active);
1859 if (set_qos_param == 1)
1860 queue_work(priv->priv_wq, &priv->qos_activate);
1866 static int rtl8192_handle_assoc_response(struct net_device *dev,
1867 struct ieee80211_assoc_response_frame *resp,
1868 struct ieee80211_network *network)
1870 struct r8192_priv *priv = ieee80211_priv(dev);
1871 rtl8192_qos_association_resp(priv, network);
1876 /* updateRATRTabel for MCS only. Basic rate is not implemented. */
1877 static void rtl8192_update_ratr_table(struct net_device* dev)
1879 struct r8192_priv* priv = ieee80211_priv(dev);
1880 struct ieee80211_device* ieee = priv->ieee80211;
1881 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
1885 rtl8192_config_rate(dev, (u16*)(&ratr_value));
1886 ratr_value |= (*(u16*)(pMcsRate)) << 12;
1891 ratr_value &= 0x00000FF0;
1894 ratr_value &= 0x0000000F;
1897 ratr_value &= 0x00000FF7;
1901 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
1902 ratr_value &= 0x0007F007;
1904 if (priv->rf_type == RF_1T2R)
1905 ratr_value &= 0x000FF007;
1907 ratr_value &= 0x0F81F007;
1913 ratr_value &= 0x0FFFFFFF;
1914 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
1915 ratr_value |= 0x80000000;
1916 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
1917 ratr_value |= 0x80000000;
1919 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
1920 write_nic_byte(dev, UFWP, 1);
1923 static bool GetNmodeSupportBySecCfg8190Pci(struct net_device*dev)
1925 struct r8192_priv *priv = ieee80211_priv(dev);
1926 struct ieee80211_device *ieee = priv->ieee80211;
1928 return !(ieee->rtllib_ap_sec_type &&
1929 (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP)));
1932 static void rtl8192_refresh_supportrate(struct r8192_priv* priv)
1934 struct ieee80211_device* ieee = priv->ieee80211;
1935 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
1936 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
1938 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
1939 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
1940 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
1943 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
1946 static u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
1948 struct r8192_priv *priv = ieee80211_priv(dev);
1950 switch(priv->rf_chip)
1955 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
1958 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
1961 ret = WIRELESS_MODE_B;
1967 static void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
1969 struct r8192_priv *priv = ieee80211_priv(dev);
1970 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
1973 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
1975 if(bSupportMode & WIRELESS_MODE_N_24G)
1977 wireless_mode = WIRELESS_MODE_N_24G;
1979 else if(bSupportMode & WIRELESS_MODE_N_5G)
1981 wireless_mode = WIRELESS_MODE_N_5G;
1983 else if((bSupportMode & WIRELESS_MODE_A))
1985 wireless_mode = WIRELESS_MODE_A;
1987 else if((bSupportMode & WIRELESS_MODE_G))
1989 wireless_mode = WIRELESS_MODE_G;
1991 else if((bSupportMode & WIRELESS_MODE_B))
1993 wireless_mode = WIRELESS_MODE_B;
1996 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
1997 wireless_mode = WIRELESS_MODE_B;
2000 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2001 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2003 priv->ieee80211->mode = wireless_mode;
2005 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2006 priv->ieee80211->pHTInfo->bEnableHT = 1;
2008 priv->ieee80211->pHTInfo->bEnableHT = 0;
2009 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2010 rtl8192_refresh_supportrate(priv);
2015 static bool GetHalfNmodeSupportByAPs819xPci(struct net_device* dev)
2017 struct r8192_priv* priv = ieee80211_priv(dev);
2018 struct ieee80211_device* ieee = priv->ieee80211;
2020 return ieee->bHalfWirelessN24GMode;
2023 short rtl8192_is_tx_queue_empty(struct net_device *dev)
2026 struct r8192_priv *priv = ieee80211_priv(dev);
2027 for (i=0; i<=MGNT_QUEUE; i++)
2029 if ((i== TXCMD_QUEUE) || (i == HCCA_QUEUE) )
2031 if (skb_queue_len(&(&priv->tx_ring[i])->queue) > 0){
2032 printk("===>tx queue is not empty:%d, %d\n", i, skb_queue_len(&(&priv->tx_ring[i])->queue));
2039 static void rtl8192_hw_sleep_down(struct net_device *dev)
2041 struct r8192_priv *priv = ieee80211_priv(dev);
2042 unsigned long flags = 0;
2044 spin_lock_irqsave(&priv->rf_ps_lock,flags);
2045 if (priv->RFChangeInProgress) {
2046 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2047 RT_TRACE(COMP_RF, "rtl8192_hw_sleep_down(): RF Change in progress! \n");
2048 printk("rtl8192_hw_sleep_down(): RF Change in progress!\n");
2051 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2053 MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
2056 static void rtl8192_hw_sleep_wq (struct work_struct *work)
2058 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2059 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
2060 struct net_device *dev = ieee->dev;
2062 rtl8192_hw_sleep_down(dev);
2065 static void rtl8192_hw_wakeup(struct net_device* dev)
2067 struct r8192_priv *priv = ieee80211_priv(dev);
2068 unsigned long flags = 0;
2070 spin_lock_irqsave(&priv->rf_ps_lock,flags);
2071 if (priv->RFChangeInProgress) {
2072 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2073 RT_TRACE(COMP_RF, "rtl8192_hw_wakeup(): RF Change in progress! \n");
2074 printk("rtl8192_hw_wakeup(): RF Change in progress! schedule wake up task again\n");
2075 queue_delayed_work(priv->ieee80211->wq,&priv->ieee80211->hw_wakeup_wq,MSECS(10));//PowerSave is not supported if kernel version is below 2.6.20
2078 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2080 MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS);
2083 void rtl8192_hw_wakeup_wq (struct work_struct *work)
2085 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2086 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
2087 struct net_device *dev = ieee->dev;
2088 rtl8192_hw_wakeup(dev);
2092 #define MIN_SLEEP_TIME 50
2093 #define MAX_SLEEP_TIME 10000
2094 static void rtl8192_hw_to_sleep(struct net_device *dev, u32 th, u32 tl)
2096 struct r8192_priv *priv = ieee80211_priv(dev);
2099 unsigned long flags;
2101 spin_lock_irqsave(&priv->ps_lock,flags);
2103 // Writing HW register with 0 equals to disable
2104 // the timer, that is not really what we want
2106 tl -= MSECS(8+16+7);
2108 // If the interval in witch we are requested to sleep is too
2109 // short then give up and remain awake
2110 // when we sleep after send null frame, the timer will be too short to sleep.
2112 if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
2113 ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
2114 spin_unlock_irqrestore(&priv->ps_lock,flags);
2115 printk("too short to sleep::%x, %x, %lx\n",tl, rb, MSECS(MIN_SLEEP_TIME));
2119 if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
2120 ((tl < rb) && (tl>MSECS(69)) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))||
2121 ((tl<rb)&&(tl<MSECS(69))&&((tl+0xffffffff-rb)>MSECS(MAX_SLEEP_TIME)))) {
2122 printk("========>too long to sleep:%x, %x, %lx\n", tl, rb, MSECS(MAX_SLEEP_TIME));
2123 spin_unlock_irqrestore(&priv->ps_lock,flags);
2127 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
2128 queue_delayed_work(priv->ieee80211->wq,
2129 &priv->ieee80211->hw_wakeup_wq,tmp);
2130 //PowerSave not supported when kernel version less 2.6.20
2132 queue_delayed_work(priv->ieee80211->wq,
2133 (void *)&priv->ieee80211->hw_sleep_wq,0);
2134 spin_unlock_irqrestore(&priv->ps_lock,flags);
2138 static void rtl8192_init_priv_variable(struct net_device* dev)
2140 struct r8192_priv *priv = ieee80211_priv(dev);
2142 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
2144 // Default Halt the NIC if RF is OFF.
2145 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_HALT_NIC;
2146 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_CLK_REQ;
2147 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_ASPM;
2148 pPSC->RegRfPsLevel |= RT_RF_LPS_LEVEL_ASPM;
2149 pPSC->bLeisurePs = true;
2150 pPSC->RegMaxLPSAwakeIntvl = 5;
2151 priv->bHwRadioOff = false;
2153 priv->being_init_adapter = false;
2154 priv->txbuffsize = 1600;//1024;
2155 priv->txfwbuffersize = 4096;
2156 priv->txringcount = 64;//32;
2157 //priv->txbeaconcount = priv->txringcount;
2158 priv->txbeaconcount = 2;
2159 priv->rxbuffersize = 9100;//2048;//1024;
2160 priv->rxringcount = MAX_RX_COUNT;//64;
2161 priv->irq_enabled=0;
2162 priv->card_8192 = NIC_8192E;
2163 priv->rx_skb_complete = 1;
2164 priv->chan = 1; //set to channel 1
2165 priv->RegWirelessMode = WIRELESS_MODE_AUTO;
2166 priv->RegChannelPlan = 0xf;
2167 priv->nrxAMPDU_size = 0;
2168 priv->nrxAMPDU_aggr_num = 0;
2169 priv->last_rxdesc_tsf_high = 0;
2170 priv->last_rxdesc_tsf_low = 0;
2171 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2172 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2173 priv->ieee80211->ieee_up=0;
2174 priv->retry_rts = DEFAULT_RETRY_RTS;
2175 priv->retry_data = DEFAULT_RETRY_DATA;
2176 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2177 priv->ieee80211->rate = 110; //11 mbps
2178 priv->ieee80211->short_slot = 1;
2179 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2180 priv->bcck_in_ch14 = false;
2181 priv->bfsync_processing = false;
2182 priv->CCKPresentAttentuation = 0;
2183 priv->rfa_txpowertrackingindex = 0;
2184 priv->rfc_txpowertrackingindex = 0;
2186 priv->ScanDelay = 50;//for Scan TODO
2187 //added by amy for silent reset
2188 priv->ResetProgress = RESET_TYPE_NORESET;
2189 priv->bForcedSilentReset = 0;
2190 priv->bDisableNormalResetCheck = false;
2191 priv->force_reset = false;
2192 //added by amy for power save
2194 priv->ieee80211->RfOffReason = 0;
2195 priv->RFChangeInProgress = false;
2196 priv->bHwRfOffAction = 0;
2197 priv->SetRFPowerStateInProgress = false;
2198 priv->ieee80211->PowerSaveControl.bInactivePs = true;
2199 priv->ieee80211->PowerSaveControl.bIPSModeBackup = false;
2201 priv->txpower_checkcnt = 0;
2202 priv->thermal_readback_index =0;
2203 priv->txpower_tracking_callback_cnt = 0;
2204 priv->ccktxpower_adjustcnt_ch14 = 0;
2205 priv->ccktxpower_adjustcnt_not_ch14 = 0;
2207 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2208 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2209 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2210 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2211 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;/* |
2212 IEEE_SOFTMAC_BEACONS;*///added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2214 priv->ieee80211->active_scan = 1;
2215 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2216 priv->ieee80211->host_encrypt = 1;
2217 priv->ieee80211->host_decrypt = 1;
2218 //priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2219 //priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2220 priv->ieee80211->start_send_beacons = rtl8192_start_beacon;//+by david 081107
2221 priv->ieee80211->stop_send_beacons = rtl8192_stop_beacon;//+by david 081107
2222 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2223 priv->ieee80211->set_chan = rtl8192_set_chan;
2224 priv->ieee80211->link_change = rtl8192_link_change;
2225 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2226 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2227 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2228 priv->ieee80211->init_wmmparam_flag = 0;
2229 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2230 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2231 priv->ieee80211->tx_headroom = sizeof(TX_FWINFO_8190PCI);
2232 priv->ieee80211->qos_support = 1;
2233 priv->ieee80211->dot11PowerSaveMode = 0;
2235 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2236 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2237 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2238 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2240 priv->ieee80211->sta_wake_up = rtl8192_hw_wakeup;
2241 // priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
2242 priv->ieee80211->enter_sleep_state = rtl8192_hw_to_sleep;
2243 priv->ieee80211->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
2245 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8190Pci;
2246 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2247 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xPci;
2250 priv->ieee80211->InitialGainHandler = InitialGain819xPci;
2253 priv->ieee80211->ieee80211_ips_leave_wq = ieee80211_ips_leave_wq;
2254 priv->ieee80211->ieee80211_ips_leave = ieee80211_ips_leave;
2257 priv->ieee80211->LeisurePSLeave = LeisurePSLeave;
2260 priv->ieee80211->SetHwRegHandler = rtl8192e_SetHwReg;
2261 priv->ieee80211->rtllib_ap_sec_type = rtl8192e_ap_sec_type;
2263 priv->card_type = USB;
2265 priv->ShortRetryLimit = 0x30;
2266 priv->LongRetryLimit = 0x30;
2268 priv->EarlyRxThreshold = 7;
2269 priv->enable_gpio0 = 0;
2271 priv->TransmitConfig = 0;
2273 priv->ReceiveConfig = RCR_ADD3 |
2274 RCR_AMF | RCR_ADF | //accept management/data
2275 RCR_AICV | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2276 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2277 RCR_AAP | ((u32)7<<RCR_MXDMA_OFFSET) |
2278 ((u32)7 << RCR_FIFO_OFFSET) | RCR_ONLYERLPKT;
2280 priv->irq_mask = (u32)(IMR_ROK | IMR_VODOK | IMR_VIDOK | IMR_BEDOK | IMR_BKDOK |
2281 IMR_HCCADOK | IMR_MGNTDOK | IMR_COMDOK | IMR_HIGHDOK |
2282 IMR_BDOK | IMR_RXCMDOK | IMR_TIMEOUT0 | IMR_RDU | IMR_RXFOVW |
2283 IMR_TXFOVW | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
2285 priv->AcmControl = 0;
2286 priv->pFirmware = vzalloc(sizeof(rt_firmware));
2288 /* rx related queue */
2289 skb_queue_head_init(&priv->rx_queue);
2290 skb_queue_head_init(&priv->skb_queue);
2292 /* Tx related queue */
2293 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2294 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2296 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2297 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2299 priv->rf_set_chan = rtl8192_phy_SwChnl;
2302 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2304 spin_lock_init(&priv->tx_lock);
2305 spin_lock_init(&priv->irq_lock);//added by thomas
2306 spin_lock_init(&priv->irq_th_lock);
2307 spin_lock_init(&priv->rf_ps_lock);
2308 spin_lock_init(&priv->ps_lock);
2309 //spin_lock_init(&priv->rf_lock);
2310 sema_init(&priv->wx_sem,1);
2311 sema_init(&priv->rf_sem,1);
2312 mutex_init(&priv->mutex);
2315 /* init tasklet and wait_queue here */
2316 #define DRV_NAME "wlan0"
2317 static void rtl8192_init_priv_task(struct net_device* dev)
2319 struct r8192_priv *priv = ieee80211_priv(dev);
2321 #ifdef PF_SYNCTHREAD
2322 priv->priv_wq = create_workqueue(DRV_NAME,0);
2324 priv->priv_wq = create_workqueue(DRV_NAME);
2328 INIT_WORK(&priv->ieee80211->ips_leave_wq, (void*)IPSLeave_wq);
2331 // INIT_WORK(&priv->reset_wq, (void(*)(void*)) rtl8192_restart);
2332 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2333 // INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2334 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2335 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2336 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2337 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2338 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2339 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2340 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2341 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq);
2342 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq);
2344 tasklet_init(&priv->irq_rx_tasklet,
2345 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2346 (unsigned long)priv);
2347 tasklet_init(&priv->irq_tx_tasklet,
2348 (void(*)(unsigned long))rtl8192_irq_tx_tasklet,
2349 (unsigned long)priv);
2350 tasklet_init(&priv->irq_prepare_beacon_tasklet,
2351 (void(*)(unsigned long))rtl8192_prepare_beacon,
2352 (unsigned long)priv);
2355 static void rtl8192_get_eeprom_size(struct net_device* dev)
2358 struct r8192_priv *priv = ieee80211_priv(dev);
2359 RT_TRACE(COMP_INIT, "===========>%s()\n", __FUNCTION__);
2360 curCR = read_nic_dword(dev, EPROM_CMD);
2361 RT_TRACE(COMP_INIT, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD, curCR);
2362 //whether need I consider BIT5?
2363 priv->epromtype = (curCR & EPROM_CMD_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2364 RT_TRACE(COMP_INIT, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2368 * used to swap endian. as ntohl & htonl are not
2369 * neccessary to swap endian, so use this instead.
2371 static inline u16 endian_swap(u16* data)
2374 *data = (tmp >> 8) | (tmp << 8);
2379 * Adapter->EEPROMAddressSize should be set before this function call.
2380 * EEPROM address size can be got through GetEEPROMSize8185()
2382 static void rtl8192_read_eeprom_info(struct net_device* dev)
2384 struct r8192_priv *priv = ieee80211_priv(dev);
2388 u8 ICVer8192, ICVer8256;
2390 u16 i,usValue, IC_Version;
2394 u8 EepromTxPower[100];
2396 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01};
2397 RT_TRACE(COMP_INIT, "====> rtl8192_read_eeprom_info\n");
2400 // TODO: I don't know if we need to apply EF function to EEPROM read function
2402 //2 Read EEPROM ID to make sure autoload is success
2403 EEPROMId = eprom_read(dev, 0);
2404 if( EEPROMId != RTL8190_EEPROM_ID )
2406 RT_TRACE(COMP_ERR, "EEPROM ID is invalid:%x, %x\n", EEPROMId, RTL8190_EEPROM_ID);
2407 priv->AutoloadFailFlag=true;
2411 priv->AutoloadFailFlag=false;
2415 // Assign Chip Version ID
2417 // Read IC Version && Channel Plan
2418 if(!priv->AutoloadFailFlag)
2421 priv->eeprom_vid = eprom_read(dev, (EEPROM_VID >> 1));
2422 priv->eeprom_did = eprom_read(dev, (EEPROM_DID >> 1));
2424 usValue = eprom_read(dev, (u16)(EEPROM_Customer_ID>>1)) >> 8 ;
2425 priv->eeprom_CustomerID = (u8)( usValue & 0xff);
2426 usValue = eprom_read(dev, (EEPROM_ICVersion_ChannelPlan>>1));
2427 priv->eeprom_ChannelPlan = usValue&0xff;
2428 IC_Version = ((usValue&0xff00)>>8);
2431 priv->card_8192_version = (VERSION_8190)(IC_Version);
2434 ICVer8192 = (IC_Version&0xf); //bit0~3; 1:A cut, 2:B cut, 3:C cut...
2435 ICVer8256 = ((IC_Version&0xf0)>>4);//bit4~6, bit7 reserved for other RF chip; 1:A cut, 2:B cut, 3:C cut...
2436 RT_TRACE(COMP_INIT, "\nICVer8192 = 0x%x\n", ICVer8192);
2437 RT_TRACE(COMP_INIT, "\nICVer8256 = 0x%x\n", ICVer8256);
2438 if(ICVer8192 == 0x2) //B-cut
2440 if(ICVer8256 == 0x5) //E-cut
2441 priv->card_8192_version= VERSION_8190_BE;
2445 switch(priv->card_8192_version)
2447 case VERSION_8190_BD:
2448 case VERSION_8190_BE:
2451 priv->card_8192_version = VERSION_8190_BD;
2454 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", priv->card_8192_version);
2458 priv->card_8192_version = VERSION_8190_BD;
2459 priv->eeprom_vid = 0;
2460 priv->eeprom_did = 0;
2461 priv->eeprom_CustomerID = 0;
2462 priv->eeprom_ChannelPlan = 0;
2463 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", 0xff);
2466 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
2467 RT_TRACE(COMP_INIT, "EEPROM DID = 0x%4x\n", priv->eeprom_did);
2468 RT_TRACE(COMP_INIT,"EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
2470 //2 Read Permanent MAC address
2471 if(!priv->AutoloadFailFlag)
2473 for(i = 0; i < 6; i += 2)
2475 usValue = eprom_read(dev, (u16) ((EEPROM_NODE_ADDRESS_BYTE_0+i)>>1));
2476 *(u16*)(&dev->dev_addr[i]) = usValue;
2479 // when auto load failed, the last address byte set to be a random one.
2480 // added by david woo.2007/11/7
2481 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2484 RT_TRACE(COMP_INIT, "Permanent Address = %pM\n", dev->dev_addr);
2486 //2 TX Power Check EEPROM Fail or not
2487 if(priv->card_8192_version > VERSION_8190_BD) {
2488 priv->bTXPowerDataReadFromEEPORM = true;
2490 priv->bTXPowerDataReadFromEEPORM = false;
2493 // 2007/11/15 MH 8190PCI Default=2T4R, 8192PCIE default=1T2R
2494 priv->rf_type = RTL819X_DEFAULT_RF_TYPE;
2496 if(priv->card_8192_version > VERSION_8190_BD)
2498 // Read RF-indication and Tx Power gain index diff of legacy to HT OFDM rate.
2499 if(!priv->AutoloadFailFlag)
2501 tempval = (eprom_read(dev, (EEPROM_RFInd_PowerDiff>>1))) & 0xff;
2502 priv->EEPROMLegacyHTTxPowerDiff = tempval & 0xf; // bit[3:0]
2504 if (tempval&0x80) //RF-indication, bit[7]
2505 priv->rf_type = RF_1T2R;
2507 priv->rf_type = RF_2T4R;
2511 priv->EEPROMLegacyHTTxPowerDiff = EEPROM_Default_LegacyHTTxPowerDiff;
2513 RT_TRACE(COMP_INIT, "EEPROMLegacyHTTxPowerDiff = %d\n",
2514 priv->EEPROMLegacyHTTxPowerDiff);
2516 // Read ThermalMeter from EEPROM
2517 if(!priv->AutoloadFailFlag)
2519 priv->EEPROMThermalMeter = (u8)(((eprom_read(dev, (EEPROM_ThermalMeter>>1))) & 0xff00)>>8);
2523 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2525 RT_TRACE(COMP_INIT, "ThermalMeter = %d\n", priv->EEPROMThermalMeter);
2526 //vivi, for tx power track
2527 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2529 if(priv->epromtype == EPROM_93c46)
2531 // Read antenna tx power offset of B/C/D to A and CrystalCap from EEPROM
2532 if(!priv->AutoloadFailFlag)
2534 usValue = eprom_read(dev, (EEPROM_TxPwDiff_CrystalCap>>1));
2535 priv->EEPROMAntPwDiff = (usValue&0x0fff);
2536 priv->EEPROMCrystalCap = (u8)((usValue&0xf000)>>12);
2540 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2541 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2543 RT_TRACE(COMP_INIT, "EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2544 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2547 // Get per-channel Tx Power Level
2549 for(i=0; i<14; i+=2)
2551 if(!priv->AutoloadFailFlag)
2553 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_CCK+i)>>1) );
2557 usValue = EEPROM_Default_TxPower;
2559 *((u16*)(&priv->EEPROMTxPowerLevelCCK[i])) = usValue;
2560 RT_TRACE(COMP_INIT,"CCK Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK[i]);
2561 RT_TRACE(COMP_INIT, "CCK Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelCCK[i+1]);
2563 for(i=0; i<14; i+=2)
2565 if(!priv->AutoloadFailFlag)
2567 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_OFDM_24G+i)>>1) );
2571 usValue = EEPROM_Default_TxPower;
2573 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[i])) = usValue;
2574 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelOFDM24G[i]);
2575 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelOFDM24G[i+1]);
2578 else if(priv->epromtype== EPROM_93c56)
2581 // Read CrystalCap from EEPROM
2582 if(!priv->AutoloadFailFlag)
2584 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2585 priv->EEPROMCrystalCap = (u8)(((eprom_read(dev, (EEPROM_C56_CrystalCap>>1))) & 0xf000)>>12);
2589 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2590 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2592 RT_TRACE(COMP_INIT,"EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2593 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2595 // Get Tx Power Level by Channel
2596 if(!priv->AutoloadFailFlag)
2598 // Read Tx power of Channel 1 ~ 14 from EEPROM.
2599 for(i = 0; i < 12; i+=2)
2602 offset = EEPROM_C56_RfA_CCK_Chnl1_TxPwIndex + i;
2604 offset = EEPROM_C56_RfC_CCK_Chnl1_TxPwIndex + i - 6;
2605 usValue = eprom_read(dev, (offset>>1));
2606 *((u16*)(&EepromTxPower[i])) = usValue;
2609 for(i = 0; i < 12; i++)
2612 priv->EEPROMRfACCKChnl1TxPwLevel[i] = EepromTxPower[i];
2613 else if ((i >=3 )&&(i <= 5))
2614 priv->EEPROMRfAOfdmChnlTxPwLevel[i-3] = EepromTxPower[i];
2615 else if ((i >=6 )&&(i <= 8))
2616 priv->EEPROMRfCCCKChnl1TxPwLevel[i-6] = EepromTxPower[i];
2618 priv->EEPROMRfCOfdmChnlTxPwLevel[i-9] = EepromTxPower[i];
2623 priv->EEPROMRfACCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2624 priv->EEPROMRfACCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2625 priv->EEPROMRfACCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2627 priv->EEPROMRfAOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2628 priv->EEPROMRfAOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2629 priv->EEPROMRfAOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2631 priv->EEPROMRfCCCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2632 priv->EEPROMRfCCCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2633 priv->EEPROMRfCCCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2635 priv->EEPROMRfCOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2636 priv->EEPROMRfCOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2637 priv->EEPROMRfCOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2639 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[0]);
2640 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[1]);
2641 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[2]);
2642 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[0]);
2643 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[1]);
2644 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[2]);
2645 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[0]);
2646 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[1]);
2647 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[2]);
2648 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[0]);
2649 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[1]);
2650 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[2]);
2655 // Update HAL variables.
2657 if(priv->epromtype == EPROM_93c46)
2661 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK[i];
2662 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[i];
2664 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2665 // Antenna B gain offset to antenna A, bit0~3
2666 priv->AntennaTxPwDiff[0] = (priv->EEPROMAntPwDiff & 0xf);
2667 // Antenna C gain offset to antenna A, bit4~7
2668 priv->AntennaTxPwDiff[1] = ((priv->EEPROMAntPwDiff & 0xf0)>>4);
2669 // Antenna D gain offset to antenna A, bit8~11
2670 priv->AntennaTxPwDiff[2] = ((priv->EEPROMAntPwDiff & 0xf00)>>8);
2671 // CrystalCap, bit12~15
2672 priv->CrystalCap = priv->EEPROMCrystalCap;
2673 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2674 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
2675 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
2677 else if(priv->epromtype == EPROM_93c56)
2679 //char cck_pwr_diff_a=0, cck_pwr_diff_c=0;
2681 //cck_pwr_diff_a = pHalData->EEPROMRfACCKChnl7TxPwLevel - pHalData->EEPROMRfAOfdmChnlTxPwLevel[1];
2682 //cck_pwr_diff_c = pHalData->EEPROMRfCCCKChnl7TxPwLevel - pHalData->EEPROMRfCOfdmChnlTxPwLevel[1];
2683 for(i=0; i<3; i++) // channel 1~3 use the same Tx Power Level.
2685 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[0];
2686 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[0];
2687 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[0];
2688 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[0];
2690 for(i=3; i<9; i++) // channel 4~9 use the same Tx Power Level
2692 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[1];
2693 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[1];
2694 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[1];
2695 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[1];
2697 for(i=9; i<14; i++) // channel 10~14 use the same Tx Power Level
2699 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[2];
2700 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[2];
2701 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[2];
2702 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[2];
2705 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_A[i]);
2707 RT_TRACE(COMP_INIT,"priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_A[i]);
2709 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_C[i]);
2711 RT_TRACE(COMP_INIT, "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_C[i]);
2712 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2713 priv->AntennaTxPwDiff[0] = 0;
2714 priv->AntennaTxPwDiff[1] = 0;
2715 priv->AntennaTxPwDiff[2] = 0;
2716 priv->CrystalCap = priv->EEPROMCrystalCap;
2717 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2718 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
2719 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
2723 if(priv->rf_type == RF_1T2R)
2725 RT_TRACE(COMP_INIT, "\n1T2R config\n");
2727 else if (priv->rf_type == RF_2T4R)
2729 RT_TRACE(COMP_INIT, "\n2T4R config\n");
2732 // 2008/01/16 MH We can only know RF type in the function. So we have to init
2733 // DIG RATR table again.
2734 init_rate_adaptive(dev);
2736 //1 Make a copy for following variables and we can change them if we want
2738 priv->rf_chip= RF_8256;
2740 if(priv->RegChannelPlan == 0xf)
2742 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2746 priv->ChannelPlan = priv->RegChannelPlan;
2750 // Used PID and DID to Set CustomerID
2752 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304 )
2754 priv->CustomerID = RT_CID_DLINK;
2757 switch(priv->eeprom_CustomerID)
2759 case EEPROM_CID_DEFAULT:
2760 priv->CustomerID = RT_CID_DEFAULT;
2762 case EEPROM_CID_CAMEO:
2763 priv->CustomerID = RT_CID_819x_CAMEO;
2765 case EEPROM_CID_RUNTOP:
2766 priv->CustomerID = RT_CID_819x_RUNTOP;
2768 case EEPROM_CID_NetCore:
2769 priv->CustomerID = RT_CID_819x_Netcore;
2771 case EEPROM_CID_TOSHIBA: // Merge by Jacken, 2008/01/31
2772 priv->CustomerID = RT_CID_TOSHIBA;
2773 if(priv->eeprom_ChannelPlan&0x80)
2774 priv->ChannelPlan = priv->eeprom_ChannelPlan&0x7f;
2776 priv->ChannelPlan = 0x0;
2777 RT_TRACE(COMP_INIT, "Toshiba ChannelPlan = 0x%x\n",
2780 case EEPROM_CID_Nettronix:
2781 priv->ScanDelay = 100; //cosa add for scan
2782 priv->CustomerID = RT_CID_Nettronix;
2784 case EEPROM_CID_Pronet:
2785 priv->CustomerID = RT_CID_PRONET;
2787 case EEPROM_CID_DLINK:
2788 priv->CustomerID = RT_CID_DLINK;
2791 case EEPROM_CID_WHQL:
2792 //Adapter->bInHctTest = TRUE;//do not supported
2794 //priv->bSupportTurboMode = FALSE;
2795 //priv->bAutoTurboBy8186 = FALSE;
2797 //pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
2798 //pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
2799 //pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
2803 // value from RegCustomerID
2807 //Avoid the channel plan array overflow, by Bruce, 2007-08-27.
2808 if(priv->ChannelPlan > CHANNEL_PLAN_LEN - 1)
2809 priv->ChannelPlan = 0; //FCC
2811 switch(priv->CustomerID)
2813 case RT_CID_DEFAULT:
2815 priv->LedStrategy = HW_LED;
2818 priv->LedStrategy = SW_LED_MODE1;
2823 case RT_CID_819x_CAMEO:
2824 priv->LedStrategy = SW_LED_MODE2;
2827 case RT_CID_819x_RUNTOP:
2828 priv->LedStrategy = SW_LED_MODE3;
2831 case RT_CID_819x_Netcore:
2832 priv->LedStrategy = SW_LED_MODE4;
2835 case RT_CID_Nettronix:
2836 priv->LedStrategy = SW_LED_MODE5;
2840 priv->LedStrategy = SW_LED_MODE6;
2843 case RT_CID_TOSHIBA: //Modify by Jacken 2008/01/31
2849 priv->LedStrategy = HW_LED;
2852 priv->LedStrategy = SW_LED_MODE1;
2859 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304)
2860 priv->ieee80211->bSupportRemoteWakeUp = true;
2862 priv->ieee80211->bSupportRemoteWakeUp = false;
2865 RT_TRACE(COMP_INIT, "RegChannelPlan(%d)\n", priv->RegChannelPlan);
2866 RT_TRACE(COMP_INIT, "ChannelPlan = %d \n", priv->ChannelPlan);
2867 RT_TRACE(COMP_INIT, "LedStrategy = %d \n", priv->LedStrategy);
2868 RT_TRACE(COMP_TRACE, "<==== ReadAdapterInfo\n");
2874 static short rtl8192_get_channel_map(struct net_device * dev)
2876 struct r8192_priv *priv = ieee80211_priv(dev);
2877 #ifdef ENABLE_DOT11D
2878 if(priv->ChannelPlan> COUNTRY_CODE_GLOBAL_DOMAIN){
2879 printk("rtl8180_init:Error channel plan! Set to default.\n");
2880 priv->ChannelPlan= 0;
2882 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
2884 rtl819x_set_channel_map(priv->ChannelPlan, priv);
2887 //Set Default Channel Plan
2889 DMESG("No channels, aborting");
2893 priv->ChannelPlan= 0;//hikaru
2894 // set channels 1..14 allowed in given locale
2895 for (i=1; i<=14; i++) {
2896 (priv->ieee80211->channel_map)[i] = (u8)(ch & 0x01);
2903 static short rtl8192_init(struct net_device *dev)
2905 struct r8192_priv *priv = ieee80211_priv(dev);
2906 memset(&(priv->stats),0,sizeof(struct Stats));
2907 rtl8192_init_priv_variable(dev);
2908 rtl8192_init_priv_lock(priv);
2909 rtl8192_init_priv_task(dev);
2910 rtl8192_get_eeprom_size(dev);
2911 rtl8192_read_eeprom_info(dev);
2912 rtl8192_get_channel_map(dev);
2914 init_timer(&priv->watch_dog_timer);
2915 priv->watch_dog_timer.data = (unsigned long)dev;
2916 priv->watch_dog_timer.function = watch_dog_timer_callback;
2917 #if defined(IRQF_SHARED)
2918 if(request_irq(dev->irq, (void*)rtl8192_interrupt, IRQF_SHARED, dev->name, dev)){
2920 if(request_irq(dev->irq, (void *)rtl8192_interrupt, SA_SHIRQ, dev->name, dev)){
2922 printk("Error allocating IRQ %d",dev->irq);
2926 printk("IRQ %d",dev->irq);
2928 if(rtl8192_pci_initdescring(dev)!=0){
2929 printk("Endopoints initialization failed");
2933 //rtl8192_rx_enable(dev);
2934 //rtl8192_adapter_start(dev);
2939 * Actually only set RRSR, RATR and BW_OPMODE registers
2940 * not to do all the hw config as its name says
2941 * This part need to modified according to the rate set we filtered
2943 static void rtl8192_hwconfig(struct net_device* dev)
2945 u32 regRATR = 0, regRRSR = 0;
2946 u8 regBwOpMode = 0, regTmp = 0;
2947 struct r8192_priv *priv = ieee80211_priv(dev);
2949 // Set RRSR, RATR, and BW_OPMODE registers
2951 switch(priv->ieee80211->mode)
2953 case WIRELESS_MODE_B:
2954 regBwOpMode = BW_OPMODE_20MHZ;
2955 regRATR = RATE_ALL_CCK;
2956 regRRSR = RATE_ALL_CCK;
2958 case WIRELESS_MODE_A:
2959 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
2960 regRATR = RATE_ALL_OFDM_AG;
2961 regRRSR = RATE_ALL_OFDM_AG;
2963 case WIRELESS_MODE_G:
2964 regBwOpMode = BW_OPMODE_20MHZ;
2965 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2966 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2968 case WIRELESS_MODE_AUTO:
2969 case WIRELESS_MODE_N_24G:
2970 // It support CCK rate by default.
2971 // CCK rate will be filtered out only when associated AP does not support it.
2972 regBwOpMode = BW_OPMODE_20MHZ;
2973 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2974 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2976 case WIRELESS_MODE_N_5G:
2977 regBwOpMode = BW_OPMODE_5G;
2978 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2979 regRRSR = RATE_ALL_OFDM_AG;
2983 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
2986 ratr_value = regRATR;
2987 if (priv->rf_type == RF_1T2R)
2989 ratr_value &= ~(RATE_ALL_OFDM_2SS);
2991 write_nic_dword(dev, RATR0, ratr_value);
2992 write_nic_byte(dev, UFWP, 1);
2994 regTmp = read_nic_byte(dev, 0x313);
2995 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
2996 write_nic_dword(dev, RRSR, regRRSR);
2999 // Set Retry Limit here
3001 write_nic_word(dev, RETRY_LIMIT,
3002 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT |
3003 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3004 // Set Contention Window here
3008 // Set Tx Antenna including Feedback control
3010 // Set Auto Rate fallback control
3016 static RT_STATUS rtl8192_adapter_start(struct net_device *dev)
3018 struct r8192_priv *priv = ieee80211_priv(dev);
3019 // struct ieee80211_device *ieee = priv->ieee80211;
3021 RT_STATUS rtStatus = RT_STATUS_SUCCESS;
3025 u8 ICVersion,SwitchingRegulatorOutput;
3027 bool bfirmwareok = true;
3031 u32 tmpRegA, tmpRegC, TempCCk;
3034 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3035 priv->being_init_adapter = true;
3036 rtl8192_pci_resetdescring(dev);
3037 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
3038 priv->Rf_Mode = RF_OP_By_SW_3wire;
3041 if(priv->ResetProgress == RESET_TYPE_NORESET)
3043 write_nic_byte(dev, ANAPAR, 0x37);
3044 // Accordign to designer's explain, LBUS active will never > 10ms. We delay 10ms
3045 // Joseph increae the time to prevent firmware download fail
3049 //PlatformSleepUs(10000);
3050 // For any kind of InitializeAdapter process, we shall use system now!!
3051 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3053 // Set to eRfoff in order not to count receive count.
3054 if(priv->RegRfOff == TRUE)
3055 priv->ieee80211->eRFPowerState = eRfOff;
3058 //3 //Config CPUReset Register
3060 //3 Firmware Reset Or Not
3061 ulRegRead = read_nic_dword(dev, CPU_GEN);
3062 if(priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3063 { //called from MPInitialized. do nothing
3064 ulRegRead |= CPU_GEN_SYSTEM_RESET;
3065 }else if(priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3066 ulRegRead |= CPU_GEN_FIRMWARE_RESET; // Called from MPReset
3068 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3071 //2008.06.03, for WOL 90 hw bug
3072 ulRegRead &= (~(CPU_GEN_GPIO_UART));
3075 write_nic_dword(dev, CPU_GEN, ulRegRead);
3081 //3 //Fix the issue of E-cut high temperature issue
3084 ICVersion = read_nic_byte(dev, IC_VERRSION);
3085 if(ICVersion >= 0x4) //E-cut only
3087 // HW SD suggest that we should not wirte this register too often, so driver
3088 // should readback this register. This register will be modified only when
3090 SwitchingRegulatorOutput = read_nic_byte(dev, SWREGULATOR);
3091 if(SwitchingRegulatorOutput != 0xb8)
3093 write_nic_byte(dev, SWREGULATOR, 0xa8);
3095 write_nic_byte(dev, SWREGULATOR, 0xb8);
3102 //3// Initialize BB before MAC
3104 RT_TRACE(COMP_INIT, "BB Config Start!\n");
3105 rtStatus = rtl8192_BBConfig(dev);
3106 if(rtStatus != RT_STATUS_SUCCESS)
3108 RT_TRACE(COMP_ERR, "BB Config failed\n");
3111 RT_TRACE(COMP_INIT,"BB Config Finished!\n");
3113 //3//Set Loopback mode or Normal mode
3115 //2006.12.13 by emily. Note!We should not merge these two CPU_GEN register writings
3116 // because setting of System_Reset bit reset MAC to default transmission mode.
3117 //Loopback mode or not
3118 priv->LoopbackMode = RTL819X_NO_LOOPBACK;
3119 //priv->LoopbackMode = RTL819X_MAC_LOOPBACK;
3120 if(priv->ResetProgress == RESET_TYPE_NORESET)
3122 ulRegRead = read_nic_dword(dev, CPU_GEN);
3123 if(priv->LoopbackMode == RTL819X_NO_LOOPBACK)
3125 ulRegRead = ((ulRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3127 else if (priv->LoopbackMode == RTL819X_MAC_LOOPBACK )
3129 ulRegRead |= CPU_CCK_LOOPBACK;
3133 RT_TRACE(COMP_ERR,"Serious error: wrong loopback mode setting\n");
3136 //2008.06.03, for WOL
3137 //ulRegRead &= (~(CPU_GEN_GPIO_UART));
3138 write_nic_dword(dev, CPU_GEN, ulRegRead);
3140 // 2006.11.29. After reset cpu, we sholud wait for a second, otherwise, it may fail to write registers. Emily
3143 //3Set Hardware(Do nothing now)
3144 rtl8192_hwconfig(dev);
3145 //2=======================================================
3146 // Common Setting for all of the FPGA platform. (part 1)
3147 //2=======================================================
3148 // If there is changes, please make sure it applies to all of the FPGA version
3150 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3154 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3155 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) |
3159 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3160 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) ));
3164 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3165 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3167 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3169 //3 Initialize Number of Reserved Pages in Firmware Queue
3171 if(priv->bInHctTest)
3173 PlatformEFIOWrite4Byte(Adapter, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK_DTM << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3174 NUM_OF_PAGE_IN_FW_QUEUE_BE_DTM << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3175 NUM_OF_PAGE_IN_FW_QUEUE_VI_DTM << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3176 NUM_OF_PAGE_IN_FW_QUEUE_VO_DTM <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3177 PlatformEFIOWrite4Byte(Adapter, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3178 PlatformEFIOWrite4Byte(Adapter, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3179 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3180 NUM_OF_PAGE_IN_FW_QUEUE_PUB_DTM<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3185 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3186 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3187 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3188 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3189 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3190 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3191 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3192 NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3195 rtl8192_tx_enable(dev);
3196 rtl8192_rx_enable(dev);
3197 //3Set Response Rate Setting Register
3198 // CCK rate is supported by default.
3199 // CCK rate will be filtered out only when associated AP does not support it.
3200 ulRegRead = (0xFFF00000 & read_nic_dword(dev, RRSR)) | RATE_ALL_OFDM_AG | RATE_ALL_CCK;
3201 write_nic_dword(dev, RRSR, ulRegRead);
3202 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3205 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3206 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3208 //rtl8192_actset_wirelessmode(dev,priv->RegWirelessMode);
3209 if(priv->ResetProgress == RESET_TYPE_NORESET)
3210 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3211 //-----------------------------------------------------------------------------
3212 // Set up security related. 070106, by rcnjko:
3213 // 1. Clear all H/W keys.
3214 // 2. Enable H/W encryption/decryption.
3215 //-----------------------------------------------------------------------------
3216 CamResetAllEntry(dev);
3218 u8 SECR_value = 0x0;
3219 SECR_value |= SCR_TxEncEnable;
3220 SECR_value |= SCR_RxDecEnable;
3221 SECR_value |= SCR_NoSKMC;
3222 write_nic_byte(dev, SECR, SECR_value);
3225 write_nic_word(dev, ATIMWND, 2);
3226 write_nic_word(dev, BCN_INTERVAL, 100);
3227 for (i=0; i<QOS_QUEUE_NUM; i++)
3228 write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
3230 // Switching regulator controller: This is set temporarily.
3231 // It's not sure if this can be removed in the future.
3232 // PJ advised to leave it by default.
3234 write_nic_byte(dev, 0xbe, 0xc0);
3236 //2=======================================================
3237 // Set PHY related configuration defined in MAC register bank
3238 //2=======================================================
3239 rtl8192_phy_configmac(dev);
3241 if (priv->card_8192_version > (u8) VERSION_8190_BD) {
3242 rtl8192_phy_getTxPower(dev);
3243 rtl8192_phy_setTxPower(dev, priv->chan);
3247 tmpvalue = read_nic_byte(dev, IC_VERRSION);
3248 priv->IC_Cut = tmpvalue;
3249 RT_TRACE(COMP_INIT, "priv->IC_Cut = 0x%x\n", priv->IC_Cut);
3250 if(priv->IC_Cut >= IC_VersionCut_D)
3252 //pHalData->bDcut = TRUE;
3253 if(priv->IC_Cut == IC_VersionCut_D)
3254 RT_TRACE(COMP_INIT, "D-cut\n");
3255 if(priv->IC_Cut == IC_VersionCut_E)
3257 RT_TRACE(COMP_INIT, "E-cut\n");
3258 // HW SD suggest that we should not wirte this register too often, so driver
3259 // should readback this register. This register will be modified only when
3265 //pHalData->bDcut = FALSE;
3266 RT_TRACE(COMP_INIT, "Before C-cut\n");
3271 RT_TRACE(COMP_INIT, "Load Firmware!\n");
3272 bfirmwareok = init_firmware(dev);
3273 if(bfirmwareok != true) {
3274 rtStatus = RT_STATUS_FAILURE;
3277 RT_TRACE(COMP_INIT, "Load Firmware finished!\n");
3280 if(priv->ResetProgress == RESET_TYPE_NORESET)
3282 RT_TRACE(COMP_INIT, "RF Config Started!\n");
3283 rtStatus = rtl8192_phy_RFConfig(dev);
3284 if(rtStatus != RT_STATUS_SUCCESS)
3286 RT_TRACE(COMP_ERR, "RF Config failed\n");
3289 RT_TRACE(COMP_INIT, "RF Config Finished!\n");
3291 rtl8192_phy_updateInitGain(dev);
3293 /*---- Set CCK and OFDM Block "ON"----*/
3294 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3295 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3299 write_nic_byte(dev, 0x87, 0x0);
3302 //2008.06.03, for WOL
3303 ucRegRead = read_nic_byte(dev, GPE);
3305 write_nic_byte(dev, GPE, ucRegRead);
3307 ucRegRead = read_nic_byte(dev, GPO);
3309 write_nic_byte(dev, GPO, ucRegRead);
3312 //2=======================================================
3314 //2=======================================================
3318 if(priv->RegRfOff == TRUE)
3319 { // User disable RF via registry.
3320 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RegRfOff ----------\n",__FUNCTION__);
3321 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW);
3322 #if 0//cosa, ask SD3 willis and he doesn't know what is this for
3323 // Those action will be discard in MgntActSet_RF_State because off the same state
3324 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3325 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3328 else if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS)
3329 { // H/W or S/W RF OFF before sleep.
3330 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3331 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3333 else if(priv->ieee80211->RfOffReason >= RF_CHANGE_BY_IPS)
3334 { // H/W or S/W RF OFF before sleep.
3335 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3336 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3340 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): RF-ON \n",__FUNCTION__);
3341 priv->ieee80211->eRFPowerState = eRfOn;
3342 priv->ieee80211->RfOffReason = 0;
3343 //DrvIFIndicateCurrentPhyStatus(Adapter);
3345 //Adapter->HalFunc.LedControlHandler(Adapter, LED_CTL_POWER_ON);
3348 // If inactive power mode is enabled, disable rf while in disconnected state.
3349 // But we should still tell upper layer we are in rf on state.
3350 // 2007.07.16, by shien chang.
3352 //if(!Adapter->bInHctTest)
3353 //IPSEnter(Adapter);
3360 // We can force firmware to do RF-R/W
3361 if(priv->ieee80211->FwRWRF)
3362 priv->Rf_Mode = RF_OP_By_FW;
3364 priv->Rf_Mode = RF_OP_By_SW_3wire;
3366 priv->Rf_Mode = RF_OP_By_SW_3wire;
3370 if(priv->ResetProgress == RESET_TYPE_NORESET)
3372 dm_initialize_txpower_tracking(dev);
3374 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3375 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3377 if(priv->rf_type == RF_2T4R){
3378 for(i = 0; i<TxBBGainTableLength; i++)
3380 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3382 priv->rfa_txpowertrackingindex= (u8)i;
3383 priv->rfa_txpowertrackingindex_real= (u8)i;
3384 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3389 for(i = 0; i<TxBBGainTableLength; i++)
3391 if(tmpRegC == priv->txbbgain_table[i].txbbgain_value)
3393 priv->rfc_txpowertrackingindex= (u8)i;
3394 priv->rfc_txpowertrackingindex_real= (u8)i;
3395 priv->rfc_txpowertracking_default = priv->rfc_txpowertrackingindex;
3399 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3401 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3403 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3405 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3409 priv->CCKPresentAttentuation_40Mdefault = 0;
3410 priv->CCKPresentAttentuation_difference = 0;
3411 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3412 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3413 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3414 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_initial = %d\n", priv->rfc_txpowertrackingindex);
3415 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_real_initial = %d\n", priv->rfc_txpowertrackingindex_real);
3416 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3417 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3421 if(priv->ResetProgress == RESET_TYPE_NORESET)
3423 dm_initialize_txpower_tracking(dev);
3425 if(priv->IC_Cut >= IC_VersionCut_D)
3427 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3428 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3429 for(i = 0; i<TxBBGainTableLength; i++)
3431 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3433 priv->rfa_txpowertrackingindex= (u8)i;
3434 priv->rfa_txpowertrackingindex_real= (u8)i;
3435 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3440 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3442 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3444 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3446 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3450 priv->CCKPresentAttentuation_40Mdefault = 0;
3451 priv->CCKPresentAttentuation_difference = 0;
3452 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3453 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3454 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3455 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3456 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3457 priv->btxpower_tracking = FALSE;//TEMPLY DISABLE
3462 rtl8192_irq_enable(dev);
3463 priv->being_init_adapter = false;
3468 static void rtl8192_prepare_beacon(struct r8192_priv *priv)
3470 struct sk_buff *skb;
3471 //unsigned long flags;
3474 skb = ieee80211_get_beacon(priv->ieee80211);
3475 tcb_desc = (cb_desc *)(skb->cb + 8);
3476 //spin_lock_irqsave(&priv->tx_lock,flags);
3477 /* prepare misc info for the beacon xmit */
3478 tcb_desc->queue_index = BEACON_QUEUE;
3479 /* IBSS does not support HT yet, use 1M defaultly */
3480 tcb_desc->data_rate = 2;
3481 tcb_desc->RATRIndex = 7;
3482 tcb_desc->bTxDisableRateFallBack = 1;
3483 tcb_desc->bTxUseDriverAssingedRate = 1;
3485 skb_push(skb, priv->ieee80211->tx_headroom);
3487 rtl8192_tx(priv->ieee80211->dev,skb);
3489 //spin_unlock_irqrestore (&priv->tx_lock, flags);
3494 * configure registers for beacon tx and enables it via
3495 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3496 * be used to stop beacon transmission
3498 static void rtl8192_start_beacon(struct net_device *dev)
3500 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3501 struct ieee80211_network *net = &priv->ieee80211->current_network;
3506 DMESG("Enabling beacon TX");
3507 //rtl8192_prepare_beacon(dev);
3508 rtl8192_irq_disable(dev);
3509 //rtl8192_beacon_tx_enable(dev);
3512 write_nic_word(dev, ATIMWND, 2);
3514 /* Beacon interval (in unit of TU) */
3515 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
3518 * DrvErlyInt (in unit of TU).
3519 * (Time to send interrupt to notify driver to c
3520 * hange beacon content)
3522 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
3525 * BcnDMATIM(in unit of us).
3526 * Indicates the time before TBTT to perform beacon queue DMA
3528 write_nic_word(dev, BCN_DMATIME, 256);
3531 * Force beacon frame transmission even after receiving
3532 * beacon frame from other ad hoc STA
3534 write_nic_byte(dev, BCN_ERR_THRESH, 100);
3536 /* Set CW and IFS */
3537 BcnTimeCfg |= BcnCW<<BCN_TCFG_CW_SHIFT;
3538 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
3539 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
3542 /* enable the interrupt for ad-hoc process */
3543 rtl8192_irq_enable(dev);
3546 static bool HalTxCheckStuck8190Pci(struct net_device *dev)
3548 u16 RegTxCounter = read_nic_word(dev, 0x128);
3549 struct r8192_priv *priv = ieee80211_priv(dev);
3550 bool bStuck = FALSE;
3551 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3552 if(priv->TxCounter==RegTxCounter)
3555 priv->TxCounter = RegTxCounter;
3561 * Assumption: RT_TX_SPINLOCK is acquired.
3564 TxCheckStuck(struct net_device *dev)
3566 struct r8192_priv *priv = ieee80211_priv(dev);
3568 ptx_ring head=NULL,tail=NULL,txring = NULL;
3569 u8 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3570 bool bCheckFwTxCnt = false;
3573 // Decide Stuch threshold according to current power save mode
3575 switch (priv->ieee80211->dot11PowerSaveMode)
3577 // The threshold value may required to be adjusted .
3578 case eActive: // Active/Continuous access.
3579 ResetThreshold = NIC_SEND_HANG_THRESHOLD_NORMAL;
3581 case eMaxPs: // Max power save mode.
3582 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3584 case eFastPs: // Fast power save mode.
3585 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3590 // Check whether specific tcb has been queued for a specific time
3592 for(QueueID = 0; QueueID < MAX_TX_QUEUE; QueueID++)
3596 if(QueueID == TXCMD_QUEUE)
3601 tail=priv->txmapringtail;
3602 head=priv->txmapringhead;
3606 tail=priv->txbkpringtail;
3607 head=priv->txbkpringhead;
3611 tail=priv->txbepringtail;
3612 head=priv->txbepringhead;
3616 tail=priv->txvipringtail;
3617 head=priv->txvipringhead;
3621 tail=priv->txvopringtail;
3622 head=priv->txvopringhead;
3637 RT_TRACE(COMP_ERR,"%s():txring is NULL , BUG!\n",__FUNCTION__);
3640 txring->nStuckCount++;
3641 bCheckFwTxCnt = TRUE;
3647 if(HalTxCheckStuck8190Pci(dev))
3649 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3650 return RESET_TYPE_SILENT;
3654 return RESET_TYPE_NORESET;
3658 static bool HalRxCheckStuck8190Pci(struct net_device *dev)
3660 struct r8192_priv *priv = ieee80211_priv(dev);
3661 u16 RegRxCounter = read_nic_word(dev, 0x130);
3662 bool bStuck = FALSE;
3663 static u8 rx_chk_cnt = 0;
3664 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3665 // If rssi is small, we should check rx for long time because of bad rx.
3666 // or maybe it will continuous silent reset every 2 seconds.
3668 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3670 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
3672 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3673 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3674 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
3686 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
3687 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
3688 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
3692 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3698 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3705 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
3711 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
3714 if(priv->RxCounter==RegRxCounter)
3717 priv->RxCounter = RegRxCounter;
3722 static RESET_TYPE RxCheckStuck(struct net_device *dev)
3725 if(HalRxCheckStuck8190Pci(dev))
3727 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
3728 return RESET_TYPE_SILENT;
3731 return RESET_TYPE_NORESET;
3735 rtl819x_ifcheck_resetornot(struct net_device *dev)
3737 struct r8192_priv *priv = ieee80211_priv(dev);
3738 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
3739 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
3740 RT_RF_POWER_STATE rfState;
3742 rfState = priv->ieee80211->eRFPowerState;
3744 TxResetType = TxCheckStuck(dev);
3746 if( rfState != eRfOff &&
3747 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3748 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
3750 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3751 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3752 // if driver is in firmware download failure status, driver should initialize RF in the following
3753 // silent reset procedure Emily, 2008.01.21
3755 // Driver should not check RX stuck in IBSS mode because it is required to
3756 // set Check BSSID in order to send beacon, however, if check BSSID is
3757 // set, STA cannot hear any packet a all. Emily, 2008.04.12
3758 RxResetType = RxCheckStuck(dev);
3762 RT_TRACE(COMP_RESET,"%s(): TxResetType is %d, RxResetType is %d\n",__FUNCTION__,TxResetType,RxResetType);
3763 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
3764 return RESET_TYPE_NORMAL;
3765 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT)
3766 return RESET_TYPE_SILENT;
3768 return RESET_TYPE_NORESET;
3773 static void CamRestoreAllEntry(struct net_device *dev)
3776 struct r8192_priv *priv = ieee80211_priv(dev);
3777 const u8* MacAddr = priv->ieee80211->current_network.bssid;
3779 static const u8 CAM_CONST_ADDR[4][6] = {
3780 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3781 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3782 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3783 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3784 static const u8 CAM_CONST_BROAD[] =
3785 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3787 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3790 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
3791 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
3794 for(EntryId=0; EntryId<4; EntryId++)
3797 MacAddr = CAM_CONST_ADDR[EntryId];
3801 priv->ieee80211->pairwise_key_type,
3809 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
3813 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3817 priv->ieee80211->pairwise_key_type,
3825 priv->ieee80211->pairwise_key_type,
3831 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
3835 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3839 priv->ieee80211->pairwise_key_type,
3847 priv->ieee80211->pairwise_key_type,
3856 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
3858 MacAddr = CAM_CONST_BROAD;
3859 for(EntryId=1 ; EntryId<4 ; EntryId++)
3865 priv->ieee80211->group_key_type,
3871 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3875 priv->ieee80211->group_key_type,
3880 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
3882 MacAddr = CAM_CONST_BROAD;
3883 for(EntryId=1; EntryId<4 ; EntryId++)
3889 priv->ieee80211->group_key_type,
3896 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3900 priv->ieee80211->group_key_type,
3908 * This function is used to fix Tx/Rx stop bug temporarily.
3909 * This function will do "system reset" to NIC when Tx or Rx is stuck.
3910 * The method checking Tx/Rx stuck of this function is supported by FW,
3911 * which reports Tx and Rx counter to register 0x128 and 0x130.
3913 static void rtl819x_ifsilentreset(struct net_device *dev)
3915 struct r8192_priv *priv = ieee80211_priv(dev);
3917 int reset_status = 0;
3918 struct ieee80211_device *ieee = priv->ieee80211;
3923 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3924 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3926 if(priv->ResetProgress==RESET_TYPE_NORESET)
3930 //LZM for PS-Poll AID issue. 090429
3931 if(priv->ieee80211->state == IEEE80211_LINKED)
3932 LeisurePSLeave(dev);
3935 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
3937 // Set the variable for reset.
3938 priv->ResetProgress = RESET_TYPE_SILENT;
3939 // rtl8192_close(dev);
3941 down(&priv->wx_sem);
3944 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
3949 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
3950 if(!netif_queue_stopped(dev))
3951 netif_stop_queue(dev);
3953 dm_backup_dynamic_mechanism_state(dev);
3955 rtl8192_irq_disable(dev);
3956 rtl8192_cancel_deferred_work(priv);
3958 del_timer_sync(&priv->watch_dog_timer);
3959 ieee->sync_scan_hurryup = 1;
3960 if(ieee->state == IEEE80211_LINKED)
3962 down(&ieee->wx_sem);
3963 printk("ieee->state is IEEE80211_LINKED\n");
3964 ieee80211_stop_send_beacons(priv->ieee80211);
3965 del_timer_sync(&ieee->associate_timer);
3966 cancel_delayed_work(&ieee->associate_retry_wq);
3967 ieee80211_stop_scan(ieee);
3971 printk("ieee->state is NOT LINKED\n");
3972 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
3974 rtl8192_halt_adapter(dev, true);
3976 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
3977 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
3978 reset_status = _rtl8192_up(dev);
3980 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
3981 if(reset_status == -1)
3990 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n",__FUNCTION__);
3994 ieee->is_silent_reset = 1;
3996 EnableHWSecurityConfig8192(dev);
3998 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4000 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4003 queue_work(ieee->wq, &ieee->associate_complete_wq);
4007 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
4009 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4010 ieee->link_change(ieee->dev);
4012 // notify_wx_assoc_event(ieee);
4014 ieee80211_start_send_beacons(ieee);
4016 if (ieee->data_hard_resume)
4017 ieee->data_hard_resume(ieee->dev);
4018 netif_carrier_on(ieee->dev);
4022 CamRestoreAllEntry(dev);
4024 // Restore the previous setting for all dynamic mechanism
4025 dm_restore_dynamic_mechanism_state(dev);
4027 priv->ResetProgress = RESET_TYPE_NORESET;
4028 priv->reset_count++;
4030 priv->bForcedSilentReset =false;
4031 priv->bResetInProgress = false;
4033 // For test --> force write UFWP.
4034 write_nic_byte(dev, UFWP, 1);
4035 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4041 void InactivePsWorkItemCallback(struct net_device *dev)
4043 struct r8192_priv *priv = ieee80211_priv(dev);
4044 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4046 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() ---------> \n");
4048 // This flag "bSwRfProcessing", indicates the status of IPS procedure, should be set if the IPS workitem
4049 // is really scheduled.
4050 // The old code, sets this flag before scheduling the IPS workitem and however, at the same time the
4051 // previous IPS workitem did not end yet, fails to schedule the current workitem. Thus, bSwRfProcessing
4052 // blocks the IPS procedure of switching RF.
4053 // By Bruce, 2007-12-25.
4055 pPSC->bSwRfProcessing = TRUE;
4057 RT_TRACE(COMP_RF, "InactivePsWorkItemCallback(): Set RF to %s.\n",
4058 pPSC->eInactivePowerState == eRfOff?"OFF":"ON");
4061 MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
4064 // To solve CAM values miss in RF OFF, rewrite CAM values after RF ON. By Bruce, 2007-09-20.
4066 pPSC->bSwRfProcessing = FALSE;
4067 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() <--------- \n");
4071 /* Change current and default preamble mode. */
4072 bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev, u8 rtPsMode)
4074 struct r8192_priv *priv = ieee80211_priv(dev);
4076 // Currently, we do not change power save mode on IBSS mode.
4077 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4083 // <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
4084 // some AP will not response to our mgnt frames with PwrMgt bit set,
4085 // e.g. cannot associate the AP.
4086 // So I commented out it. 2005.02.16, by rcnjko.
4088 // // Change device's power save mode.
4089 // Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
4091 // Update power save mode configured.
4092 //RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__FUNCTION__,rtPsMode);
4093 if(!priv->ps_force) {
4094 priv->ieee80211->ps = rtPsMode;
4097 // Awake immediately
4098 if(priv->ieee80211->sta_sleep != 0 && rtPsMode == IEEE80211_PS_DISABLED)
4100 unsigned long flags;
4102 //PlatformSetTimer(Adapter, &(pMgntInfo->AwakeTimer), 0);
4103 // Notify the AP we awke.
4104 rtl8192_hw_wakeup(dev);
4105 priv->ieee80211->sta_sleep = 0;
4107 spin_lock_irqsave(&(priv->ieee80211->mgmt_tx_lock), flags);
4108 printk("LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
4109 ieee80211_sta_ps_send_null_frame(priv->ieee80211, 0);
4110 spin_unlock_irqrestore(&(priv->ieee80211->mgmt_tx_lock), flags);
4116 /* Enter the leisure power save mode. */
4117 void LeisurePSEnter(struct net_device *dev)
4119 struct r8192_priv *priv = ieee80211_priv(dev);
4120 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4122 //RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
4123 //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
4124 // pPSC->bLeisurePs, priv->ieee80211->ps,pPSC->LpsIdleCount,RT_CHECK_FOR_HANG_PERIOD);
4126 if(!((priv->ieee80211->iw_mode == IW_MODE_INFRA) &&
4127 (priv->ieee80211->state == IEEE80211_LINKED)) ||
4128 (priv->ieee80211->iw_mode == IW_MODE_ADHOC) ||
4129 (priv->ieee80211->iw_mode == IW_MODE_MASTER))
4132 if (pPSC->bLeisurePs)
4134 // Idle for a while if we connect to AP a while ago.
4135 if(pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) // 4 Sec
4138 if(priv->ieee80211->ps == IEEE80211_PS_DISABLED)
4141 //RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter 802.11 power save mode...\n");
4142 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST);
4147 pPSC->LpsIdleCount++;
4152 /* Leave leisure power save mode. */
4153 void LeisurePSLeave(struct net_device *dev)
4155 struct r8192_priv *priv = ieee80211_priv(dev);
4156 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4158 if (pPSC->bLeisurePs)
4160 if(priv->ieee80211->ps != IEEE80211_PS_DISABLED)
4162 // move to lps_wakecomplete()
4163 //RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n");
4164 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_DISABLED);
4172 /* Enter the inactive power save mode. RF will be off */
4174 IPSEnter(struct net_device *dev)
4176 struct r8192_priv *priv = ieee80211_priv(dev);
4177 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4178 RT_RF_POWER_STATE rtState;
4180 if (pPSC->bInactivePs)
4182 rtState = priv->ieee80211->eRFPowerState;
4184 // Added by Bruce, 2007-12-25.
4185 // Do not enter IPS in the following conditions:
4186 // (1) RF is already OFF or Sleep
4187 // (2) bSwRfProcessing (indicates the IPS is still under going)
4188 // (3) Connectted (only disconnected can trigger IPS)
4189 // (4) IBSS (send Beacon)
4190 // (5) AP mode (send Beacon)
4192 if (rtState == eRfOn && !pPSC->bSwRfProcessing
4193 && (priv->ieee80211->state != IEEE80211_LINKED) )
4195 RT_TRACE(COMP_RF,"IPSEnter(): Turn off RF.\n");
4196 //printk("IPSEnter(): Turn off RF.\n");
4197 pPSC->eInactivePowerState = eRfOff;
4198 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4199 InactivePsWorkItemCallback(dev);
4206 // Leave the inactive power save mode, RF will be on.
4207 // 2007.08.17, by shien chang.
4210 IPSLeave(struct net_device *dev)
4212 struct r8192_priv *priv = ieee80211_priv(dev);
4213 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4214 RT_RF_POWER_STATE rtState;
4216 if (pPSC->bInactivePs)
4218 rtState = priv->ieee80211->eRFPowerState;
4219 if (rtState != eRfOn && !pPSC->bSwRfProcessing && priv->ieee80211->RfOffReason <= RF_CHANGE_BY_IPS)
4221 RT_TRACE(COMP_POWER, "IPSLeave(): Turn on RF.\n");
4222 //printk("IPSLeave(): Turn on RF.\n");
4223 pPSC->eInactivePowerState = eRfOn;
4224 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4225 InactivePsWorkItemCallback(dev);
4230 void IPSLeave_wq(void *data)
4232 struct ieee80211_device *ieee = container_of(data,struct ieee80211_device,ips_leave_wq);
4233 struct net_device *dev = ieee->dev;
4235 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4236 down(&priv->ieee80211->ips_sem);
4238 up(&priv->ieee80211->ips_sem);
4241 void ieee80211_ips_leave_wq(struct net_device *dev)
4243 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4244 RT_RF_POWER_STATE rtState;
4245 rtState = priv->ieee80211->eRFPowerState;
4247 if(priv->ieee80211->PowerSaveControl.bInactivePs){
4248 if(rtState == eRfOff){
4249 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
4251 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
4255 printk("=========>%s(): IPSLeave\n",__FUNCTION__);
4256 queue_work(priv->ieee80211->wq,&priv->ieee80211->ips_leave_wq);
4261 //added by amy 090331 end
4262 void ieee80211_ips_leave(struct net_device *dev)
4264 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4265 down(&priv->ieee80211->ips_sem);
4267 up(&priv->ieee80211->ips_sem);
4271 static void rtl819x_update_rxcounts(
4272 struct r8192_priv *priv,
4281 *TotalRxDataNum = 0;
4283 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4284 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4285 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4286 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4287 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4288 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4293 static void rtl819x_watchdog_wqcallback(struct work_struct *work)
4295 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4296 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4297 struct net_device *dev = priv->ieee80211->dev;
4298 struct ieee80211_device* ieee = priv->ieee80211;
4299 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4300 static u8 check_reset_cnt=0;
4301 unsigned long flags;
4302 bool bBusyTraffic = false;
4303 static u8 last_time = 0;
4304 bool bEnterPS = false;
4306 if ((!priv->up) || priv->bHwRadioOff)
4311 hal_dm_watchdog(dev);
4313 // printk("watch_dog ENABLE_IPS\n");
4314 if(ieee->actscanning == false){
4315 //printk("%d,%d,%d,%d\n", ieee->eRFPowerState, ieee->is_set_key, ieee->proto_stoppping, ieee->wx_set_enc);
4316 if((ieee->iw_mode == IW_MODE_INFRA) && (ieee->state == IEEE80211_NOLINK) &&
4317 (ieee->eRFPowerState == eRfOn)&&!ieee->is_set_key &&
4318 (!ieee->proto_stoppping) && !ieee->wx_set_enc){
4319 if(ieee->PowerSaveControl.ReturnPoint == IPS_CALLBACK_NONE){
4320 //printk("====================>haha:IPSEnter()\n");
4322 //ieee80211_stop_scan(priv->ieee80211);
4327 {//to get busy traffic condition
4328 if(ieee->state == IEEE80211_LINKED)
4330 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 100 ||
4331 ieee->LinkDetectInfo.NumTxOkInPeriod> 100 ) {
4332 bBusyTraffic = true;
4336 //added by amy for Leisure PS
4337 if( ((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod + ieee->LinkDetectInfo.NumTxOkInPeriod) > 8 ) ||
4338 (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2) )
4340 //printk("ieee->LinkDetectInfo.NumRxUnicastOkInPeriod is %d,ieee->LinkDetectInfo.NumTxOkInPeriod is %d\n",
4341 // ieee->LinkDetectInfo.NumRxUnicastOkInPeriod,ieee->LinkDetectInfo.NumTxOkInPeriod);
4349 //printk("***bEnterPS = %d\n", bEnterPS);
4350 // LeisurePS only work in infra mode.
4353 LeisurePSEnter(dev);
4357 LeisurePSLeave(dev);
4365 //RT_TRACE(COMP_LPS,"====>no link LPS leave\n");
4366 LeisurePSLeave(dev);
4370 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4371 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4372 ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
4373 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4377 //added by amy for AP roaming
4380 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4382 u32 TotalRxBcnNum = 0;
4383 u32 TotalRxDataNum = 0;
4385 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4386 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4388 if( ieee->eRFPowerState == eRfOff)
4389 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4390 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4391 // Dot11d_Reset(dev);
4392 ieee->state = IEEE80211_ASSOCIATING;
4393 notify_wx_assoc_event(priv->ieee80211);
4394 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4395 ieee->is_roaming = true;
4396 ieee->is_set_key = false;
4397 ieee->link_change(dev);
4398 queue_work(ieee->wq, &ieee->associate_procedure_wq);
4401 ieee->LinkDetectInfo.NumRecvBcnInPeriod=0;
4402 ieee->LinkDetectInfo.NumRecvDataInPeriod=0;
4405 //check if reset the driver
4406 spin_lock_irqsave(&priv->tx_lock,flags);
4407 if(check_reset_cnt++ >= 3 && !ieee->is_roaming && (last_time != 1))
4409 ResetType = rtl819x_ifcheck_resetornot(dev);
4410 check_reset_cnt = 3;
4411 //DbgPrint("Start to check silent reset\n");
4413 spin_unlock_irqrestore(&priv->tx_lock,flags);
4414 if(!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_NORMAL)
4416 priv->ResetProgress = RESET_TYPE_NORMAL;
4417 RT_TRACE(COMP_RESET,"%s(): NOMAL RESET\n",__FUNCTION__);
4420 /* disable silent reset temply 2008.9.11*/
4422 if( ((priv->force_reset) || (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT))) // This is control by OID set in Pomelo
4425 rtl819x_ifsilentreset(dev);
4430 priv->force_reset = false;
4431 priv->bForcedSilentReset = false;
4432 priv->bResetInProgress = false;
4433 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4437 void watch_dog_timer_callback(unsigned long data)
4439 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4440 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq,0);
4441 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4445 static int _rtl8192_up(struct net_device *dev)
4447 struct r8192_priv *priv = ieee80211_priv(dev);
4449 RT_STATUS init_status = RT_STATUS_SUCCESS;
4451 priv->ieee80211->ieee_up=1;
4452 priv->bdisable_nic = false; //YJ,add,091111
4453 RT_TRACE(COMP_INIT, "Bringing up iface");
4455 init_status = rtl8192_adapter_start(dev);
4456 if(init_status != RT_STATUS_SUCCESS)
4458 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
4461 RT_TRACE(COMP_INIT, "start adapter finished\n");
4463 if(priv->ieee80211->eRFPowerState!=eRfOn)
4464 MgntActSet_RF_State(dev, eRfOn, priv->ieee80211->RfOffReason);
4466 if(priv->ieee80211->state != IEEE80211_LINKED)
4467 ieee80211_softmac_start_protocol(priv->ieee80211);
4468 ieee80211_reset_queue(priv->ieee80211);
4469 watch_dog_timer_callback((unsigned long) dev);
4470 if(!netif_queue_stopped(dev))
4471 netif_start_queue(dev);
4473 netif_wake_queue(dev);
4479 static int rtl8192_open(struct net_device *dev)
4481 struct r8192_priv *priv = ieee80211_priv(dev);
4484 down(&priv->wx_sem);
4485 ret = rtl8192_up(dev);
4492 int rtl8192_up(struct net_device *dev)
4494 struct r8192_priv *priv = ieee80211_priv(dev);
4496 if (priv->up == 1) return -1;
4498 return _rtl8192_up(dev);
4502 static int rtl8192_close(struct net_device *dev)
4504 struct r8192_priv *priv = ieee80211_priv(dev);
4507 down(&priv->wx_sem);
4509 ret = rtl8192_down(dev);
4517 int rtl8192_down(struct net_device *dev)
4519 struct r8192_priv *priv = ieee80211_priv(dev);
4521 if (priv->up == 0) return -1;
4524 //LZM for PS-Poll AID issue. 090429
4525 if(priv->ieee80211->state == IEEE80211_LINKED)
4526 LeisurePSLeave(dev);
4530 priv->ieee80211->ieee_up = 0;
4531 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4533 if (!netif_queue_stopped(dev))
4534 netif_stop_queue(dev);
4536 rtl8192_irq_disable(dev);
4537 rtl8192_cancel_deferred_work(priv);
4539 del_timer_sync(&priv->watch_dog_timer);
4541 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4543 rtl8192_halt_adapter(dev,false);
4544 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4546 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4552 void rtl8192_commit(struct net_device *dev)
4554 struct r8192_priv *priv = ieee80211_priv(dev);
4556 if (priv->up == 0) return ;
4559 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4561 rtl8192_irq_disable(dev);
4562 rtl8192_halt_adapter(dev,true);
4566 static void rtl8192_restart(struct work_struct *work)
4568 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4569 struct net_device *dev = priv->ieee80211->dev;
4571 down(&priv->wx_sem);
4573 rtl8192_commit(dev);
4578 static void r8192_set_multicast(struct net_device *dev)
4580 struct r8192_priv *priv = ieee80211_priv(dev);
4583 //down(&priv->wx_sem);
4587 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4589 if (promisc != priv->promisc) {
4591 // rtl8192_commit(dev);
4594 priv->promisc = promisc;
4596 //schedule_work(&priv->reset_wq);
4597 //up(&priv->wx_sem);
4601 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
4603 struct r8192_priv *priv = ieee80211_priv(dev);
4604 struct sockaddr *addr = mac;
4606 down(&priv->wx_sem);
4608 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4610 schedule_work(&priv->reset_wq);
4616 /* based on ipw2200 driver */
4617 static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4619 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4620 struct iwreq *wrq = (struct iwreq *)rq;
4622 struct ieee80211_device *ieee = priv->ieee80211;
4624 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4625 struct iw_point *p = &wrq->u.data;
4626 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
4628 down(&priv->wx_sem);
4631 if (p->length < sizeof(struct ieee_param) || !p->pointer){
4636 ipw = kmalloc(p->length, GFP_KERNEL);
4641 if (copy_from_user(ipw, p->pointer, p->length)) {
4648 case RTL_IOCTL_WPA_SUPPLICANT:
4649 //parse here for HW security
4650 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
4652 if (ipw->u.crypt.set_tx)
4654 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4655 ieee->pairwise_key_type = KEY_TYPE_CCMP;
4656 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4657 ieee->pairwise_key_type = KEY_TYPE_TKIP;
4658 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4660 if (ipw->u.crypt.key_len == 13)
4661 ieee->pairwise_key_type = KEY_TYPE_WEP104;
4662 else if (ipw->u.crypt.key_len == 5)
4663 ieee->pairwise_key_type = KEY_TYPE_WEP40;
4666 ieee->pairwise_key_type = KEY_TYPE_NA;
4668 if (ieee->pairwise_key_type)
4670 memcpy((u8*)key, ipw->u.crypt.key, 16);
4671 EnableHWSecurityConfig8192(dev);
4672 //we fill both index entry and 4th entry for pairwise key as in IPW interface, adhoc will only get here, so we need index entry for its default key serching!
4674 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4675 if (ieee->auth_mode != 2) //LEAP WEP will never set this.
4676 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4678 if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) && ieee->pHTInfo->bCurrentHTSupport){
4679 write_nic_byte(dev, 0x173, 1); //fix aes bug
4683 else //if (ipw->u.crypt.idx) //group key use idx > 0
4685 memcpy((u8*)key, ipw->u.crypt.key, 16);
4686 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4687 ieee->group_key_type= KEY_TYPE_CCMP;
4688 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4689 ieee->group_key_type = KEY_TYPE_TKIP;
4690 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4692 if (ipw->u.crypt.key_len == 13)
4693 ieee->group_key_type = KEY_TYPE_WEP104;
4694 else if (ipw->u.crypt.key_len == 5)
4695 ieee->group_key_type = KEY_TYPE_WEP40;
4698 ieee->group_key_type = KEY_TYPE_NA;
4700 if (ieee->group_key_type)
4704 ipw->u.crypt.idx, //KeyIndex
4705 ieee->group_key_type, //KeyType
4706 broadcast_addr, //MacAddr
4716 printk("@@ wrq->u pointer = ");
4717 for(i=0;i<wrq->u.data.length;i++){
4718 if(i%10==0) printk("\n");
4719 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
4723 #endif /*JOHN_DEBUG*/
4724 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
4739 static u8 HwRateToMRate90(bool bIsHT, u8 rate)
4745 case DESC90_RATE1M: ret_rate = MGN_1M; break;
4746 case DESC90_RATE2M: ret_rate = MGN_2M; break;
4747 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
4748 case DESC90_RATE11M: ret_rate = MGN_11M; break;
4749 case DESC90_RATE6M: ret_rate = MGN_6M; break;
4750 case DESC90_RATE9M: ret_rate = MGN_9M; break;
4751 case DESC90_RATE12M: ret_rate = MGN_12M; break;
4752 case DESC90_RATE18M: ret_rate = MGN_18M; break;
4753 case DESC90_RATE24M: ret_rate = MGN_24M; break;
4754 case DESC90_RATE36M: ret_rate = MGN_36M; break;
4755 case DESC90_RATE48M: ret_rate = MGN_48M; break;
4756 case DESC90_RATE54M: ret_rate = MGN_54M; break;
4759 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
4765 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
4766 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
4767 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
4768 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
4769 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
4770 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
4771 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
4772 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
4773 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
4774 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
4775 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
4776 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
4777 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
4778 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
4779 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
4780 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
4781 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
4784 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
4792 /* Record the TSF time stamp when receiving a packet */
4793 static void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
4795 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4797 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
4798 stats->mac_time[0] = priv->LastRxDescTSFLow;
4799 stats->mac_time[1] = priv->LastRxDescTSFHigh;
4801 priv->LastRxDescTSFLow = stats->mac_time[0];
4802 priv->LastRxDescTSFHigh = stats->mac_time[1];
4806 static long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
4808 long signal_power; // in dBm.
4810 // Translate to dBm (x=0.5y-95).
4811 signal_power = (long)((signal_strength_index + 1) >> 1);
4814 return signal_power;
4818 * Update Rx signal related information in the packet reeived
4819 * to RxStats. User application can query RxStats to realize
4820 * current Rx signal status.
4822 * In normal operation, user only care about the information of the BSS
4823 * and we shall invoke this function if the packet received is from the BSS.
4826 rtl819x_update_rxsignalstatistics8190pci(
4827 struct r8192_priv * priv,
4828 struct ieee80211_rx_stats * pprevious_stats
4833 //2 <ToDo> Update Rx Statistics (such as signal strength and signal quality).
4836 if(priv->stats.recv_signal_power == 0)
4837 priv->stats.recv_signal_power = pprevious_stats->RecvSignalPower;
4839 // To avoid the past result restricting the statistics sensitivity, weight the current power (5/6) to speed up the
4840 // reaction of smoothed Signal Power.
4841 if(pprevious_stats->RecvSignalPower > priv->stats.recv_signal_power)
4843 else if(pprevious_stats->RecvSignalPower < priv->stats.recv_signal_power)
4846 // We need more correct power of received packets and the "SignalStrength" of RxStats have been beautified or translated,
4847 // so we record the correct power in Dbm here. By Bruce, 2008-03-07.
4849 priv->stats.recv_signal_power = (priv->stats.recv_signal_power * 5 + pprevious_stats->RecvSignalPower + weighting) / 6;
4853 rtl8190_process_cck_rxpathsel(
4854 struct r8192_priv * priv,
4855 struct ieee80211_rx_stats * pprevious_stats
4858 #ifdef RTL8190P //Only 90P 2T4R need to check
4859 char last_cck_adc_pwdb[4]={0,0,0,0};
4861 //cosa add for Rx path selection
4862 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable)
4864 if(pprevious_stats->bIsCCK &&
4865 (pprevious_stats->bPacketToSelf ||pprevious_stats->bPacketBeacon))
4867 /* record the cck adc_pwdb to the sliding window. */
4868 if(priv->stats.cck_adc_pwdb.TotalNum++ >= PHY_RSSI_SLID_WIN_MAX)
4870 priv->stats.cck_adc_pwdb.TotalNum = PHY_RSSI_SLID_WIN_MAX;
4871 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4873 last_cck_adc_pwdb[i] = priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index];
4874 priv->stats.cck_adc_pwdb.TotalVal[i] -= last_cck_adc_pwdb[i];
4877 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4879 priv->stats.cck_adc_pwdb.TotalVal[i] += pprevious_stats->cck_adc_pwdb[i];
4880 priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index] = pprevious_stats->cck_adc_pwdb[i];
4882 priv->stats.cck_adc_pwdb.index++;
4883 if(priv->stats.cck_adc_pwdb.index >= PHY_RSSI_SLID_WIN_MAX)
4884 priv->stats.cck_adc_pwdb.index = 0;
4886 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4888 DM_RxPathSelTable.cck_pwdb_sta[i] = priv->stats.cck_adc_pwdb.TotalVal[i]/priv->stats.cck_adc_pwdb.TotalNum;
4891 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4893 if(pprevious_stats->cck_adc_pwdb[i] > (char)priv->undecorated_smoothed_cck_adc_pwdb[i])
4895 priv->undecorated_smoothed_cck_adc_pwdb[i] =
4896 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
4897 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
4898 priv->undecorated_smoothed_cck_adc_pwdb[i] = priv->undecorated_smoothed_cck_adc_pwdb[i] + 1;
4902 priv->undecorated_smoothed_cck_adc_pwdb[i] =
4903 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
4904 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
4913 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
4914 be a local static. Otherwise, it may increase when we return from S3/S4. The
4915 value will be kept in memory or disk. We must delcare the value in adapter
4916 and it will be reinitialized when return from S3/S4. */
4917 static void rtl8192_process_phyinfo(struct r8192_priv * priv, u8* buffer,struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
4919 bool bcheck = false;
4921 u32 nspatial_stream, tmp_val;
4923 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
4924 static u32 slide_evm_index=0, slide_evm_statistics=0;
4925 static u32 last_rssi=0, last_evm=0;
4926 //cosa add for rx path selection
4927 // static long slide_cck_adc_pwdb_index=0, slide_cck_adc_pwdb_statistics=0;
4928 // static char last_cck_adc_pwdb[4]={0,0,0,0};
4929 //cosa add for beacon rssi smoothing
4930 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
4931 static u32 last_beacon_adc_pwdb=0;
4933 struct ieee80211_hdr_3addr *hdr;
4935 unsigned int frag,seq;
4936 hdr = (struct ieee80211_hdr_3addr *)buffer;
4937 sc = le16_to_cpu(hdr->seq_ctl);
4938 frag = WLAN_GET_SEQ_FRAG(sc);
4939 seq = WLAN_GET_SEQ_SEQ(sc);
4940 //cosa add 04292008 to record the sequence number
4941 pcurrent_stats->Seq_Num = seq;
4943 // Check whether we should take the previous packet into accounting
4945 if(!pprevious_stats->bIsAMPDU)
4947 // if previous packet is not aggregated packet
4951 //remve for that we don't use AMPDU to calculate PWDB,because the reported PWDB of some AP is fault.
4953 // if previous packet is aggregated packet, and current packet
4955 // (2) is the first packet of one AMPDU
4956 // that means the previous packet is the last one aggregated packet
4957 if( !pcurrent_stats->bIsAMPDU || pcurrent_stats->bFirstMPDU)
4962 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
4964 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
4965 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
4966 priv->stats.slide_rssi_total -= last_rssi;
4968 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
4970 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
4971 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
4972 slide_rssi_index = 0;
4974 // <1> Showed on UI for user, in dbm
4975 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
4976 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
4977 pcurrent_stats->rssi = priv->stats.signal_strength;
4979 // If the previous packet does not match the criteria, neglect it
4981 if(!pprevious_stats->bPacketMatchBSSID)
4983 if(!pprevious_stats->bToSelfBA)
4990 rtl8190_process_cck_rxpathsel(priv,pprevious_stats);
4995 priv->stats.num_process_phyinfo++;
4997 /* record the general signal strength to the sliding window. */
4998 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
5000 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
5001 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
5002 priv->stats.slide_rssi_total -= last_rssi;
5004 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
5006 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
5007 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
5008 slide_rssi_index = 0;
5010 // <1> Showed on UI for user, in dbm
5011 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
5012 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
5015 // <2> Showed on UI for engineering
5016 // hardware does not provide rssi information for each rf path in CCK
5017 if(!pprevious_stats->bIsCCK && pprevious_stats->bPacketToSelf)
5019 for (rfpath = RF90_PATH_A; rfpath < RF90_PATH_C; rfpath++)
5021 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
5023 RT_TRACE(COMP_DBG,"Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d \n" ,pprevious_stats->RxMIMOSignalStrength[rfpath] );
5024 //Fixed by Jacken 2008-03-20
5025 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
5027 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
5028 //DbgPrint("MIMO RSSI initialize \n");
5030 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
5032 priv->stats.rx_rssi_percentage[rfpath] =
5033 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5034 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5035 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
5039 priv->stats.rx_rssi_percentage[rfpath] =
5040 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5041 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5043 RT_TRACE(COMP_DBG,"Jacken -> priv->RxStats.RxRSSIPercentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
5051 //cosa add for beacon rssi smoothing by average.
5052 if(pprevious_stats->bPacketBeacon)
5054 /* record the beacon pwdb to the sliding window. */
5055 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5057 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
5058 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
5059 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
5060 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
5061 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
5063 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
5064 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
5065 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
5066 slide_beacon_adc_pwdb_index++;
5067 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5068 slide_beacon_adc_pwdb_index = 0;
5069 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
5070 if(pprevious_stats->RxPWDBAll >= 3)
5071 pprevious_stats->RxPWDBAll -= 3;
5074 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
5075 pprevious_stats->bIsCCK? "CCK": "OFDM",
5076 pprevious_stats->RxPWDBAll);
5078 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5080 if(priv->undecorated_smoothed_pwdb < 0) // initialize
5082 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
5083 //DbgPrint("First pwdb initialize \n");
5086 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
5088 priv->undecorated_smoothed_pwdb =
5089 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5090 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5091 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
5095 priv->undecorated_smoothed_pwdb =
5096 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5097 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5100 //Fixed by Jacken 2008-03-20
5101 if(pPreviousRfd->Status.RxPWDBAll > (u32)pHalData->UndecoratedSmoothedPWDB)
5103 pHalData->UndecoratedSmoothedPWDB =
5104 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5105 pHalData->UndecoratedSmoothedPWDB = pHalData->UndecoratedSmoothedPWDB + 1;
5109 pHalData->UndecoratedSmoothedPWDB =
5110 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5113 rtl819x_update_rxsignalstatistics8190pci(priv,pprevious_stats);
5119 /* record the general EVM to the sliding window. */
5120 if(pprevious_stats->SignalQuality == 0)
5125 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
5126 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
5127 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
5128 last_evm = priv->stats.slide_evm[slide_evm_index];
5129 priv->stats.slide_evm_total -= last_evm;
5132 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
5134 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
5135 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
5136 slide_evm_index = 0;
5138 // <1> Showed on UI for user, in percentage.
5139 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
5140 priv->stats.signal_quality = tmp_val;
5141 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
5142 priv->stats.last_signal_strength_inpercent = tmp_val;
5145 // <2> Showed on UI for engineering
5146 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5148 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
5150 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
5152 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
5154 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
5156 priv->stats.rx_evm_percentage[nspatial_stream] =
5157 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
5158 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
5166 static u8 rtl819x_query_rxpwrpercentage(
5170 if ((antpower <= -100) || (antpower >= 20))
5174 else if (antpower >= 0)
5180 return (100+antpower);
5186 rtl819x_evm_dbtopercentage(
5198 ret_val = 0 - ret_val;
5205 /* We want good-looking for signal strength/quality */
5206 static long rtl819x_signal_scale_mapping(long currsig)
5210 // Step 1. Scale mapping.
5211 if(currsig >= 61 && currsig <= 100)
5213 retsig = 90 + ((currsig - 60) / 4);
5215 else if(currsig >= 41 && currsig <= 60)
5217 retsig = 78 + ((currsig - 40) / 2);
5219 else if(currsig >= 31 && currsig <= 40)
5221 retsig = 66 + (currsig - 30);
5223 else if(currsig >= 21 && currsig <= 30)
5225 retsig = 54 + (currsig - 20);
5227 else if(currsig >= 5 && currsig <= 20)
5229 retsig = 42 + (((currsig - 5) * 2) / 3);
5231 else if(currsig == 4)
5235 else if(currsig == 3)
5239 else if(currsig == 2)
5243 else if(currsig == 1)
5255 static void rtl8192_query_rxphystatus(
5256 struct r8192_priv * priv,
5257 struct ieee80211_rx_stats * pstats,
5258 prx_desc_819x_pci pdesc,
5259 prx_fwinfo_819x_pci pdrvinfo,
5260 struct ieee80211_rx_stats * precord_stats,
5261 bool bpacket_match_bssid,
5262 bool bpacket_toself,
5267 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
5268 phy_sts_ofdm_819xpci_t* pofdm_buf;
5269 phy_sts_cck_819xpci_t * pcck_buf;
5270 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
5272 u8 i,max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
5273 char rx_pwr[4], rx_pwr_all=0;
5274 //long rx_avg_pwr = 0;
5275 char rx_snrX, rx_evmX;
5277 u32 RSSI, total_rssi=0;//, total_evm=0;
5278 // long signal_strength_index = 0;
5282 /* 2007/07/04 MH For OFDM RSSI. For high power or not. */
5283 static u8 check_reg824 = 0;
5284 static u32 reg824_bit9 = 0;
5286 priv->stats.numqry_phystatus++;
5288 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
5290 // Record it for next packet processing
5291 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
5292 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
5293 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
5294 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
5295 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
5296 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
5297 /*2007.08.30 requested by SD3 Jerry */
5298 if(check_reg824 == 0)
5300 reg824_bit9 = rtl8192_QueryBBReg(priv->ieee80211->dev, rFPGA0_XA_HSSIParameter2, 0x200);
5305 prxpkt = (u8*)pdrvinfo;
5307 /* Move pointer to the 16th bytes. Phy status start address. */
5308 prxpkt += sizeof(rx_fwinfo_819x_pci);
5310 /* Initial the cck and ofdm buffer pointer */
5311 pcck_buf = (phy_sts_cck_819xpci_t *)prxpkt;
5312 pofdm_buf = (phy_sts_ofdm_819xpci_t *)prxpkt;
5314 pstats->RxMIMOSignalQuality[0] = -1;
5315 pstats->RxMIMOSignalQuality[1] = -1;
5316 precord_stats->RxMIMOSignalQuality[0] = -1;
5317 precord_stats->RxMIMOSignalQuality[1] = -1;
5322 // (1)Hardware does not provide RSSI for CCK
5326 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5328 u8 report;//, cck_agc_rpt;
5331 char cck_adc_pwdb[4];
5333 priv->stats.numqry_phystatusCCK++;
5335 #ifdef RTL8190P //Only 90P 2T4R need to check
5336 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable && bpacket_match_bssid)
5338 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5340 tmp_pwdb = pcck_buf->adc_pwdb_X[i];
5341 cck_adc_pwdb[i] = (char)tmp_pwdb;
5342 cck_adc_pwdb[i] /= 2;
5343 pstats->cck_adc_pwdb[i] = precord_stats->cck_adc_pwdb[i] = cck_adc_pwdb[i];
5344 //DbgPrint("RF-%d tmp_pwdb = 0x%x, cck_adc_pwdb = %d", i, tmp_pwdb, cck_adc_pwdb[i]);
5351 report = pcck_buf->cck_agc_rpt & 0xc0;
5355 //Fixed by Jacken from Bryant 2008-03-20
5356 //Original value is -38 , -26 , -14 , -2
5357 //Fixed value is -35 , -23 , -11 , 6
5359 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
5362 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
5365 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
5368 rx_pwr_all = 8 - (pcck_buf->cck_agc_rpt & 0x3e);
5374 report = pcck_buf->cck_agc_rpt & 0x60;
5379 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5382 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
5385 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5388 rx_pwr_all = -8 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5393 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5394 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5395 pstats->RecvSignalPower = rx_pwr_all;
5398 // (3) Get Signal Quality (EVM)
5400 if(bpacket_match_bssid)
5404 if(pstats->RxPWDBAll > 40)
5409 sq = pcck_buf->sq_rpt;
5411 if(pcck_buf->sq_rpt > 64)
5413 else if (pcck_buf->sq_rpt < 20)
5416 sq = ((64-sq) * 100) / 44;
5418 pstats->SignalQuality = precord_stats->SignalQuality = sq;
5419 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5420 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5425 priv->stats.numqry_phystatusHT++;
5427 // (1)Get RSSI for HT rate
5429 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5431 // 2008/01/30 MH we will judge RF RX path now.
5432 if (priv->brfpath_rxenable[i])
5437 //Fixed by Jacken from Bryant 2008-03-20
5438 //Original value is 106
5439 #ifdef RTL8190P //Modify by Jacken 2008/03/31
5440 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5442 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 110;
5445 //Get Rx snr value in DB
5446 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5447 rx_snrX = (char)(tmp_rxsnr);
5449 priv->stats.rxSNRdB[i] = (long)rx_snrX;
5451 /* Translate DBM to percentage. */
5452 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5453 if (priv->brfpath_rxenable[i])
5456 /* Record Signal Strength for next packet */
5457 if(bpacket_match_bssid)
5459 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5460 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5466 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5468 //Fixed by Jacken from Bryant 2008-03-20
5469 //Original value is 106
5470 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5471 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5473 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5474 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5475 pstats->RecvSignalPower = rx_pwr_all;
5477 // (3)EVM of HT rate
5479 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5480 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5481 max_spatial_stream = 2; //both spatial stream make sense
5483 max_spatial_stream = 1; //only spatial stream 1 makes sense
5485 for(i=0; i<max_spatial_stream; i++)
5487 tmp_rxevm = pofdm_buf->rxevm_X[i];
5488 rx_evmX = (char)(tmp_rxevm);
5490 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5491 // fill most significant bit to "zero" when doing shifting operation which may change a negative
5492 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5495 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5497 EVM = SignalScaleMapping(EVM);//make it good looking, from 0~100
5499 if(bpacket_match_bssid)
5501 if(i==0) // Fill value in RFD, Get the first spatial stream only
5502 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5503 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5508 /* record rx statistics for debug */
5509 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5510 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5511 if(pdrvinfo->BW) //40M channel
5512 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5514 priv->stats.received_bwtype[0]++;
5517 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5518 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5521 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5526 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u1Byte)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u1Byte)(total_rssi/=RF90_PATH_MAX);
5527 // We can judge RX path number now.
5529 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5534 rtl8192_record_rxdesc_forlateruse(
5535 struct ieee80211_rx_stats * psrc_stats,
5536 struct ieee80211_rx_stats * ptarget_stats
5539 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5540 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5541 //ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5546 static void TranslateRxSignalStuff819xpci(struct net_device *dev,
5547 struct sk_buff *skb,
5548 struct ieee80211_rx_stats * pstats,
5549 prx_desc_819x_pci pdesc,
5550 prx_fwinfo_819x_pci pdrvinfo)
5552 // TODO: We must only check packet for current MAC address. Not finish
5553 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5554 bool bpacket_match_bssid, bpacket_toself;
5555 bool bPacketBeacon=false, bToSelfBA=false;
5556 static struct ieee80211_rx_stats previous_stats;
5557 struct ieee80211_hdr_3addr *hdr;
5560 // Get Signal Quality for only RX data queue (but not command queue)
5565 /* Get MAC frame start address. */
5566 tmp_buf = skb->data;
5568 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5569 fc = le16_to_cpu(hdr->frame_ctl);
5570 type = WLAN_FC_GET_TYPE(fc);
5571 praddr = hdr->addr1;
5573 /* Check if the received packet is acceptabe. */
5574 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5575 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5576 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5577 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5579 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5581 bPacketBeacon = true;
5582 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5584 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5586 if((eqMacAddr(praddr,dev->dev_addr)))
5588 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5592 if(bpacket_match_bssid)
5594 priv->stats.numpacket_matchbssid++;
5597 priv->stats.numpacket_toself++;
5600 // Process PHY information for previous packet (RSSI/PWDB/EVM)
5602 // Because phy information is contained in the last packet of AMPDU only, so driver
5603 // should process phy information of previous packet
5604 rtl8192_process_phyinfo(priv, tmp_buf,&previous_stats, pstats);
5605 rtl8192_query_rxphystatus(priv, pstats, pdesc, pdrvinfo, &previous_stats, bpacket_match_bssid,
5606 bpacket_toself ,bPacketBeacon, bToSelfBA);
5607 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
5612 static void rtl8192_tx_resume(struct net_device *dev)
5614 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5615 struct ieee80211_device *ieee = priv->ieee80211;
5616 struct sk_buff *skb;
5619 for(queue_index = BK_QUEUE; queue_index < TXCMD_QUEUE;queue_index++) {
5620 while((!skb_queue_empty(&ieee->skb_waitQ[queue_index]))&&
5621 (priv->ieee80211->check_nic_enough_desc(dev,queue_index) > 0)) {
5622 /* 1. dequeue the packet from the wait queue */
5623 skb = skb_dequeue(&ieee->skb_waitQ[queue_index]);
5624 /* 2. tx the packet directly */
5625 ieee->softmac_data_hard_start_xmit(skb,dev,0/* rate useless now*/);
5627 if(queue_index!=MGNT_QUEUE) {
5628 ieee->stats.tx_packets++;
5629 ieee->stats.tx_bytes += skb->len;
5636 static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv)
5638 rtl8192_tx_resume(priv->ieee80211->dev);
5641 /* Record the received data rate */
5642 static void UpdateReceivedRateHistogramStatistics8190(
5643 struct net_device *dev,
5644 struct ieee80211_rx_stats* pstats
5647 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5648 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
5650 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
5654 else if(pstats->bICV)
5657 if(pstats->bShortPreamble)
5658 preamble_guardinterval = 1;// short
5660 preamble_guardinterval = 0;// long
5662 switch(pstats->rate)
5667 case MGN_1M: rateIndex = 0; break;
5668 case MGN_2M: rateIndex = 1; break;
5669 case MGN_5_5M: rateIndex = 2; break;
5670 case MGN_11M: rateIndex = 3; break;
5674 case MGN_6M: rateIndex = 4; break;
5675 case MGN_9M: rateIndex = 5; break;
5676 case MGN_12M: rateIndex = 6; break;
5677 case MGN_18M: rateIndex = 7; break;
5678 case MGN_24M: rateIndex = 8; break;
5679 case MGN_36M: rateIndex = 9; break;
5680 case MGN_48M: rateIndex = 10; break;
5681 case MGN_54M: rateIndex = 11; break;
5683 // 11n High throughput rate
5685 case MGN_MCS0: rateIndex = 12; break;
5686 case MGN_MCS1: rateIndex = 13; break;
5687 case MGN_MCS2: rateIndex = 14; break;
5688 case MGN_MCS3: rateIndex = 15; break;
5689 case MGN_MCS4: rateIndex = 16; break;
5690 case MGN_MCS5: rateIndex = 17; break;
5691 case MGN_MCS6: rateIndex = 18; break;
5692 case MGN_MCS7: rateIndex = 19; break;
5693 case MGN_MCS8: rateIndex = 20; break;
5694 case MGN_MCS9: rateIndex = 21; break;
5695 case MGN_MCS10: rateIndex = 22; break;
5696 case MGN_MCS11: rateIndex = 23; break;
5697 case MGN_MCS12: rateIndex = 24; break;
5698 case MGN_MCS13: rateIndex = 25; break;
5699 case MGN_MCS14: rateIndex = 26; break;
5700 case MGN_MCS15: rateIndex = 27; break;
5701 default: rateIndex = 28; break;
5703 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
5704 priv->stats.received_rate_histogram[0][rateIndex]++; //total
5705 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
5708 static void rtl8192_rx(struct net_device *dev)
5710 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5711 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
5712 bool unicast_packet = false;
5713 struct ieee80211_rx_stats stats = {
5717 .freq = IEEE80211_24GHZ_BAND,
5719 unsigned int count = priv->rxringcount;
5721 stats.nic_type = NIC_8192E;
5724 rx_desc_819x_pci *pdesc = &priv->rx_ring[priv->rx_idx];//rx descriptor
5725 struct sk_buff *skb = priv->rx_buf[priv->rx_idx];//rx pkt
5728 /* wait data to be filled by hardware */
5731 stats.bICV = pdesc->ICV;
5732 stats.bCRC = pdesc->CRC32;
5733 stats.bHwError = pdesc->CRC32 | pdesc->ICV;
5735 stats.Length = pdesc->Length;
5736 if(stats.Length < 24)
5737 stats.bHwError |= 1;
5739 if(stats.bHwError) {
5740 stats.bShift = false;
5743 if (pdesc->Length <500)
5744 priv->stats.rxcrcerrmin++;
5745 else if (pdesc->Length >1000)
5746 priv->stats.rxcrcerrmax++;
5748 priv->stats.rxcrcerrmid++;
5752 prx_fwinfo_819x_pci pDrvInfo = NULL;
5753 struct sk_buff *new_skb = dev_alloc_skb(priv->rxbuffersize);
5755 if (unlikely(!new_skb)) {
5759 stats.RxDrvInfoSize = pdesc->RxDrvInfoSize;
5760 stats.RxBufShift = ((pdesc->Shift)&0x03);
5761 stats.Decrypted = !pdesc->SWDec;
5763 pci_dma_sync_single_for_cpu(priv->pdev,
5764 *((dma_addr_t *)skb->cb),
5766 PCI_DMA_FROMDEVICE);
5767 skb_put(skb, pdesc->Length);
5768 pDrvInfo = (rx_fwinfo_819x_pci *)(skb->data + stats.RxBufShift);
5769 skb_reserve(skb, stats.RxDrvInfoSize + stats.RxBufShift);
5771 stats.rate = HwRateToMRate90((bool)pDrvInfo->RxHT, (u8)pDrvInfo->RxRate);
5772 stats.bShortPreamble = pDrvInfo->SPLCP;
5774 /* it is debug only. It should be disabled in released driver.
5775 * 2007.1.11 by Emily
5777 UpdateReceivedRateHistogramStatistics8190(dev, &stats);
5779 stats.bIsAMPDU = (pDrvInfo->PartAggr==1);
5780 stats.bFirstMPDU = (pDrvInfo->PartAggr==1) && (pDrvInfo->FirstAGGR==1);
5782 stats.TimeStampLow = pDrvInfo->TSFL;
5783 stats.TimeStampHigh = read_nic_dword(dev, TSFR+4);
5785 UpdateRxPktTimeStamp8190(dev, &stats);
5788 // Get Total offset of MPDU Frame Body
5790 if((stats.RxBufShift + stats.RxDrvInfoSize) > 0)
5793 stats.RxIs40MHzPacket = pDrvInfo->BW;
5796 TranslateRxSignalStuff819xpci(dev,skb, &stats, pdesc, pDrvInfo);
5799 if(pDrvInfo->FirstAGGR==1 || pDrvInfo->PartAggr == 1)
5800 RT_TRACE(COMP_RXDESC, "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
5801 pDrvInfo->FirstAGGR, pDrvInfo->PartAggr);
5802 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5803 /* rx packets statistics */
5804 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5805 unicast_packet = false;
5807 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5809 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5812 /* unicast packet */
5813 unicast_packet = true;
5816 stats.packetlength = stats.Length-4;
5817 stats.fraglength = stats.packetlength;
5818 stats.fragoffset = 0;
5819 stats.ntotalfrag = 1;
5821 if(!ieee80211_rtl_rx(priv->ieee80211, skb, &stats)){
5822 dev_kfree_skb_any(skb);
5825 if(unicast_packet) {
5826 priv->stats.rxbytesunicast += skb->len;
5830 pci_unmap_single(priv->pdev, *((dma_addr_t *) skb->cb),
5831 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
5834 priv->rx_buf[priv->rx_idx] = skb;
5835 *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev, skb_tail_pointer(skb), priv->rxbuffersize, PCI_DMA_FROMDEVICE);
5840 pdesc->BufferAddress = cpu_to_le32(*((dma_addr_t *)skb->cb));
5842 pdesc->Length = priv->rxbuffersize;
5843 if (priv->rx_idx == priv->rxringcount-1)
5845 priv->rx_idx = (priv->rx_idx + 1) % priv->rxringcount;
5850 static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
5852 rtl8192_rx(priv->ieee80211->dev);
5854 write_nic_dword(priv->ieee80211->dev, INTA_MASK,read_nic_dword(priv->ieee80211->dev, INTA_MASK) | IMR_RDU);
5857 static const struct net_device_ops rtl8192_netdev_ops = {
5858 .ndo_open = rtl8192_open,
5859 .ndo_stop = rtl8192_close,
5860 .ndo_tx_timeout = tx_timeout,
5861 .ndo_do_ioctl = rtl8192_ioctl,
5862 .ndo_set_multicast_list = r8192_set_multicast,
5863 .ndo_set_mac_address = r8192_set_mac_adr,
5864 .ndo_start_xmit = ieee80211_rtl_xmit,
5867 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
5868 const struct pci_device_id *id)
5870 unsigned long ioaddr = 0;
5871 struct net_device *dev = NULL;
5872 struct r8192_priv *priv= NULL;
5876 #ifdef CONFIG_RTL8192_IO_MAP
5877 unsigned long pio_start, pio_len, pio_flags;
5879 unsigned long pmem_start, pmem_len, pmem_flags;
5880 #endif //end #ifdef RTL_IO_MAP
5882 RT_TRACE(COMP_INIT,"Configuring chip resources");
5884 if( pci_enable_device (pdev) ){
5885 RT_TRACE(COMP_ERR,"Failed to enable PCI device");
5889 pci_set_master(pdev);
5890 //pci_set_wmi(pdev);
5891 pci_set_dma_mask(pdev, 0xffffff00ULL);
5892 pci_set_consistent_dma_mask(pdev,0xffffff00ULL);
5893 dev = alloc_ieee80211(sizeof(struct r8192_priv));
5899 pci_set_drvdata(pdev, dev);
5900 SET_NETDEV_DEV(dev, &pdev->dev);
5901 priv = ieee80211_priv(dev);
5902 priv->ieee80211 = netdev_priv(dev);
5904 if((pdev->subsystem_vendor == PCI_VENDOR_ID_DLINK)&&(pdev->subsystem_device == 0x3304)){
5905 priv->ieee80211->bSupportRemoteWakeUp = 1;
5908 priv->ieee80211->bSupportRemoteWakeUp = 0;
5911 #ifdef CONFIG_RTL8192_IO_MAP
5913 pio_start = (unsigned long)pci_resource_start (pdev, 0);
5914 pio_len = (unsigned long)pci_resource_len (pdev, 0);
5915 pio_flags = (unsigned long)pci_resource_flags (pdev, 0);
5917 if (!(pio_flags & IORESOURCE_IO)) {
5918 RT_TRACE(COMP_ERR,"region #0 not a PIO resource, aborting");
5922 //DMESG("IO space @ 0x%08lx", pio_start );
5923 if( ! request_region( pio_start, pio_len, RTL819xE_MODULE_NAME ) ){
5924 RT_TRACE(COMP_ERR,"request_region failed!");
5929 dev->base_addr = ioaddr; // device I/O address
5933 pmem_start = pci_resource_start(pdev, 1);
5934 pmem_len = pci_resource_len(pdev, 1);
5935 pmem_flags = pci_resource_flags (pdev, 1);
5937 if (!(pmem_flags & IORESOURCE_MEM)) {
5938 RT_TRACE(COMP_ERR,"region #1 not a MMIO resource, aborting");
5942 //DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
5943 if( ! request_mem_region(pmem_start, pmem_len, RTL819xE_MODULE_NAME)) {
5944 RT_TRACE(COMP_ERR,"request_mem_region failed!");
5949 ioaddr = (unsigned long)ioremap_nocache( pmem_start, pmem_len);
5950 if( ioaddr == (unsigned long)NULL ){
5951 RT_TRACE(COMP_ERR,"ioremap failed!");
5952 // release_mem_region( pmem_start, pmem_len );
5956 dev->mem_start = ioaddr; // shared mem start
5957 dev->mem_end = ioaddr + pci_resource_len(pdev, 0); // shared mem end
5959 #endif //end #ifdef RTL_IO_MAP
5961 /* We disable the RETRY_TIMEOUT register (0x41) to keep
5962 * PCI Tx retries from interfering with C3 CPU state */
5963 pci_write_config_byte(pdev, 0x41, 0x00);
5966 pci_read_config_byte(pdev, 0x05, &unit);
5967 pci_write_config_byte(pdev, 0x05, unit & (~0x04));
5969 dev->irq = pdev->irq;
5972 dev->netdev_ops = &rtl8192_netdev_ops;
5974 dev->open = rtl8192_open;
5975 dev->stop = rtl8192_close;
5976 //dev->hard_start_xmit = rtl8192_8023_hard_start_xmit;
5977 dev->tx_timeout = tx_timeout;
5978 //dev->wireless_handlers = &r8192_wx_handlers_def;
5979 dev->do_ioctl = rtl8192_ioctl;
5980 dev->set_multicast_list = r8192_set_multicast;
5981 dev->set_mac_address = r8192_set_mac_adr;
5984 //DMESG("Oops: i'm coming\n");
5985 #if WIRELESS_EXT >= 12
5986 #if WIRELESS_EXT < 17
5987 dev->get_wireless_stats = r8192_get_wireless_stats;
5989 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
5991 //dev->get_wireless_stats = r8192_get_wireless_stats;
5992 dev->type=ARPHRD_ETHER;
5994 dev->watchdog_timeo = HZ*3; //modified by john, 0805
5996 if (dev_alloc_name(dev, ifname) < 0){
5997 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
5998 strcpy(ifname, "wlan%d");
5999 dev_alloc_name(dev, ifname);
6002 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
6003 if(rtl8192_init(dev)!=0){
6004 RT_TRACE(COMP_ERR, "Initialization failed");
6008 netif_carrier_off(dev);
6009 netif_stop_queue(dev);
6011 register_netdev(dev);
6012 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
6013 rtl8192_proc_init_one(dev);
6016 RT_TRACE(COMP_INIT, "Driver probe completed\n");
6021 #ifdef CONFIG_RTL8180_IO_MAP
6023 if( dev->base_addr != 0 ){
6025 release_region(dev->base_addr,
6026 pci_resource_len(pdev, 0) );
6029 if( dev->mem_start != (unsigned long)NULL ){
6030 iounmap( (void *)dev->mem_start );
6031 release_mem_region( pci_resource_start(pdev, 1),
6032 pci_resource_len(pdev, 1) );
6034 #endif //end #ifdef RTL_IO_MAP
6040 free_irq(dev->irq, dev);
6043 free_ieee80211(dev);
6047 pci_disable_device(pdev);
6049 DMESG("wlan driver load failed\n");
6050 pci_set_drvdata(pdev, NULL);
6055 /* detach all the work and timer structure declared or inititialized
6056 * in r8192_init function.
6058 static void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
6060 /* call cancel_work_sync instead of cancel_delayed_work if and only if Linux_version_code
6061 * is or is newer than 2.6.20 and work structure is defined to be struct work_struct.
6062 * Otherwise call cancel_delayed_work is enough.
6063 * FIXME (2.6.20 should 2.6.22, work_struct should not cancel)
6065 cancel_delayed_work(&priv->watch_dog_wq);
6066 cancel_delayed_work(&priv->update_beacon_wq);
6067 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
6068 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
6070 cancel_delayed_work(&priv->gpio_change_rf_wq);
6072 cancel_work_sync(&priv->reset_wq);
6073 cancel_work_sync(&priv->qos_activate);
6074 //cancel_work_sync(&priv->SetBWModeWorkItem);
6075 //cancel_work_sync(&priv->SwChnlWorkItem);
6080 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev)
6082 struct net_device *dev = pci_get_drvdata(pdev);
6083 struct r8192_priv *priv ;
6087 unregister_netdev(dev);
6089 priv=ieee80211_priv(dev);
6091 rtl8192_proc_remove_one(dev);
6094 if (priv->pFirmware)
6096 vfree(priv->pFirmware);
6097 priv->pFirmware = NULL;
6099 // priv->rf_close(dev);
6100 // rtl8192_usb_deleteendpoints(dev);
6101 destroy_workqueue(priv->priv_wq);
6102 /* redundant with rtl8192_down */
6103 // rtl8192_irq_disable(dev);
6104 // rtl8192_reset(dev);
6108 /* free tx/rx rings */
6109 rtl8192_free_rx_ring(dev);
6110 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
6111 rtl8192_free_tx_ring(dev, i);
6116 printk("Freeing irq %d\n",dev->irq);
6117 free_irq(dev->irq, dev);
6124 // free_beacon_desc_ring(dev,priv->txbeaconcount);
6126 #ifdef CONFIG_RTL8180_IO_MAP
6128 if( dev->base_addr != 0 ){
6130 release_region(dev->base_addr,
6131 pci_resource_len(pdev, 0) );
6134 if( dev->mem_start != (unsigned long)NULL ){
6135 iounmap( (void *)dev->mem_start );
6136 release_mem_region( pci_resource_start(pdev, 1),
6137 pci_resource_len(pdev, 1) );
6139 #endif /*end #ifdef RTL_IO_MAP*/
6140 free_ieee80211(dev);
6144 pci_disable_device(pdev);
6145 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
6148 extern int ieee80211_rtl_init(void);
6149 extern void ieee80211_rtl_exit(void);
6151 static int __init rtl8192_pci_module_init(void)
6155 retval = ieee80211_rtl_init();
6159 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
6160 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
6161 RT_TRACE(COMP_INIT, "Initializing module");
6162 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
6163 rtl8192_proc_module_init();
6164 if(0!=pci_register_driver(&rtl8192_pci_driver))
6166 DMESG("No device found");
6167 /*pci_unregister_driver (&rtl8192_pci_driver);*/
6174 static void __exit rtl8192_pci_module_exit(void)
6176 pci_unregister_driver(&rtl8192_pci_driver);
6178 RT_TRACE(COMP_DOWN, "Exiting");
6179 rtl8192_proc_module_remove();
6180 ieee80211_rtl_exit();
6183 //warning message WB
6184 static irqreturn_t rtl8192_interrupt(int irq, void *netdev)
6186 struct net_device *dev = (struct net_device *) netdev;
6187 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6188 unsigned long flags;
6190 /* We should return IRQ_NONE, but for now let me keep this */
6191 if(priv->irq_enabled == 0){
6195 spin_lock_irqsave(&priv->irq_th_lock,flags);
6199 inta = read_nic_dword(dev, ISR);// & priv->IntrMask;
6200 write_nic_dword(dev,ISR,inta); // reset int situation
6202 priv->stats.shints++;
6203 //DMESG("Enter interrupt, ISR value = 0x%08x", inta);
6205 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6208 most probably we can safely return IRQ_NONE,
6209 but for now is better to avoid problems
6215 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6221 DMESG("NIC irq %x",inta);
6223 //priv->irqpending = inta;
6226 if(!netif_running(dev)) {
6227 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6231 if(inta & IMR_TIMEOUT0){
6232 // write_nic_dword(dev, TimerInt, 0);
6233 //DMESG("=================>waking up");
6234 // rtl8180_hw_wakeup(dev);
6237 if(inta & IMR_TBDOK){
6238 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6239 rtl8192_tx_isr(dev, BEACON_QUEUE);
6240 priv->stats.txbeaconokint++;
6243 if(inta & IMR_TBDER){
6244 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6245 rtl8192_tx_isr(dev, BEACON_QUEUE);
6246 priv->stats.txbeaconerr++;
6249 if(inta & IMR_MGNTDOK ) {
6250 RT_TRACE(COMP_INTR, "Manage ok interrupt!\n");
6251 priv->stats.txmanageokint++;
6252 rtl8192_tx_isr(dev,MGNT_QUEUE);
6256 if(inta & IMR_COMDOK)
6258 priv->stats.txcmdpktokint++;
6259 rtl8192_tx_isr(dev,TXCMD_QUEUE);
6264 DMESG("Frame arrived !");
6266 priv->stats.rxint++;
6267 tasklet_schedule(&priv->irq_rx_tasklet);
6270 if(inta & IMR_BcnInt) {
6271 RT_TRACE(COMP_INTR, "prepare beacon for interrupt!\n");
6272 tasklet_schedule(&priv->irq_prepare_beacon_tasklet);
6276 RT_TRACE(COMP_INTR, "rx descriptor unavailable!\n");
6277 priv->stats.rxrdu++;
6278 /* reset int situation */
6279 write_nic_dword(dev,INTA_MASK,read_nic_dword(dev, INTA_MASK) & ~IMR_RDU);
6280 tasklet_schedule(&priv->irq_rx_tasklet);
6283 if(inta & IMR_RXFOVW){
6284 RT_TRACE(COMP_INTR, "rx overflow !\n");
6285 priv->stats.rxoverflow++;
6286 tasklet_schedule(&priv->irq_rx_tasklet);
6289 if(inta & IMR_TXFOVW) priv->stats.txoverflow++;
6291 if(inta & IMR_BKDOK){
6292 RT_TRACE(COMP_INTR, "BK Tx OK interrupt!\n");
6293 priv->stats.txbkokint++;
6294 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6295 rtl8192_tx_isr(dev,BK_QUEUE);
6296 rtl8192_try_wake_queue(dev, BK_QUEUE);
6299 if(inta & IMR_BEDOK){
6300 RT_TRACE(COMP_INTR, "BE TX OK interrupt!\n");
6301 priv->stats.txbeokint++;
6302 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6303 rtl8192_tx_isr(dev,BE_QUEUE);
6304 rtl8192_try_wake_queue(dev, BE_QUEUE);
6307 if(inta & IMR_VIDOK){
6308 RT_TRACE(COMP_INTR, "VI TX OK interrupt!\n");
6309 priv->stats.txviokint++;
6310 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6311 rtl8192_tx_isr(dev,VI_QUEUE);
6312 rtl8192_try_wake_queue(dev, VI_QUEUE);
6315 if(inta & IMR_VODOK){
6316 priv->stats.txvookint++;
6317 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6318 rtl8192_tx_isr(dev,VO_QUEUE);
6319 rtl8192_try_wake_queue(dev, VO_QUEUE);
6322 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6327 static void rtl8192_try_wake_queue(struct net_device *dev, int pri)
6332 void EnableHWSecurityConfig8192(struct net_device *dev)
6334 u8 SECR_value = 0x0;
6335 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6336 struct ieee80211_device* ieee = priv->ieee80211;
6338 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
6340 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
6342 SECR_value |= SCR_RxUseDK;
6343 SECR_value |= SCR_TxUseDK;
6345 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
6347 SECR_value |= SCR_RxUseDK;
6348 SECR_value |= SCR_TxUseDK;
6353 //add HWSec active enable here.
6354 //default using hwsec. when peer AP is in N mode only and pairwise_key_type is none_aes(which HT_IOT_ACT_PURE_N_MODE indicates it), use software security. when peer AP is in b,g,n mode mixed and pairwise_key_type is none_aes, use g mode hw security. WB on 2008.7.4
6355 ieee->hwsec_active = 1;
6357 if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep)//!ieee->hwsec_support) //add hwsec_support flag to totol control hw_sec on/off
6359 ieee->hwsec_active = 0;
6360 SECR_value &= ~SCR_RxDecEnable;
6363 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__,
6364 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
6366 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
6370 #define TOTAL_CAM_ENTRY 32
6371 //#define CAM_CONTENT_COUNT 8
6372 void setKey( struct net_device *dev,
6380 u32 TargetCommand = 0;
6381 u32 TargetContent = 0;
6385 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6386 RT_RF_POWER_STATE rtState;
6387 rtState = priv->ieee80211->eRFPowerState;
6388 if(priv->ieee80211->PowerSaveControl.bInactivePs){
6389 if(rtState == eRfOff){
6390 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
6392 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
6393 //up(&priv->wx_sem);
6397 down(&priv->ieee80211->ips_sem);
6399 up(&priv->ieee80211->ips_sem);
6403 priv->ieee80211->is_set_key = true;
6405 if (EntryNo >= TOTAL_CAM_ENTRY)
6406 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
6408 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
6411 usConfig |= BIT15 | (KeyType<<2);
6413 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
6414 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
6417 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
6418 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
6419 TargetCommand |= BIT31|BIT16;
6421 if(i==0){//MAC|Config
6422 TargetContent = (u32)(*(MacAddr+0)) << 16|
6423 (u32)(*(MacAddr+1)) << 24|
6426 write_nic_dword(dev, WCAMI, TargetContent);
6427 write_nic_dword(dev, RWCAM, TargetCommand);
6428 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6431 TargetContent = (u32)(*(MacAddr+2)) |
6432 (u32)(*(MacAddr+3)) << 8|
6433 (u32)(*(MacAddr+4)) << 16|
6434 (u32)(*(MacAddr+5)) << 24;
6435 write_nic_dword(dev, WCAMI, TargetContent);
6436 write_nic_dword(dev, RWCAM, TargetCommand);
6438 else { //Key Material
6439 if(KeyContent != NULL)
6441 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6442 write_nic_dword(dev, RWCAM, TargetCommand);
6446 RT_TRACE(COMP_SEC,"=========>after set key, usconfig:%x\n", usConfig);
6449 bool NicIFEnableNIC(struct net_device* dev)
6451 RT_STATUS init_status = RT_STATUS_SUCCESS;
6452 struct r8192_priv* priv = ieee80211_priv(dev);
6453 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
6457 RT_TRACE(COMP_ERR, "ERR!!! %s(): Driver is already down!\n",__FUNCTION__);
6458 priv->bdisable_nic = false; //YJ,add,091111
6461 // <1> Reset memory: descriptor, buffer,..
6462 //NicIFResetMemory(Adapter);
6464 // <2> Enable Adapter
6465 //priv->bfirst_init = true;
6466 init_status = rtl8192_adapter_start(dev);
6467 if (init_status != RT_STATUS_SUCCESS) {
6468 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
6469 priv->bdisable_nic = false; //YJ,add,091111
6472 //printk("start adapter finished\n");
6473 RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
6474 //priv->bfirst_init = false;
6476 // <3> Enable Interrupt
6477 rtl8192_irq_enable(dev);
6478 priv->bdisable_nic = false;
6480 return (init_status == RT_STATUS_SUCCESS);
6483 bool NicIFDisableNIC(struct net_device* dev)
6486 struct r8192_priv* priv = ieee80211_priv(dev);
6488 // <1> Disable Interrupt
6490 priv->bdisable_nic = true; //YJ,move,091109
6491 tmp_state = priv->ieee80211->state;
6493 ieee80211_softmac_stop_protocol(priv->ieee80211, false);
6495 priv->ieee80211->state = tmp_state;
6496 rtl8192_cancel_deferred_work(priv);
6497 rtl8192_irq_disable(dev);
6498 // <2> Stop all timer
6500 // <3> Disable Adapter
6501 rtl8192_halt_adapter(dev, false);
6502 // priv->bdisable_nic = true;
6507 module_init(rtl8192_pci_module_init);
6508 module_exit(rtl8192_pci_module_exit);