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 const struct pci_device_id rtl8192_pci_id_tbl[] __devinitdata = {
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 = (rt_firmware*)vmalloc(sizeof(rt_firmware));
2287 if (priv->pFirmware)
2288 memset(priv->pFirmware, 0, sizeof(rt_firmware));
2290 /* rx related queue */
2291 skb_queue_head_init(&priv->rx_queue);
2292 skb_queue_head_init(&priv->skb_queue);
2294 /* Tx related queue */
2295 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2296 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2298 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2299 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2301 priv->rf_set_chan = rtl8192_phy_SwChnl;
2304 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2306 spin_lock_init(&priv->tx_lock);
2307 spin_lock_init(&priv->irq_lock);//added by thomas
2308 spin_lock_init(&priv->irq_th_lock);
2309 spin_lock_init(&priv->rf_ps_lock);
2310 spin_lock_init(&priv->ps_lock);
2311 //spin_lock_init(&priv->rf_lock);
2312 sema_init(&priv->wx_sem,1);
2313 sema_init(&priv->rf_sem,1);
2314 mutex_init(&priv->mutex);
2317 /* init tasklet and wait_queue here */
2318 #define DRV_NAME "wlan0"
2319 static void rtl8192_init_priv_task(struct net_device* dev)
2321 struct r8192_priv *priv = ieee80211_priv(dev);
2323 #ifdef PF_SYNCTHREAD
2324 priv->priv_wq = create_workqueue(DRV_NAME,0);
2326 priv->priv_wq = create_workqueue(DRV_NAME);
2330 INIT_WORK(&priv->ieee80211->ips_leave_wq, (void*)IPSLeave_wq);
2333 // INIT_WORK(&priv->reset_wq, (void(*)(void*)) rtl8192_restart);
2334 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2335 // INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2336 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2337 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2338 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2339 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2340 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2341 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2342 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2343 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq);
2344 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq);
2346 tasklet_init(&priv->irq_rx_tasklet,
2347 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2348 (unsigned long)priv);
2349 tasklet_init(&priv->irq_tx_tasklet,
2350 (void(*)(unsigned long))rtl8192_irq_tx_tasklet,
2351 (unsigned long)priv);
2352 tasklet_init(&priv->irq_prepare_beacon_tasklet,
2353 (void(*)(unsigned long))rtl8192_prepare_beacon,
2354 (unsigned long)priv);
2357 static void rtl8192_get_eeprom_size(struct net_device* dev)
2360 struct r8192_priv *priv = ieee80211_priv(dev);
2361 RT_TRACE(COMP_INIT, "===========>%s()\n", __FUNCTION__);
2362 curCR = read_nic_dword(dev, EPROM_CMD);
2363 RT_TRACE(COMP_INIT, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD, curCR);
2364 //whether need I consider BIT5?
2365 priv->epromtype = (curCR & EPROM_CMD_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2366 RT_TRACE(COMP_INIT, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2370 * used to swap endian. as ntohl & htonl are not
2371 * neccessary to swap endian, so use this instead.
2373 static inline u16 endian_swap(u16* data)
2376 *data = (tmp >> 8) | (tmp << 8);
2381 * Adapter->EEPROMAddressSize should be set before this function call.
2382 * EEPROM address size can be got through GetEEPROMSize8185()
2384 static void rtl8192_read_eeprom_info(struct net_device* dev)
2386 struct r8192_priv *priv = ieee80211_priv(dev);
2390 u8 ICVer8192, ICVer8256;
2392 u16 i,usValue, IC_Version;
2396 u8 EepromTxPower[100];
2398 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01};
2399 RT_TRACE(COMP_INIT, "====> rtl8192_read_eeprom_info\n");
2402 // TODO: I don't know if we need to apply EF function to EEPROM read function
2404 //2 Read EEPROM ID to make sure autoload is success
2405 EEPROMId = eprom_read(dev, 0);
2406 if( EEPROMId != RTL8190_EEPROM_ID )
2408 RT_TRACE(COMP_ERR, "EEPROM ID is invalid:%x, %x\n", EEPROMId, RTL8190_EEPROM_ID);
2409 priv->AutoloadFailFlag=true;
2413 priv->AutoloadFailFlag=false;
2417 // Assign Chip Version ID
2419 // Read IC Version && Channel Plan
2420 if(!priv->AutoloadFailFlag)
2423 priv->eeprom_vid = eprom_read(dev, (EEPROM_VID >> 1));
2424 priv->eeprom_did = eprom_read(dev, (EEPROM_DID >> 1));
2426 usValue = eprom_read(dev, (u16)(EEPROM_Customer_ID>>1)) >> 8 ;
2427 priv->eeprom_CustomerID = (u8)( usValue & 0xff);
2428 usValue = eprom_read(dev, (EEPROM_ICVersion_ChannelPlan>>1));
2429 priv->eeprom_ChannelPlan = usValue&0xff;
2430 IC_Version = ((usValue&0xff00)>>8);
2433 priv->card_8192_version = (VERSION_8190)(IC_Version);
2436 ICVer8192 = (IC_Version&0xf); //bit0~3; 1:A cut, 2:B cut, 3:C cut...
2437 ICVer8256 = ((IC_Version&0xf0)>>4);//bit4~6, bit7 reserved for other RF chip; 1:A cut, 2:B cut, 3:C cut...
2438 RT_TRACE(COMP_INIT, "\nICVer8192 = 0x%x\n", ICVer8192);
2439 RT_TRACE(COMP_INIT, "\nICVer8256 = 0x%x\n", ICVer8256);
2440 if(ICVer8192 == 0x2) //B-cut
2442 if(ICVer8256 == 0x5) //E-cut
2443 priv->card_8192_version= VERSION_8190_BE;
2447 switch(priv->card_8192_version)
2449 case VERSION_8190_BD:
2450 case VERSION_8190_BE:
2453 priv->card_8192_version = VERSION_8190_BD;
2456 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", priv->card_8192_version);
2460 priv->card_8192_version = VERSION_8190_BD;
2461 priv->eeprom_vid = 0;
2462 priv->eeprom_did = 0;
2463 priv->eeprom_CustomerID = 0;
2464 priv->eeprom_ChannelPlan = 0;
2465 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", 0xff);
2468 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
2469 RT_TRACE(COMP_INIT, "EEPROM DID = 0x%4x\n", priv->eeprom_did);
2470 RT_TRACE(COMP_INIT,"EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
2472 //2 Read Permanent MAC address
2473 if(!priv->AutoloadFailFlag)
2475 for(i = 0; i < 6; i += 2)
2477 usValue = eprom_read(dev, (u16) ((EEPROM_NODE_ADDRESS_BYTE_0+i)>>1));
2478 *(u16*)(&dev->dev_addr[i]) = usValue;
2481 // when auto load failed, the last address byte set to be a random one.
2482 // added by david woo.2007/11/7
2483 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2486 RT_TRACE(COMP_INIT, "Permanent Address = %pM\n", dev->dev_addr);
2488 //2 TX Power Check EEPROM Fail or not
2489 if(priv->card_8192_version > VERSION_8190_BD) {
2490 priv->bTXPowerDataReadFromEEPORM = true;
2492 priv->bTXPowerDataReadFromEEPORM = false;
2495 // 2007/11/15 MH 8190PCI Default=2T4R, 8192PCIE default=1T2R
2496 priv->rf_type = RTL819X_DEFAULT_RF_TYPE;
2498 if(priv->card_8192_version > VERSION_8190_BD)
2500 // Read RF-indication and Tx Power gain index diff of legacy to HT OFDM rate.
2501 if(!priv->AutoloadFailFlag)
2503 tempval = (eprom_read(dev, (EEPROM_RFInd_PowerDiff>>1))) & 0xff;
2504 priv->EEPROMLegacyHTTxPowerDiff = tempval & 0xf; // bit[3:0]
2506 if (tempval&0x80) //RF-indication, bit[7]
2507 priv->rf_type = RF_1T2R;
2509 priv->rf_type = RF_2T4R;
2513 priv->EEPROMLegacyHTTxPowerDiff = EEPROM_Default_LegacyHTTxPowerDiff;
2515 RT_TRACE(COMP_INIT, "EEPROMLegacyHTTxPowerDiff = %d\n",
2516 priv->EEPROMLegacyHTTxPowerDiff);
2518 // Read ThermalMeter from EEPROM
2519 if(!priv->AutoloadFailFlag)
2521 priv->EEPROMThermalMeter = (u8)(((eprom_read(dev, (EEPROM_ThermalMeter>>1))) & 0xff00)>>8);
2525 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2527 RT_TRACE(COMP_INIT, "ThermalMeter = %d\n", priv->EEPROMThermalMeter);
2528 //vivi, for tx power track
2529 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2531 if(priv->epromtype == EPROM_93c46)
2533 // Read antenna tx power offset of B/C/D to A and CrystalCap from EEPROM
2534 if(!priv->AutoloadFailFlag)
2536 usValue = eprom_read(dev, (EEPROM_TxPwDiff_CrystalCap>>1));
2537 priv->EEPROMAntPwDiff = (usValue&0x0fff);
2538 priv->EEPROMCrystalCap = (u8)((usValue&0xf000)>>12);
2542 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2543 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2545 RT_TRACE(COMP_INIT, "EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2546 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2549 // Get per-channel Tx Power Level
2551 for(i=0; i<14; i+=2)
2553 if(!priv->AutoloadFailFlag)
2555 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_CCK+i)>>1) );
2559 usValue = EEPROM_Default_TxPower;
2561 *((u16*)(&priv->EEPROMTxPowerLevelCCK[i])) = usValue;
2562 RT_TRACE(COMP_INIT,"CCK Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK[i]);
2563 RT_TRACE(COMP_INIT, "CCK Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelCCK[i+1]);
2565 for(i=0; i<14; i+=2)
2567 if(!priv->AutoloadFailFlag)
2569 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_OFDM_24G+i)>>1) );
2573 usValue = EEPROM_Default_TxPower;
2575 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[i])) = usValue;
2576 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelOFDM24G[i]);
2577 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelOFDM24G[i+1]);
2580 else if(priv->epromtype== EPROM_93c56)
2583 // Read CrystalCap from EEPROM
2584 if(!priv->AutoloadFailFlag)
2586 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2587 priv->EEPROMCrystalCap = (u8)(((eprom_read(dev, (EEPROM_C56_CrystalCap>>1))) & 0xf000)>>12);
2591 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2592 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2594 RT_TRACE(COMP_INIT,"EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2595 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2597 // Get Tx Power Level by Channel
2598 if(!priv->AutoloadFailFlag)
2600 // Read Tx power of Channel 1 ~ 14 from EEPROM.
2601 for(i = 0; i < 12; i+=2)
2604 offset = EEPROM_C56_RfA_CCK_Chnl1_TxPwIndex + i;
2606 offset = EEPROM_C56_RfC_CCK_Chnl1_TxPwIndex + i - 6;
2607 usValue = eprom_read(dev, (offset>>1));
2608 *((u16*)(&EepromTxPower[i])) = usValue;
2611 for(i = 0; i < 12; i++)
2614 priv->EEPROMRfACCKChnl1TxPwLevel[i] = EepromTxPower[i];
2615 else if ((i >=3 )&&(i <= 5))
2616 priv->EEPROMRfAOfdmChnlTxPwLevel[i-3] = EepromTxPower[i];
2617 else if ((i >=6 )&&(i <= 8))
2618 priv->EEPROMRfCCCKChnl1TxPwLevel[i-6] = EepromTxPower[i];
2620 priv->EEPROMRfCOfdmChnlTxPwLevel[i-9] = EepromTxPower[i];
2625 priv->EEPROMRfACCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2626 priv->EEPROMRfACCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2627 priv->EEPROMRfACCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2629 priv->EEPROMRfAOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2630 priv->EEPROMRfAOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2631 priv->EEPROMRfAOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2633 priv->EEPROMRfCCCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2634 priv->EEPROMRfCCCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2635 priv->EEPROMRfCCCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2637 priv->EEPROMRfCOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2638 priv->EEPROMRfCOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2639 priv->EEPROMRfCOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2641 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[0]);
2642 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[1]);
2643 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[2]);
2644 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[0]);
2645 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[1]);
2646 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[2]);
2647 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[0]);
2648 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[1]);
2649 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[2]);
2650 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[0]);
2651 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[1]);
2652 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[2]);
2657 // Update HAL variables.
2659 if(priv->epromtype == EPROM_93c46)
2663 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK[i];
2664 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[i];
2666 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2667 // Antenna B gain offset to antenna A, bit0~3
2668 priv->AntennaTxPwDiff[0] = (priv->EEPROMAntPwDiff & 0xf);
2669 // Antenna C gain offset to antenna A, bit4~7
2670 priv->AntennaTxPwDiff[1] = ((priv->EEPROMAntPwDiff & 0xf0)>>4);
2671 // Antenna D gain offset to antenna A, bit8~11
2672 priv->AntennaTxPwDiff[2] = ((priv->EEPROMAntPwDiff & 0xf00)>>8);
2673 // CrystalCap, bit12~15
2674 priv->CrystalCap = priv->EEPROMCrystalCap;
2675 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2676 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
2677 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
2679 else if(priv->epromtype == EPROM_93c56)
2681 //char cck_pwr_diff_a=0, cck_pwr_diff_c=0;
2683 //cck_pwr_diff_a = pHalData->EEPROMRfACCKChnl7TxPwLevel - pHalData->EEPROMRfAOfdmChnlTxPwLevel[1];
2684 //cck_pwr_diff_c = pHalData->EEPROMRfCCCKChnl7TxPwLevel - pHalData->EEPROMRfCOfdmChnlTxPwLevel[1];
2685 for(i=0; i<3; i++) // channel 1~3 use the same Tx Power Level.
2687 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[0];
2688 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[0];
2689 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[0];
2690 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[0];
2692 for(i=3; i<9; i++) // channel 4~9 use the same Tx Power Level
2694 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[1];
2695 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[1];
2696 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[1];
2697 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[1];
2699 for(i=9; i<14; i++) // channel 10~14 use the same Tx Power Level
2701 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[2];
2702 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[2];
2703 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[2];
2704 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[2];
2707 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_A[i]);
2709 RT_TRACE(COMP_INIT,"priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_A[i]);
2711 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_C[i]);
2713 RT_TRACE(COMP_INIT, "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_C[i]);
2714 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2715 priv->AntennaTxPwDiff[0] = 0;
2716 priv->AntennaTxPwDiff[1] = 0;
2717 priv->AntennaTxPwDiff[2] = 0;
2718 priv->CrystalCap = priv->EEPROMCrystalCap;
2719 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2720 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
2721 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
2725 if(priv->rf_type == RF_1T2R)
2727 RT_TRACE(COMP_INIT, "\n1T2R config\n");
2729 else if (priv->rf_type == RF_2T4R)
2731 RT_TRACE(COMP_INIT, "\n2T4R config\n");
2734 // 2008/01/16 MH We can only know RF type in the function. So we have to init
2735 // DIG RATR table again.
2736 init_rate_adaptive(dev);
2738 //1 Make a copy for following variables and we can change them if we want
2740 priv->rf_chip= RF_8256;
2742 if(priv->RegChannelPlan == 0xf)
2744 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2748 priv->ChannelPlan = priv->RegChannelPlan;
2752 // Used PID and DID to Set CustomerID
2754 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304 )
2756 priv->CustomerID = RT_CID_DLINK;
2759 switch(priv->eeprom_CustomerID)
2761 case EEPROM_CID_DEFAULT:
2762 priv->CustomerID = RT_CID_DEFAULT;
2764 case EEPROM_CID_CAMEO:
2765 priv->CustomerID = RT_CID_819x_CAMEO;
2767 case EEPROM_CID_RUNTOP:
2768 priv->CustomerID = RT_CID_819x_RUNTOP;
2770 case EEPROM_CID_NetCore:
2771 priv->CustomerID = RT_CID_819x_Netcore;
2773 case EEPROM_CID_TOSHIBA: // Merge by Jacken, 2008/01/31
2774 priv->CustomerID = RT_CID_TOSHIBA;
2775 if(priv->eeprom_ChannelPlan&0x80)
2776 priv->ChannelPlan = priv->eeprom_ChannelPlan&0x7f;
2778 priv->ChannelPlan = 0x0;
2779 RT_TRACE(COMP_INIT, "Toshiba ChannelPlan = 0x%x\n",
2782 case EEPROM_CID_Nettronix:
2783 priv->ScanDelay = 100; //cosa add for scan
2784 priv->CustomerID = RT_CID_Nettronix;
2786 case EEPROM_CID_Pronet:
2787 priv->CustomerID = RT_CID_PRONET;
2789 case EEPROM_CID_DLINK:
2790 priv->CustomerID = RT_CID_DLINK;
2793 case EEPROM_CID_WHQL:
2794 //Adapter->bInHctTest = TRUE;//do not supported
2796 //priv->bSupportTurboMode = FALSE;
2797 //priv->bAutoTurboBy8186 = FALSE;
2799 //pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
2800 //pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
2801 //pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
2805 // value from RegCustomerID
2809 //Avoid the channel plan array overflow, by Bruce, 2007-08-27.
2810 if(priv->ChannelPlan > CHANNEL_PLAN_LEN - 1)
2811 priv->ChannelPlan = 0; //FCC
2813 switch(priv->CustomerID)
2815 case RT_CID_DEFAULT:
2817 priv->LedStrategy = HW_LED;
2820 priv->LedStrategy = SW_LED_MODE1;
2825 case RT_CID_819x_CAMEO:
2826 priv->LedStrategy = SW_LED_MODE2;
2829 case RT_CID_819x_RUNTOP:
2830 priv->LedStrategy = SW_LED_MODE3;
2833 case RT_CID_819x_Netcore:
2834 priv->LedStrategy = SW_LED_MODE4;
2837 case RT_CID_Nettronix:
2838 priv->LedStrategy = SW_LED_MODE5;
2842 priv->LedStrategy = SW_LED_MODE6;
2845 case RT_CID_TOSHIBA: //Modify by Jacken 2008/01/31
2851 priv->LedStrategy = HW_LED;
2854 priv->LedStrategy = SW_LED_MODE1;
2861 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304)
2862 priv->ieee80211->bSupportRemoteWakeUp = true;
2864 priv->ieee80211->bSupportRemoteWakeUp = false;
2867 RT_TRACE(COMP_INIT, "RegChannelPlan(%d)\n", priv->RegChannelPlan);
2868 RT_TRACE(COMP_INIT, "ChannelPlan = %d \n", priv->ChannelPlan);
2869 RT_TRACE(COMP_INIT, "LedStrategy = %d \n", priv->LedStrategy);
2870 RT_TRACE(COMP_TRACE, "<==== ReadAdapterInfo\n");
2876 static short rtl8192_get_channel_map(struct net_device * dev)
2878 struct r8192_priv *priv = ieee80211_priv(dev);
2879 #ifdef ENABLE_DOT11D
2880 if(priv->ChannelPlan> COUNTRY_CODE_GLOBAL_DOMAIN){
2881 printk("rtl8180_init:Error channel plan! Set to default.\n");
2882 priv->ChannelPlan= 0;
2884 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
2886 rtl819x_set_channel_map(priv->ChannelPlan, priv);
2889 //Set Default Channel Plan
2891 DMESG("No channels, aborting");
2895 priv->ChannelPlan= 0;//hikaru
2896 // set channels 1..14 allowed in given locale
2897 for (i=1; i<=14; i++) {
2898 (priv->ieee80211->channel_map)[i] = (u8)(ch & 0x01);
2905 static short rtl8192_init(struct net_device *dev)
2907 struct r8192_priv *priv = ieee80211_priv(dev);
2908 memset(&(priv->stats),0,sizeof(struct Stats));
2909 rtl8192_init_priv_variable(dev);
2910 rtl8192_init_priv_lock(priv);
2911 rtl8192_init_priv_task(dev);
2912 rtl8192_get_eeprom_size(dev);
2913 rtl8192_read_eeprom_info(dev);
2914 rtl8192_get_channel_map(dev);
2916 init_timer(&priv->watch_dog_timer);
2917 priv->watch_dog_timer.data = (unsigned long)dev;
2918 priv->watch_dog_timer.function = watch_dog_timer_callback;
2919 #if defined(IRQF_SHARED)
2920 if(request_irq(dev->irq, (void*)rtl8192_interrupt, IRQF_SHARED, dev->name, dev)){
2922 if(request_irq(dev->irq, (void *)rtl8192_interrupt, SA_SHIRQ, dev->name, dev)){
2924 printk("Error allocating IRQ %d",dev->irq);
2928 printk("IRQ %d",dev->irq);
2930 if(rtl8192_pci_initdescring(dev)!=0){
2931 printk("Endopoints initialization failed");
2935 //rtl8192_rx_enable(dev);
2936 //rtl8192_adapter_start(dev);
2941 * Actually only set RRSR, RATR and BW_OPMODE registers
2942 * not to do all the hw config as its name says
2943 * This part need to modified according to the rate set we filtered
2945 static void rtl8192_hwconfig(struct net_device* dev)
2947 u32 regRATR = 0, regRRSR = 0;
2948 u8 regBwOpMode = 0, regTmp = 0;
2949 struct r8192_priv *priv = ieee80211_priv(dev);
2951 // Set RRSR, RATR, and BW_OPMODE registers
2953 switch(priv->ieee80211->mode)
2955 case WIRELESS_MODE_B:
2956 regBwOpMode = BW_OPMODE_20MHZ;
2957 regRATR = RATE_ALL_CCK;
2958 regRRSR = RATE_ALL_CCK;
2960 case WIRELESS_MODE_A:
2961 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
2962 regRATR = RATE_ALL_OFDM_AG;
2963 regRRSR = RATE_ALL_OFDM_AG;
2965 case WIRELESS_MODE_G:
2966 regBwOpMode = BW_OPMODE_20MHZ;
2967 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2968 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2970 case WIRELESS_MODE_AUTO:
2971 case WIRELESS_MODE_N_24G:
2972 // It support CCK rate by default.
2973 // CCK rate will be filtered out only when associated AP does not support it.
2974 regBwOpMode = BW_OPMODE_20MHZ;
2975 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2976 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2978 case WIRELESS_MODE_N_5G:
2979 regBwOpMode = BW_OPMODE_5G;
2980 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2981 regRRSR = RATE_ALL_OFDM_AG;
2985 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
2988 ratr_value = regRATR;
2989 if (priv->rf_type == RF_1T2R)
2991 ratr_value &= ~(RATE_ALL_OFDM_2SS);
2993 write_nic_dword(dev, RATR0, ratr_value);
2994 write_nic_byte(dev, UFWP, 1);
2996 regTmp = read_nic_byte(dev, 0x313);
2997 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
2998 write_nic_dword(dev, RRSR, regRRSR);
3001 // Set Retry Limit here
3003 write_nic_word(dev, RETRY_LIMIT,
3004 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT |
3005 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3006 // Set Contention Window here
3010 // Set Tx Antenna including Feedback control
3012 // Set Auto Rate fallback control
3018 static RT_STATUS rtl8192_adapter_start(struct net_device *dev)
3020 struct r8192_priv *priv = ieee80211_priv(dev);
3021 // struct ieee80211_device *ieee = priv->ieee80211;
3023 RT_STATUS rtStatus = RT_STATUS_SUCCESS;
3027 u8 ICVersion,SwitchingRegulatorOutput;
3029 bool bfirmwareok = true;
3033 u32 tmpRegA, tmpRegC, TempCCk;
3036 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3037 priv->being_init_adapter = true;
3038 rtl8192_pci_resetdescring(dev);
3039 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
3040 priv->Rf_Mode = RF_OP_By_SW_3wire;
3043 if(priv->ResetProgress == RESET_TYPE_NORESET)
3045 write_nic_byte(dev, ANAPAR, 0x37);
3046 // Accordign to designer's explain, LBUS active will never > 10ms. We delay 10ms
3047 // Joseph increae the time to prevent firmware download fail
3051 //PlatformSleepUs(10000);
3052 // For any kind of InitializeAdapter process, we shall use system now!!
3053 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3055 // Set to eRfoff in order not to count receive count.
3056 if(priv->RegRfOff == TRUE)
3057 priv->ieee80211->eRFPowerState = eRfOff;
3060 //3 //Config CPUReset Register
3062 //3 Firmware Reset Or Not
3063 ulRegRead = read_nic_dword(dev, CPU_GEN);
3064 if(priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3065 { //called from MPInitialized. do nothing
3066 ulRegRead |= CPU_GEN_SYSTEM_RESET;
3067 }else if(priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3068 ulRegRead |= CPU_GEN_FIRMWARE_RESET; // Called from MPReset
3070 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3073 //2008.06.03, for WOL 90 hw bug
3074 ulRegRead &= (~(CPU_GEN_GPIO_UART));
3077 write_nic_dword(dev, CPU_GEN, ulRegRead);
3083 //3 //Fix the issue of E-cut high temperature issue
3086 ICVersion = read_nic_byte(dev, IC_VERRSION);
3087 if(ICVersion >= 0x4) //E-cut only
3089 // HW SD suggest that we should not wirte this register too often, so driver
3090 // should readback this register. This register will be modified only when
3092 SwitchingRegulatorOutput = read_nic_byte(dev, SWREGULATOR);
3093 if(SwitchingRegulatorOutput != 0xb8)
3095 write_nic_byte(dev, SWREGULATOR, 0xa8);
3097 write_nic_byte(dev, SWREGULATOR, 0xb8);
3104 //3// Initialize BB before MAC
3106 RT_TRACE(COMP_INIT, "BB Config Start!\n");
3107 rtStatus = rtl8192_BBConfig(dev);
3108 if(rtStatus != RT_STATUS_SUCCESS)
3110 RT_TRACE(COMP_ERR, "BB Config failed\n");
3113 RT_TRACE(COMP_INIT,"BB Config Finished!\n");
3115 //3//Set Loopback mode or Normal mode
3117 //2006.12.13 by emily. Note!We should not merge these two CPU_GEN register writings
3118 // because setting of System_Reset bit reset MAC to default transmission mode.
3119 //Loopback mode or not
3120 priv->LoopbackMode = RTL819X_NO_LOOPBACK;
3121 //priv->LoopbackMode = RTL819X_MAC_LOOPBACK;
3122 if(priv->ResetProgress == RESET_TYPE_NORESET)
3124 ulRegRead = read_nic_dword(dev, CPU_GEN);
3125 if(priv->LoopbackMode == RTL819X_NO_LOOPBACK)
3127 ulRegRead = ((ulRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3129 else if (priv->LoopbackMode == RTL819X_MAC_LOOPBACK )
3131 ulRegRead |= CPU_CCK_LOOPBACK;
3135 RT_TRACE(COMP_ERR,"Serious error: wrong loopback mode setting\n");
3138 //2008.06.03, for WOL
3139 //ulRegRead &= (~(CPU_GEN_GPIO_UART));
3140 write_nic_dword(dev, CPU_GEN, ulRegRead);
3142 // 2006.11.29. After reset cpu, we sholud wait for a second, otherwise, it may fail to write registers. Emily
3145 //3Set Hardware(Do nothing now)
3146 rtl8192_hwconfig(dev);
3147 //2=======================================================
3148 // Common Setting for all of the FPGA platform. (part 1)
3149 //2=======================================================
3150 // If there is changes, please make sure it applies to all of the FPGA version
3152 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3156 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3157 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) |
3161 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3162 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) ));
3166 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3167 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3169 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3171 //3 Initialize Number of Reserved Pages in Firmware Queue
3173 if(priv->bInHctTest)
3175 PlatformEFIOWrite4Byte(Adapter, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK_DTM << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3176 NUM_OF_PAGE_IN_FW_QUEUE_BE_DTM << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3177 NUM_OF_PAGE_IN_FW_QUEUE_VI_DTM << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3178 NUM_OF_PAGE_IN_FW_QUEUE_VO_DTM <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3179 PlatformEFIOWrite4Byte(Adapter, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3180 PlatformEFIOWrite4Byte(Adapter, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3181 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3182 NUM_OF_PAGE_IN_FW_QUEUE_PUB_DTM<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3187 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3188 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3189 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3190 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3191 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3192 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3193 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3194 NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3197 rtl8192_tx_enable(dev);
3198 rtl8192_rx_enable(dev);
3199 //3Set Response Rate Setting Register
3200 // CCK rate is supported by default.
3201 // CCK rate will be filtered out only when associated AP does not support it.
3202 ulRegRead = (0xFFF00000 & read_nic_dword(dev, RRSR)) | RATE_ALL_OFDM_AG | RATE_ALL_CCK;
3203 write_nic_dword(dev, RRSR, ulRegRead);
3204 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3207 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3208 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3210 //rtl8192_actset_wirelessmode(dev,priv->RegWirelessMode);
3211 if(priv->ResetProgress == RESET_TYPE_NORESET)
3212 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3213 //-----------------------------------------------------------------------------
3214 // Set up security related. 070106, by rcnjko:
3215 // 1. Clear all H/W keys.
3216 // 2. Enable H/W encryption/decryption.
3217 //-----------------------------------------------------------------------------
3218 CamResetAllEntry(dev);
3220 u8 SECR_value = 0x0;
3221 SECR_value |= SCR_TxEncEnable;
3222 SECR_value |= SCR_RxDecEnable;
3223 SECR_value |= SCR_NoSKMC;
3224 write_nic_byte(dev, SECR, SECR_value);
3227 write_nic_word(dev, ATIMWND, 2);
3228 write_nic_word(dev, BCN_INTERVAL, 100);
3229 for (i=0; i<QOS_QUEUE_NUM; i++)
3230 write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
3232 // Switching regulator controller: This is set temporarily.
3233 // It's not sure if this can be removed in the future.
3234 // PJ advised to leave it by default.
3236 write_nic_byte(dev, 0xbe, 0xc0);
3238 //2=======================================================
3239 // Set PHY related configuration defined in MAC register bank
3240 //2=======================================================
3241 rtl8192_phy_configmac(dev);
3243 if (priv->card_8192_version > (u8) VERSION_8190_BD) {
3244 rtl8192_phy_getTxPower(dev);
3245 rtl8192_phy_setTxPower(dev, priv->chan);
3249 tmpvalue = read_nic_byte(dev, IC_VERRSION);
3250 priv->IC_Cut = tmpvalue;
3251 RT_TRACE(COMP_INIT, "priv->IC_Cut = 0x%x\n", priv->IC_Cut);
3252 if(priv->IC_Cut >= IC_VersionCut_D)
3254 //pHalData->bDcut = TRUE;
3255 if(priv->IC_Cut == IC_VersionCut_D)
3256 RT_TRACE(COMP_INIT, "D-cut\n");
3257 if(priv->IC_Cut == IC_VersionCut_E)
3259 RT_TRACE(COMP_INIT, "E-cut\n");
3260 // HW SD suggest that we should not wirte this register too often, so driver
3261 // should readback this register. This register will be modified only when
3267 //pHalData->bDcut = FALSE;
3268 RT_TRACE(COMP_INIT, "Before C-cut\n");
3273 RT_TRACE(COMP_INIT, "Load Firmware!\n");
3274 bfirmwareok = init_firmware(dev);
3275 if(bfirmwareok != true) {
3276 rtStatus = RT_STATUS_FAILURE;
3279 RT_TRACE(COMP_INIT, "Load Firmware finished!\n");
3282 if(priv->ResetProgress == RESET_TYPE_NORESET)
3284 RT_TRACE(COMP_INIT, "RF Config Started!\n");
3285 rtStatus = rtl8192_phy_RFConfig(dev);
3286 if(rtStatus != RT_STATUS_SUCCESS)
3288 RT_TRACE(COMP_ERR, "RF Config failed\n");
3291 RT_TRACE(COMP_INIT, "RF Config Finished!\n");
3293 rtl8192_phy_updateInitGain(dev);
3295 /*---- Set CCK and OFDM Block "ON"----*/
3296 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3297 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3301 write_nic_byte(dev, 0x87, 0x0);
3304 //2008.06.03, for WOL
3305 ucRegRead = read_nic_byte(dev, GPE);
3307 write_nic_byte(dev, GPE, ucRegRead);
3309 ucRegRead = read_nic_byte(dev, GPO);
3311 write_nic_byte(dev, GPO, ucRegRead);
3314 //2=======================================================
3316 //2=======================================================
3320 if(priv->RegRfOff == TRUE)
3321 { // User disable RF via registry.
3322 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RegRfOff ----------\n",__FUNCTION__);
3323 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW);
3324 #if 0//cosa, ask SD3 willis and he doesn't know what is this for
3325 // Those action will be discard in MgntActSet_RF_State because off the same state
3326 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3327 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3330 else if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS)
3331 { // H/W or S/W RF OFF before sleep.
3332 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3333 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3335 else if(priv->ieee80211->RfOffReason >= RF_CHANGE_BY_IPS)
3336 { // H/W or S/W RF OFF before sleep.
3337 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3338 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3342 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): RF-ON \n",__FUNCTION__);
3343 priv->ieee80211->eRFPowerState = eRfOn;
3344 priv->ieee80211->RfOffReason = 0;
3345 //DrvIFIndicateCurrentPhyStatus(Adapter);
3347 //Adapter->HalFunc.LedControlHandler(Adapter, LED_CTL_POWER_ON);
3350 // If inactive power mode is enabled, disable rf while in disconnected state.
3351 // But we should still tell upper layer we are in rf on state.
3352 // 2007.07.16, by shien chang.
3354 //if(!Adapter->bInHctTest)
3355 //IPSEnter(Adapter);
3362 // We can force firmware to do RF-R/W
3363 if(priv->ieee80211->FwRWRF)
3364 priv->Rf_Mode = RF_OP_By_FW;
3366 priv->Rf_Mode = RF_OP_By_SW_3wire;
3368 priv->Rf_Mode = RF_OP_By_SW_3wire;
3372 if(priv->ResetProgress == RESET_TYPE_NORESET)
3374 dm_initialize_txpower_tracking(dev);
3376 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3377 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3379 if(priv->rf_type == RF_2T4R){
3380 for(i = 0; i<TxBBGainTableLength; i++)
3382 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3384 priv->rfa_txpowertrackingindex= (u8)i;
3385 priv->rfa_txpowertrackingindex_real= (u8)i;
3386 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3391 for(i = 0; i<TxBBGainTableLength; i++)
3393 if(tmpRegC == priv->txbbgain_table[i].txbbgain_value)
3395 priv->rfc_txpowertrackingindex= (u8)i;
3396 priv->rfc_txpowertrackingindex_real= (u8)i;
3397 priv->rfc_txpowertracking_default = priv->rfc_txpowertrackingindex;
3401 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3403 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3405 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3407 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3411 priv->CCKPresentAttentuation_40Mdefault = 0;
3412 priv->CCKPresentAttentuation_difference = 0;
3413 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3414 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3415 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3416 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_initial = %d\n", priv->rfc_txpowertrackingindex);
3417 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_real_initial = %d\n", priv->rfc_txpowertrackingindex_real);
3418 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3419 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3423 if(priv->ResetProgress == RESET_TYPE_NORESET)
3425 dm_initialize_txpower_tracking(dev);
3427 if(priv->IC_Cut >= IC_VersionCut_D)
3429 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3430 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3431 for(i = 0; i<TxBBGainTableLength; i++)
3433 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3435 priv->rfa_txpowertrackingindex= (u8)i;
3436 priv->rfa_txpowertrackingindex_real= (u8)i;
3437 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3442 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3444 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3446 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3448 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3452 priv->CCKPresentAttentuation_40Mdefault = 0;
3453 priv->CCKPresentAttentuation_difference = 0;
3454 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3455 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3456 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3457 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3458 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3459 priv->btxpower_tracking = FALSE;//TEMPLY DISABLE
3464 rtl8192_irq_enable(dev);
3465 priv->being_init_adapter = false;
3470 static void rtl8192_prepare_beacon(struct r8192_priv *priv)
3472 struct sk_buff *skb;
3473 //unsigned long flags;
3476 skb = ieee80211_get_beacon(priv->ieee80211);
3477 tcb_desc = (cb_desc *)(skb->cb + 8);
3478 //spin_lock_irqsave(&priv->tx_lock,flags);
3479 /* prepare misc info for the beacon xmit */
3480 tcb_desc->queue_index = BEACON_QUEUE;
3481 /* IBSS does not support HT yet, use 1M defaultly */
3482 tcb_desc->data_rate = 2;
3483 tcb_desc->RATRIndex = 7;
3484 tcb_desc->bTxDisableRateFallBack = 1;
3485 tcb_desc->bTxUseDriverAssingedRate = 1;
3487 skb_push(skb, priv->ieee80211->tx_headroom);
3489 rtl8192_tx(priv->ieee80211->dev,skb);
3491 //spin_unlock_irqrestore (&priv->tx_lock, flags);
3496 * configure registers for beacon tx and enables it via
3497 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3498 * be used to stop beacon transmission
3500 static void rtl8192_start_beacon(struct net_device *dev)
3502 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3503 struct ieee80211_network *net = &priv->ieee80211->current_network;
3508 DMESG("Enabling beacon TX");
3509 //rtl8192_prepare_beacon(dev);
3510 rtl8192_irq_disable(dev);
3511 //rtl8192_beacon_tx_enable(dev);
3514 write_nic_word(dev, ATIMWND, 2);
3516 /* Beacon interval (in unit of TU) */
3517 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
3520 * DrvErlyInt (in unit of TU).
3521 * (Time to send interrupt to notify driver to c
3522 * hange beacon content)
3524 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
3527 * BcnDMATIM(in unit of us).
3528 * Indicates the time before TBTT to perform beacon queue DMA
3530 write_nic_word(dev, BCN_DMATIME, 256);
3533 * Force beacon frame transmission even after receiving
3534 * beacon frame from other ad hoc STA
3536 write_nic_byte(dev, BCN_ERR_THRESH, 100);
3538 /* Set CW and IFS */
3539 BcnTimeCfg |= BcnCW<<BCN_TCFG_CW_SHIFT;
3540 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
3541 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
3544 /* enable the interrupt for ad-hoc process */
3545 rtl8192_irq_enable(dev);
3548 static bool HalTxCheckStuck8190Pci(struct net_device *dev)
3550 u16 RegTxCounter = read_nic_word(dev, 0x128);
3551 struct r8192_priv *priv = ieee80211_priv(dev);
3552 bool bStuck = FALSE;
3553 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3554 if(priv->TxCounter==RegTxCounter)
3557 priv->TxCounter = RegTxCounter;
3563 * Assumption: RT_TX_SPINLOCK is acquired.
3566 TxCheckStuck(struct net_device *dev)
3568 struct r8192_priv *priv = ieee80211_priv(dev);
3570 ptx_ring head=NULL,tail=NULL,txring = NULL;
3571 u8 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3572 bool bCheckFwTxCnt = false;
3575 // Decide Stuch threshold according to current power save mode
3577 switch (priv->ieee80211->dot11PowerSaveMode)
3579 // The threshold value may required to be adjusted .
3580 case eActive: // Active/Continuous access.
3581 ResetThreshold = NIC_SEND_HANG_THRESHOLD_NORMAL;
3583 case eMaxPs: // Max power save mode.
3584 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3586 case eFastPs: // Fast power save mode.
3587 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3592 // Check whether specific tcb has been queued for a specific time
3594 for(QueueID = 0; QueueID < MAX_TX_QUEUE; QueueID++)
3598 if(QueueID == TXCMD_QUEUE)
3603 tail=priv->txmapringtail;
3604 head=priv->txmapringhead;
3608 tail=priv->txbkpringtail;
3609 head=priv->txbkpringhead;
3613 tail=priv->txbepringtail;
3614 head=priv->txbepringhead;
3618 tail=priv->txvipringtail;
3619 head=priv->txvipringhead;
3623 tail=priv->txvopringtail;
3624 head=priv->txvopringhead;
3639 RT_TRACE(COMP_ERR,"%s():txring is NULL , BUG!\n",__FUNCTION__);
3642 txring->nStuckCount++;
3643 bCheckFwTxCnt = TRUE;
3649 if(HalTxCheckStuck8190Pci(dev))
3651 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3652 return RESET_TYPE_SILENT;
3656 return RESET_TYPE_NORESET;
3660 static bool HalRxCheckStuck8190Pci(struct net_device *dev)
3662 struct r8192_priv *priv = ieee80211_priv(dev);
3663 u16 RegRxCounter = read_nic_word(dev, 0x130);
3664 bool bStuck = FALSE;
3665 static u8 rx_chk_cnt = 0;
3666 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3667 // If rssi is small, we should check rx for long time because of bad rx.
3668 // or maybe it will continuous silent reset every 2 seconds.
3670 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3672 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
3674 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3675 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3676 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
3688 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
3689 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
3690 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
3694 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3700 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3707 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
3713 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
3716 if(priv->RxCounter==RegRxCounter)
3719 priv->RxCounter = RegRxCounter;
3724 static RESET_TYPE RxCheckStuck(struct net_device *dev)
3727 if(HalRxCheckStuck8190Pci(dev))
3729 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
3730 return RESET_TYPE_SILENT;
3733 return RESET_TYPE_NORESET;
3737 rtl819x_ifcheck_resetornot(struct net_device *dev)
3739 struct r8192_priv *priv = ieee80211_priv(dev);
3740 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
3741 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
3742 RT_RF_POWER_STATE rfState;
3744 rfState = priv->ieee80211->eRFPowerState;
3746 TxResetType = TxCheckStuck(dev);
3748 if( rfState != eRfOff &&
3749 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3750 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
3752 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3753 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3754 // if driver is in firmware download failure status, driver should initialize RF in the following
3755 // silent reset procedure Emily, 2008.01.21
3757 // Driver should not check RX stuck in IBSS mode because it is required to
3758 // set Check BSSID in order to send beacon, however, if check BSSID is
3759 // set, STA cannot hear any packet a all. Emily, 2008.04.12
3760 RxResetType = RxCheckStuck(dev);
3764 RT_TRACE(COMP_RESET,"%s(): TxResetType is %d, RxResetType is %d\n",__FUNCTION__,TxResetType,RxResetType);
3765 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
3766 return RESET_TYPE_NORMAL;
3767 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT)
3768 return RESET_TYPE_SILENT;
3770 return RESET_TYPE_NORESET;
3775 static void CamRestoreAllEntry(struct net_device *dev)
3778 struct r8192_priv *priv = ieee80211_priv(dev);
3779 const u8* MacAddr = priv->ieee80211->current_network.bssid;
3781 static const u8 CAM_CONST_ADDR[4][6] = {
3782 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3783 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3784 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3785 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3786 static const u8 CAM_CONST_BROAD[] =
3787 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3789 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3792 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
3793 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
3796 for(EntryId=0; EntryId<4; EntryId++)
3799 MacAddr = CAM_CONST_ADDR[EntryId];
3803 priv->ieee80211->pairwise_key_type,
3811 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
3815 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3819 priv->ieee80211->pairwise_key_type,
3827 priv->ieee80211->pairwise_key_type,
3833 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
3837 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3841 priv->ieee80211->pairwise_key_type,
3849 priv->ieee80211->pairwise_key_type,
3858 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
3860 MacAddr = CAM_CONST_BROAD;
3861 for(EntryId=1 ; EntryId<4 ; EntryId++)
3867 priv->ieee80211->group_key_type,
3873 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3877 priv->ieee80211->group_key_type,
3882 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
3884 MacAddr = CAM_CONST_BROAD;
3885 for(EntryId=1; EntryId<4 ; EntryId++)
3891 priv->ieee80211->group_key_type,
3898 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3902 priv->ieee80211->group_key_type,
3910 * This function is used to fix Tx/Rx stop bug temporarily.
3911 * This function will do "system reset" to NIC when Tx or Rx is stuck.
3912 * The method checking Tx/Rx stuck of this function is supported by FW,
3913 * which reports Tx and Rx counter to register 0x128 and 0x130.
3915 static void rtl819x_ifsilentreset(struct net_device *dev)
3917 struct r8192_priv *priv = ieee80211_priv(dev);
3919 int reset_status = 0;
3920 struct ieee80211_device *ieee = priv->ieee80211;
3925 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3926 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3928 if(priv->ResetProgress==RESET_TYPE_NORESET)
3932 //LZM for PS-Poll AID issue. 090429
3933 if(priv->ieee80211->state == IEEE80211_LINKED)
3934 LeisurePSLeave(dev);
3937 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
3939 // Set the variable for reset.
3940 priv->ResetProgress = RESET_TYPE_SILENT;
3941 // rtl8192_close(dev);
3943 down(&priv->wx_sem);
3946 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
3951 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
3952 if(!netif_queue_stopped(dev))
3953 netif_stop_queue(dev);
3955 dm_backup_dynamic_mechanism_state(dev);
3957 rtl8192_irq_disable(dev);
3958 rtl8192_cancel_deferred_work(priv);
3960 del_timer_sync(&priv->watch_dog_timer);
3961 ieee->sync_scan_hurryup = 1;
3962 if(ieee->state == IEEE80211_LINKED)
3964 down(&ieee->wx_sem);
3965 printk("ieee->state is IEEE80211_LINKED\n");
3966 ieee80211_stop_send_beacons(priv->ieee80211);
3967 del_timer_sync(&ieee->associate_timer);
3968 cancel_delayed_work(&ieee->associate_retry_wq);
3969 ieee80211_stop_scan(ieee);
3973 printk("ieee->state is NOT LINKED\n");
3974 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
3976 rtl8192_halt_adapter(dev, true);
3978 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
3979 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
3980 reset_status = _rtl8192_up(dev);
3982 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
3983 if(reset_status == -1)
3992 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n",__FUNCTION__);
3996 ieee->is_silent_reset = 1;
3998 EnableHWSecurityConfig8192(dev);
4000 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4002 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4005 queue_work(ieee->wq, &ieee->associate_complete_wq);
4009 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
4011 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4012 ieee->link_change(ieee->dev);
4014 // notify_wx_assoc_event(ieee);
4016 ieee80211_start_send_beacons(ieee);
4018 if (ieee->data_hard_resume)
4019 ieee->data_hard_resume(ieee->dev);
4020 netif_carrier_on(ieee->dev);
4024 CamRestoreAllEntry(dev);
4026 // Restore the previous setting for all dynamic mechanism
4027 dm_restore_dynamic_mechanism_state(dev);
4029 priv->ResetProgress = RESET_TYPE_NORESET;
4030 priv->reset_count++;
4032 priv->bForcedSilentReset =false;
4033 priv->bResetInProgress = false;
4035 // For test --> force write UFWP.
4036 write_nic_byte(dev, UFWP, 1);
4037 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4043 void InactivePsWorkItemCallback(struct net_device *dev)
4045 struct r8192_priv *priv = ieee80211_priv(dev);
4046 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4048 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() ---------> \n");
4050 // This flag "bSwRfProcessing", indicates the status of IPS procedure, should be set if the IPS workitem
4051 // is really scheduled.
4052 // The old code, sets this flag before scheduling the IPS workitem and however, at the same time the
4053 // previous IPS workitem did not end yet, fails to schedule the current workitem. Thus, bSwRfProcessing
4054 // blocks the IPS procedure of switching RF.
4055 // By Bruce, 2007-12-25.
4057 pPSC->bSwRfProcessing = TRUE;
4059 RT_TRACE(COMP_RF, "InactivePsWorkItemCallback(): Set RF to %s.\n",
4060 pPSC->eInactivePowerState == eRfOff?"OFF":"ON");
4063 MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
4066 // To solve CAM values miss in RF OFF, rewrite CAM values after RF ON. By Bruce, 2007-09-20.
4068 pPSC->bSwRfProcessing = FALSE;
4069 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() <--------- \n");
4073 /* Change current and default preamble mode. */
4074 bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev, u8 rtPsMode)
4076 struct r8192_priv *priv = ieee80211_priv(dev);
4078 // Currently, we do not change power save mode on IBSS mode.
4079 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4085 // <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
4086 // some AP will not response to our mgnt frames with PwrMgt bit set,
4087 // e.g. cannot associate the AP.
4088 // So I commented out it. 2005.02.16, by rcnjko.
4090 // // Change device's power save mode.
4091 // Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
4093 // Update power save mode configured.
4094 //RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__FUNCTION__,rtPsMode);
4095 if(!priv->ps_force) {
4096 priv->ieee80211->ps = rtPsMode;
4099 // Awake immediately
4100 if(priv->ieee80211->sta_sleep != 0 && rtPsMode == IEEE80211_PS_DISABLED)
4102 unsigned long flags;
4104 //PlatformSetTimer(Adapter, &(pMgntInfo->AwakeTimer), 0);
4105 // Notify the AP we awke.
4106 rtl8192_hw_wakeup(dev);
4107 priv->ieee80211->sta_sleep = 0;
4109 spin_lock_irqsave(&(priv->ieee80211->mgmt_tx_lock), flags);
4110 printk("LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
4111 ieee80211_sta_ps_send_null_frame(priv->ieee80211, 0);
4112 spin_unlock_irqrestore(&(priv->ieee80211->mgmt_tx_lock), flags);
4118 /* Enter the leisure power save mode. */
4119 void LeisurePSEnter(struct net_device *dev)
4121 struct r8192_priv *priv = ieee80211_priv(dev);
4122 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4124 //RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
4125 //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
4126 // pPSC->bLeisurePs, priv->ieee80211->ps,pPSC->LpsIdleCount,RT_CHECK_FOR_HANG_PERIOD);
4128 if(!((priv->ieee80211->iw_mode == IW_MODE_INFRA) &&
4129 (priv->ieee80211->state == IEEE80211_LINKED)) ||
4130 (priv->ieee80211->iw_mode == IW_MODE_ADHOC) ||
4131 (priv->ieee80211->iw_mode == IW_MODE_MASTER))
4134 if (pPSC->bLeisurePs)
4136 // Idle for a while if we connect to AP a while ago.
4137 if(pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) // 4 Sec
4140 if(priv->ieee80211->ps == IEEE80211_PS_DISABLED)
4143 //RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter 802.11 power save mode...\n");
4144 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST);
4149 pPSC->LpsIdleCount++;
4154 /* Leave leisure power save mode. */
4155 void LeisurePSLeave(struct net_device *dev)
4157 struct r8192_priv *priv = ieee80211_priv(dev);
4158 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4160 if (pPSC->bLeisurePs)
4162 if(priv->ieee80211->ps != IEEE80211_PS_DISABLED)
4164 // move to lps_wakecomplete()
4165 //RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n");
4166 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_DISABLED);
4174 /* Enter the inactive power save mode. RF will be off */
4176 IPSEnter(struct net_device *dev)
4178 struct r8192_priv *priv = ieee80211_priv(dev);
4179 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4180 RT_RF_POWER_STATE rtState;
4182 if (pPSC->bInactivePs)
4184 rtState = priv->ieee80211->eRFPowerState;
4186 // Added by Bruce, 2007-12-25.
4187 // Do not enter IPS in the following conditions:
4188 // (1) RF is already OFF or Sleep
4189 // (2) bSwRfProcessing (indicates the IPS is still under going)
4190 // (3) Connectted (only disconnected can trigger IPS)
4191 // (4) IBSS (send Beacon)
4192 // (5) AP mode (send Beacon)
4194 if (rtState == eRfOn && !pPSC->bSwRfProcessing
4195 && (priv->ieee80211->state != IEEE80211_LINKED) )
4197 RT_TRACE(COMP_RF,"IPSEnter(): Turn off RF.\n");
4198 //printk("IPSEnter(): Turn off RF.\n");
4199 pPSC->eInactivePowerState = eRfOff;
4200 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4201 InactivePsWorkItemCallback(dev);
4208 // Leave the inactive power save mode, RF will be on.
4209 // 2007.08.17, by shien chang.
4212 IPSLeave(struct net_device *dev)
4214 struct r8192_priv *priv = ieee80211_priv(dev);
4215 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4216 RT_RF_POWER_STATE rtState;
4218 if (pPSC->bInactivePs)
4220 rtState = priv->ieee80211->eRFPowerState;
4221 if (rtState != eRfOn && !pPSC->bSwRfProcessing && priv->ieee80211->RfOffReason <= RF_CHANGE_BY_IPS)
4223 RT_TRACE(COMP_POWER, "IPSLeave(): Turn on RF.\n");
4224 //printk("IPSLeave(): Turn on RF.\n");
4225 pPSC->eInactivePowerState = eRfOn;
4226 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4227 InactivePsWorkItemCallback(dev);
4232 void IPSLeave_wq(void *data)
4234 struct ieee80211_device *ieee = container_of(data,struct ieee80211_device,ips_leave_wq);
4235 struct net_device *dev = ieee->dev;
4237 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4238 down(&priv->ieee80211->ips_sem);
4240 up(&priv->ieee80211->ips_sem);
4243 void ieee80211_ips_leave_wq(struct net_device *dev)
4245 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4246 RT_RF_POWER_STATE rtState;
4247 rtState = priv->ieee80211->eRFPowerState;
4249 if(priv->ieee80211->PowerSaveControl.bInactivePs){
4250 if(rtState == eRfOff){
4251 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
4253 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
4257 printk("=========>%s(): IPSLeave\n",__FUNCTION__);
4258 queue_work(priv->ieee80211->wq,&priv->ieee80211->ips_leave_wq);
4263 //added by amy 090331 end
4264 void ieee80211_ips_leave(struct net_device *dev)
4266 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4267 down(&priv->ieee80211->ips_sem);
4269 up(&priv->ieee80211->ips_sem);
4273 static void rtl819x_update_rxcounts(
4274 struct r8192_priv *priv,
4283 *TotalRxDataNum = 0;
4285 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4286 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4287 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4288 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4289 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4290 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4295 static void rtl819x_watchdog_wqcallback(struct work_struct *work)
4297 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4298 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4299 struct net_device *dev = priv->ieee80211->dev;
4300 struct ieee80211_device* ieee = priv->ieee80211;
4301 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4302 static u8 check_reset_cnt=0;
4303 unsigned long flags;
4304 bool bBusyTraffic = false;
4305 static u8 last_time = 0;
4306 bool bEnterPS = false;
4308 if ((!priv->up) || priv->bHwRadioOff)
4313 hal_dm_watchdog(dev);
4315 // printk("watch_dog ENABLE_IPS\n");
4316 if(ieee->actscanning == false){
4317 //printk("%d,%d,%d,%d\n", ieee->eRFPowerState, ieee->is_set_key, ieee->proto_stoppping, ieee->wx_set_enc);
4318 if((ieee->iw_mode == IW_MODE_INFRA) && (ieee->state == IEEE80211_NOLINK) &&
4319 (ieee->eRFPowerState == eRfOn)&&!ieee->is_set_key &&
4320 (!ieee->proto_stoppping) && !ieee->wx_set_enc){
4321 if(ieee->PowerSaveControl.ReturnPoint == IPS_CALLBACK_NONE){
4322 //printk("====================>haha:IPSEnter()\n");
4324 //ieee80211_stop_scan(priv->ieee80211);
4329 {//to get busy traffic condition
4330 if(ieee->state == IEEE80211_LINKED)
4332 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 100 ||
4333 ieee->LinkDetectInfo.NumTxOkInPeriod> 100 ) {
4334 bBusyTraffic = true;
4338 //added by amy for Leisure PS
4339 if( ((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod + ieee->LinkDetectInfo.NumTxOkInPeriod) > 8 ) ||
4340 (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2) )
4342 //printk("ieee->LinkDetectInfo.NumRxUnicastOkInPeriod is %d,ieee->LinkDetectInfo.NumTxOkInPeriod is %d\n",
4343 // ieee->LinkDetectInfo.NumRxUnicastOkInPeriod,ieee->LinkDetectInfo.NumTxOkInPeriod);
4351 //printk("***bEnterPS = %d\n", bEnterPS);
4352 // LeisurePS only work in infra mode.
4355 LeisurePSEnter(dev);
4359 LeisurePSLeave(dev);
4367 //RT_TRACE(COMP_LPS,"====>no link LPS leave\n");
4368 LeisurePSLeave(dev);
4372 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4373 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4374 ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
4375 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4379 //added by amy for AP roaming
4382 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4384 u32 TotalRxBcnNum = 0;
4385 u32 TotalRxDataNum = 0;
4387 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4388 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4390 if( ieee->eRFPowerState == eRfOff)
4391 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4392 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4393 // Dot11d_Reset(dev);
4394 ieee->state = IEEE80211_ASSOCIATING;
4395 notify_wx_assoc_event(priv->ieee80211);
4396 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4397 ieee->is_roaming = true;
4398 ieee->is_set_key = false;
4399 ieee->link_change(dev);
4400 queue_work(ieee->wq, &ieee->associate_procedure_wq);
4403 ieee->LinkDetectInfo.NumRecvBcnInPeriod=0;
4404 ieee->LinkDetectInfo.NumRecvDataInPeriod=0;
4407 //check if reset the driver
4408 spin_lock_irqsave(&priv->tx_lock,flags);
4409 if(check_reset_cnt++ >= 3 && !ieee->is_roaming && (last_time != 1))
4411 ResetType = rtl819x_ifcheck_resetornot(dev);
4412 check_reset_cnt = 3;
4413 //DbgPrint("Start to check silent reset\n");
4415 spin_unlock_irqrestore(&priv->tx_lock,flags);
4416 if(!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_NORMAL)
4418 priv->ResetProgress = RESET_TYPE_NORMAL;
4419 RT_TRACE(COMP_RESET,"%s(): NOMAL RESET\n",__FUNCTION__);
4422 /* disable silent reset temply 2008.9.11*/
4424 if( ((priv->force_reset) || (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT))) // This is control by OID set in Pomelo
4427 rtl819x_ifsilentreset(dev);
4432 priv->force_reset = false;
4433 priv->bForcedSilentReset = false;
4434 priv->bResetInProgress = false;
4435 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4439 void watch_dog_timer_callback(unsigned long data)
4441 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4442 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq,0);
4443 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4447 static int _rtl8192_up(struct net_device *dev)
4449 struct r8192_priv *priv = ieee80211_priv(dev);
4451 RT_STATUS init_status = RT_STATUS_SUCCESS;
4453 priv->ieee80211->ieee_up=1;
4454 priv->bdisable_nic = false; //YJ,add,091111
4455 RT_TRACE(COMP_INIT, "Bringing up iface");
4457 init_status = rtl8192_adapter_start(dev);
4458 if(init_status != RT_STATUS_SUCCESS)
4460 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
4463 RT_TRACE(COMP_INIT, "start adapter finished\n");
4465 if(priv->ieee80211->eRFPowerState!=eRfOn)
4466 MgntActSet_RF_State(dev, eRfOn, priv->ieee80211->RfOffReason);
4468 if(priv->ieee80211->state != IEEE80211_LINKED)
4469 ieee80211_softmac_start_protocol(priv->ieee80211);
4470 ieee80211_reset_queue(priv->ieee80211);
4471 watch_dog_timer_callback((unsigned long) dev);
4472 if(!netif_queue_stopped(dev))
4473 netif_start_queue(dev);
4475 netif_wake_queue(dev);
4481 static int rtl8192_open(struct net_device *dev)
4483 struct r8192_priv *priv = ieee80211_priv(dev);
4486 down(&priv->wx_sem);
4487 ret = rtl8192_up(dev);
4494 int rtl8192_up(struct net_device *dev)
4496 struct r8192_priv *priv = ieee80211_priv(dev);
4498 if (priv->up == 1) return -1;
4500 return _rtl8192_up(dev);
4504 static int rtl8192_close(struct net_device *dev)
4506 struct r8192_priv *priv = ieee80211_priv(dev);
4509 down(&priv->wx_sem);
4511 ret = rtl8192_down(dev);
4519 int rtl8192_down(struct net_device *dev)
4521 struct r8192_priv *priv = ieee80211_priv(dev);
4523 if (priv->up == 0) return -1;
4526 //LZM for PS-Poll AID issue. 090429
4527 if(priv->ieee80211->state == IEEE80211_LINKED)
4528 LeisurePSLeave(dev);
4532 priv->ieee80211->ieee_up = 0;
4533 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4535 if (!netif_queue_stopped(dev))
4536 netif_stop_queue(dev);
4538 rtl8192_irq_disable(dev);
4539 rtl8192_cancel_deferred_work(priv);
4541 del_timer_sync(&priv->watch_dog_timer);
4543 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4545 rtl8192_halt_adapter(dev,false);
4546 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4548 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4554 void rtl8192_commit(struct net_device *dev)
4556 struct r8192_priv *priv = ieee80211_priv(dev);
4558 if (priv->up == 0) return ;
4561 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4563 rtl8192_irq_disable(dev);
4564 rtl8192_halt_adapter(dev,true);
4568 static void rtl8192_restart(struct work_struct *work)
4570 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4571 struct net_device *dev = priv->ieee80211->dev;
4573 down(&priv->wx_sem);
4575 rtl8192_commit(dev);
4580 static void r8192_set_multicast(struct net_device *dev)
4582 struct r8192_priv *priv = ieee80211_priv(dev);
4585 //down(&priv->wx_sem);
4589 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4591 if (promisc != priv->promisc) {
4593 // rtl8192_commit(dev);
4596 priv->promisc = promisc;
4598 //schedule_work(&priv->reset_wq);
4599 //up(&priv->wx_sem);
4603 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
4605 struct r8192_priv *priv = ieee80211_priv(dev);
4606 struct sockaddr *addr = mac;
4608 down(&priv->wx_sem);
4610 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4612 schedule_work(&priv->reset_wq);
4618 /* based on ipw2200 driver */
4619 static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4621 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4622 struct iwreq *wrq = (struct iwreq *)rq;
4624 struct ieee80211_device *ieee = priv->ieee80211;
4626 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4627 struct iw_point *p = &wrq->u.data;
4628 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
4630 down(&priv->wx_sem);
4633 if (p->length < sizeof(struct ieee_param) || !p->pointer){
4638 ipw = kmalloc(p->length, GFP_KERNEL);
4643 if (copy_from_user(ipw, p->pointer, p->length)) {
4650 case RTL_IOCTL_WPA_SUPPLICANT:
4651 //parse here for HW security
4652 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
4654 if (ipw->u.crypt.set_tx)
4656 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4657 ieee->pairwise_key_type = KEY_TYPE_CCMP;
4658 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4659 ieee->pairwise_key_type = KEY_TYPE_TKIP;
4660 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4662 if (ipw->u.crypt.key_len == 13)
4663 ieee->pairwise_key_type = KEY_TYPE_WEP104;
4664 else if (ipw->u.crypt.key_len == 5)
4665 ieee->pairwise_key_type = KEY_TYPE_WEP40;
4668 ieee->pairwise_key_type = KEY_TYPE_NA;
4670 if (ieee->pairwise_key_type)
4672 memcpy((u8*)key, ipw->u.crypt.key, 16);
4673 EnableHWSecurityConfig8192(dev);
4674 //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!
4676 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4677 if (ieee->auth_mode != 2) //LEAP WEP will never set this.
4678 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4680 if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) && ieee->pHTInfo->bCurrentHTSupport){
4681 write_nic_byte(dev, 0x173, 1); //fix aes bug
4685 else //if (ipw->u.crypt.idx) //group key use idx > 0
4687 memcpy((u8*)key, ipw->u.crypt.key, 16);
4688 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4689 ieee->group_key_type= KEY_TYPE_CCMP;
4690 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4691 ieee->group_key_type = KEY_TYPE_TKIP;
4692 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4694 if (ipw->u.crypt.key_len == 13)
4695 ieee->group_key_type = KEY_TYPE_WEP104;
4696 else if (ipw->u.crypt.key_len == 5)
4697 ieee->group_key_type = KEY_TYPE_WEP40;
4700 ieee->group_key_type = KEY_TYPE_NA;
4702 if (ieee->group_key_type)
4706 ipw->u.crypt.idx, //KeyIndex
4707 ieee->group_key_type, //KeyType
4708 broadcast_addr, //MacAddr
4718 printk("@@ wrq->u pointer = ");
4719 for(i=0;i<wrq->u.data.length;i++){
4720 if(i%10==0) printk("\n");
4721 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
4725 #endif /*JOHN_DEBUG*/
4726 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
4741 static u8 HwRateToMRate90(bool bIsHT, u8 rate)
4747 case DESC90_RATE1M: ret_rate = MGN_1M; break;
4748 case DESC90_RATE2M: ret_rate = MGN_2M; break;
4749 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
4750 case DESC90_RATE11M: ret_rate = MGN_11M; break;
4751 case DESC90_RATE6M: ret_rate = MGN_6M; break;
4752 case DESC90_RATE9M: ret_rate = MGN_9M; break;
4753 case DESC90_RATE12M: ret_rate = MGN_12M; break;
4754 case DESC90_RATE18M: ret_rate = MGN_18M; break;
4755 case DESC90_RATE24M: ret_rate = MGN_24M; break;
4756 case DESC90_RATE36M: ret_rate = MGN_36M; break;
4757 case DESC90_RATE48M: ret_rate = MGN_48M; break;
4758 case DESC90_RATE54M: ret_rate = MGN_54M; break;
4761 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
4767 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
4768 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
4769 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
4770 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
4771 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
4772 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
4773 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
4774 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
4775 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
4776 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
4777 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
4778 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
4779 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
4780 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
4781 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
4782 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
4783 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
4786 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
4794 /* Record the TSF time stamp when receiving a packet */
4795 static void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
4797 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4799 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
4800 stats->mac_time[0] = priv->LastRxDescTSFLow;
4801 stats->mac_time[1] = priv->LastRxDescTSFHigh;
4803 priv->LastRxDescTSFLow = stats->mac_time[0];
4804 priv->LastRxDescTSFHigh = stats->mac_time[1];
4808 static long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
4810 long signal_power; // in dBm.
4812 // Translate to dBm (x=0.5y-95).
4813 signal_power = (long)((signal_strength_index + 1) >> 1);
4816 return signal_power;
4820 * Update Rx signal related information in the packet reeived
4821 * to RxStats. User application can query RxStats to realize
4822 * current Rx signal status.
4824 * In normal operation, user only care about the information of the BSS
4825 * and we shall invoke this function if the packet received is from the BSS.
4828 rtl819x_update_rxsignalstatistics8190pci(
4829 struct r8192_priv * priv,
4830 struct ieee80211_rx_stats * pprevious_stats
4835 //2 <ToDo> Update Rx Statistics (such as signal strength and signal quality).
4838 if(priv->stats.recv_signal_power == 0)
4839 priv->stats.recv_signal_power = pprevious_stats->RecvSignalPower;
4841 // To avoid the past result restricting the statistics sensitivity, weight the current power (5/6) to speed up the
4842 // reaction of smoothed Signal Power.
4843 if(pprevious_stats->RecvSignalPower > priv->stats.recv_signal_power)
4845 else if(pprevious_stats->RecvSignalPower < priv->stats.recv_signal_power)
4848 // We need more correct power of received packets and the "SignalStrength" of RxStats have been beautified or translated,
4849 // so we record the correct power in Dbm here. By Bruce, 2008-03-07.
4851 priv->stats.recv_signal_power = (priv->stats.recv_signal_power * 5 + pprevious_stats->RecvSignalPower + weighting) / 6;
4855 rtl8190_process_cck_rxpathsel(
4856 struct r8192_priv * priv,
4857 struct ieee80211_rx_stats * pprevious_stats
4860 #ifdef RTL8190P //Only 90P 2T4R need to check
4861 char last_cck_adc_pwdb[4]={0,0,0,0};
4863 //cosa add for Rx path selection
4864 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable)
4866 if(pprevious_stats->bIsCCK &&
4867 (pprevious_stats->bPacketToSelf ||pprevious_stats->bPacketBeacon))
4869 /* record the cck adc_pwdb to the sliding window. */
4870 if(priv->stats.cck_adc_pwdb.TotalNum++ >= PHY_RSSI_SLID_WIN_MAX)
4872 priv->stats.cck_adc_pwdb.TotalNum = PHY_RSSI_SLID_WIN_MAX;
4873 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4875 last_cck_adc_pwdb[i] = priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index];
4876 priv->stats.cck_adc_pwdb.TotalVal[i] -= last_cck_adc_pwdb[i];
4879 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4881 priv->stats.cck_adc_pwdb.TotalVal[i] += pprevious_stats->cck_adc_pwdb[i];
4882 priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index] = pprevious_stats->cck_adc_pwdb[i];
4884 priv->stats.cck_adc_pwdb.index++;
4885 if(priv->stats.cck_adc_pwdb.index >= PHY_RSSI_SLID_WIN_MAX)
4886 priv->stats.cck_adc_pwdb.index = 0;
4888 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4890 DM_RxPathSelTable.cck_pwdb_sta[i] = priv->stats.cck_adc_pwdb.TotalVal[i]/priv->stats.cck_adc_pwdb.TotalNum;
4893 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4895 if(pprevious_stats->cck_adc_pwdb[i] > (char)priv->undecorated_smoothed_cck_adc_pwdb[i])
4897 priv->undecorated_smoothed_cck_adc_pwdb[i] =
4898 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
4899 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
4900 priv->undecorated_smoothed_cck_adc_pwdb[i] = priv->undecorated_smoothed_cck_adc_pwdb[i] + 1;
4904 priv->undecorated_smoothed_cck_adc_pwdb[i] =
4905 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
4906 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
4915 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
4916 be a local static. Otherwise, it may increase when we return from S3/S4. The
4917 value will be kept in memory or disk. We must delcare the value in adapter
4918 and it will be reinitialized when return from S3/S4. */
4919 static void rtl8192_process_phyinfo(struct r8192_priv * priv, u8* buffer,struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
4921 bool bcheck = false;
4923 u32 nspatial_stream, tmp_val;
4925 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
4926 static u32 slide_evm_index=0, slide_evm_statistics=0;
4927 static u32 last_rssi=0, last_evm=0;
4928 //cosa add for rx path selection
4929 // static long slide_cck_adc_pwdb_index=0, slide_cck_adc_pwdb_statistics=0;
4930 // static char last_cck_adc_pwdb[4]={0,0,0,0};
4931 //cosa add for beacon rssi smoothing
4932 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
4933 static u32 last_beacon_adc_pwdb=0;
4935 struct ieee80211_hdr_3addr *hdr;
4937 unsigned int frag,seq;
4938 hdr = (struct ieee80211_hdr_3addr *)buffer;
4939 sc = le16_to_cpu(hdr->seq_ctl);
4940 frag = WLAN_GET_SEQ_FRAG(sc);
4941 seq = WLAN_GET_SEQ_SEQ(sc);
4942 //cosa add 04292008 to record the sequence number
4943 pcurrent_stats->Seq_Num = seq;
4945 // Check whether we should take the previous packet into accounting
4947 if(!pprevious_stats->bIsAMPDU)
4949 // if previous packet is not aggregated packet
4953 //remve for that we don't use AMPDU to calculate PWDB,because the reported PWDB of some AP is fault.
4955 // if previous packet is aggregated packet, and current packet
4957 // (2) is the first packet of one AMPDU
4958 // that means the previous packet is the last one aggregated packet
4959 if( !pcurrent_stats->bIsAMPDU || pcurrent_stats->bFirstMPDU)
4964 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
4966 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
4967 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
4968 priv->stats.slide_rssi_total -= last_rssi;
4970 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
4972 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
4973 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
4974 slide_rssi_index = 0;
4976 // <1> Showed on UI for user, in dbm
4977 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
4978 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
4979 pcurrent_stats->rssi = priv->stats.signal_strength;
4981 // If the previous packet does not match the criteria, neglect it
4983 if(!pprevious_stats->bPacketMatchBSSID)
4985 if(!pprevious_stats->bToSelfBA)
4992 rtl8190_process_cck_rxpathsel(priv,pprevious_stats);
4997 priv->stats.num_process_phyinfo++;
4999 /* record the general signal strength to the sliding window. */
5000 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
5002 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
5003 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
5004 priv->stats.slide_rssi_total -= last_rssi;
5006 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
5008 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
5009 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
5010 slide_rssi_index = 0;
5012 // <1> Showed on UI for user, in dbm
5013 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
5014 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
5017 // <2> Showed on UI for engineering
5018 // hardware does not provide rssi information for each rf path in CCK
5019 if(!pprevious_stats->bIsCCK && pprevious_stats->bPacketToSelf)
5021 for (rfpath = RF90_PATH_A; rfpath < RF90_PATH_C; rfpath++)
5023 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
5025 RT_TRACE(COMP_DBG,"Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d \n" ,pprevious_stats->RxMIMOSignalStrength[rfpath] );
5026 //Fixed by Jacken 2008-03-20
5027 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
5029 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
5030 //DbgPrint("MIMO RSSI initialize \n");
5032 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
5034 priv->stats.rx_rssi_percentage[rfpath] =
5035 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5036 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5037 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
5041 priv->stats.rx_rssi_percentage[rfpath] =
5042 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5043 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5045 RT_TRACE(COMP_DBG,"Jacken -> priv->RxStats.RxRSSIPercentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
5053 //cosa add for beacon rssi smoothing by average.
5054 if(pprevious_stats->bPacketBeacon)
5056 /* record the beacon pwdb to the sliding window. */
5057 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5059 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
5060 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
5061 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
5062 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
5063 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
5065 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
5066 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
5067 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
5068 slide_beacon_adc_pwdb_index++;
5069 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5070 slide_beacon_adc_pwdb_index = 0;
5071 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
5072 if(pprevious_stats->RxPWDBAll >= 3)
5073 pprevious_stats->RxPWDBAll -= 3;
5076 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
5077 pprevious_stats->bIsCCK? "CCK": "OFDM",
5078 pprevious_stats->RxPWDBAll);
5080 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5082 if(priv->undecorated_smoothed_pwdb < 0) // initialize
5084 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
5085 //DbgPrint("First pwdb initialize \n");
5088 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
5090 priv->undecorated_smoothed_pwdb =
5091 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5092 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5093 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
5097 priv->undecorated_smoothed_pwdb =
5098 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5099 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5102 //Fixed by Jacken 2008-03-20
5103 if(pPreviousRfd->Status.RxPWDBAll > (u32)pHalData->UndecoratedSmoothedPWDB)
5105 pHalData->UndecoratedSmoothedPWDB =
5106 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5107 pHalData->UndecoratedSmoothedPWDB = pHalData->UndecoratedSmoothedPWDB + 1;
5111 pHalData->UndecoratedSmoothedPWDB =
5112 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5115 rtl819x_update_rxsignalstatistics8190pci(priv,pprevious_stats);
5121 /* record the general EVM to the sliding window. */
5122 if(pprevious_stats->SignalQuality == 0)
5127 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
5128 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
5129 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
5130 last_evm = priv->stats.slide_evm[slide_evm_index];
5131 priv->stats.slide_evm_total -= last_evm;
5134 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
5136 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
5137 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
5138 slide_evm_index = 0;
5140 // <1> Showed on UI for user, in percentage.
5141 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
5142 priv->stats.signal_quality = tmp_val;
5143 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
5144 priv->stats.last_signal_strength_inpercent = tmp_val;
5147 // <2> Showed on UI for engineering
5148 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5150 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
5152 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
5154 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
5156 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
5158 priv->stats.rx_evm_percentage[nspatial_stream] =
5159 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
5160 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
5168 static u8 rtl819x_query_rxpwrpercentage(
5172 if ((antpower <= -100) || (antpower >= 20))
5176 else if (antpower >= 0)
5182 return (100+antpower);
5188 rtl819x_evm_dbtopercentage(
5200 ret_val = 0 - ret_val;
5207 /* We want good-looking for signal strength/quality */
5208 static long rtl819x_signal_scale_mapping(long currsig)
5212 // Step 1. Scale mapping.
5213 if(currsig >= 61 && currsig <= 100)
5215 retsig = 90 + ((currsig - 60) / 4);
5217 else if(currsig >= 41 && currsig <= 60)
5219 retsig = 78 + ((currsig - 40) / 2);
5221 else if(currsig >= 31 && currsig <= 40)
5223 retsig = 66 + (currsig - 30);
5225 else if(currsig >= 21 && currsig <= 30)
5227 retsig = 54 + (currsig - 20);
5229 else if(currsig >= 5 && currsig <= 20)
5231 retsig = 42 + (((currsig - 5) * 2) / 3);
5233 else if(currsig == 4)
5237 else if(currsig == 3)
5241 else if(currsig == 2)
5245 else if(currsig == 1)
5257 static void rtl8192_query_rxphystatus(
5258 struct r8192_priv * priv,
5259 struct ieee80211_rx_stats * pstats,
5260 prx_desc_819x_pci pdesc,
5261 prx_fwinfo_819x_pci pdrvinfo,
5262 struct ieee80211_rx_stats * precord_stats,
5263 bool bpacket_match_bssid,
5264 bool bpacket_toself,
5269 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
5270 phy_sts_ofdm_819xpci_t* pofdm_buf;
5271 phy_sts_cck_819xpci_t * pcck_buf;
5272 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
5274 u8 i,max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
5275 char rx_pwr[4], rx_pwr_all=0;
5276 //long rx_avg_pwr = 0;
5277 char rx_snrX, rx_evmX;
5279 u32 RSSI, total_rssi=0;//, total_evm=0;
5280 // long signal_strength_index = 0;
5284 /* 2007/07/04 MH For OFDM RSSI. For high power or not. */
5285 static u8 check_reg824 = 0;
5286 static u32 reg824_bit9 = 0;
5288 priv->stats.numqry_phystatus++;
5290 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
5292 // Record it for next packet processing
5293 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
5294 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
5295 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
5296 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
5297 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
5298 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
5299 /*2007.08.30 requested by SD3 Jerry */
5300 if(check_reg824 == 0)
5302 reg824_bit9 = rtl8192_QueryBBReg(priv->ieee80211->dev, rFPGA0_XA_HSSIParameter2, 0x200);
5307 prxpkt = (u8*)pdrvinfo;
5309 /* Move pointer to the 16th bytes. Phy status start address. */
5310 prxpkt += sizeof(rx_fwinfo_819x_pci);
5312 /* Initial the cck and ofdm buffer pointer */
5313 pcck_buf = (phy_sts_cck_819xpci_t *)prxpkt;
5314 pofdm_buf = (phy_sts_ofdm_819xpci_t *)prxpkt;
5316 pstats->RxMIMOSignalQuality[0] = -1;
5317 pstats->RxMIMOSignalQuality[1] = -1;
5318 precord_stats->RxMIMOSignalQuality[0] = -1;
5319 precord_stats->RxMIMOSignalQuality[1] = -1;
5324 // (1)Hardware does not provide RSSI for CCK
5328 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5330 u8 report;//, cck_agc_rpt;
5333 char cck_adc_pwdb[4];
5335 priv->stats.numqry_phystatusCCK++;
5337 #ifdef RTL8190P //Only 90P 2T4R need to check
5338 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable && bpacket_match_bssid)
5340 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5342 tmp_pwdb = pcck_buf->adc_pwdb_X[i];
5343 cck_adc_pwdb[i] = (char)tmp_pwdb;
5344 cck_adc_pwdb[i] /= 2;
5345 pstats->cck_adc_pwdb[i] = precord_stats->cck_adc_pwdb[i] = cck_adc_pwdb[i];
5346 //DbgPrint("RF-%d tmp_pwdb = 0x%x, cck_adc_pwdb = %d", i, tmp_pwdb, cck_adc_pwdb[i]);
5353 report = pcck_buf->cck_agc_rpt & 0xc0;
5357 //Fixed by Jacken from Bryant 2008-03-20
5358 //Original value is -38 , -26 , -14 , -2
5359 //Fixed value is -35 , -23 , -11 , 6
5361 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
5364 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
5367 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
5370 rx_pwr_all = 8 - (pcck_buf->cck_agc_rpt & 0x3e);
5376 report = pcck_buf->cck_agc_rpt & 0x60;
5381 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5384 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
5387 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5390 rx_pwr_all = -8 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5395 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5396 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5397 pstats->RecvSignalPower = rx_pwr_all;
5400 // (3) Get Signal Quality (EVM)
5402 if(bpacket_match_bssid)
5406 if(pstats->RxPWDBAll > 40)
5411 sq = pcck_buf->sq_rpt;
5413 if(pcck_buf->sq_rpt > 64)
5415 else if (pcck_buf->sq_rpt < 20)
5418 sq = ((64-sq) * 100) / 44;
5420 pstats->SignalQuality = precord_stats->SignalQuality = sq;
5421 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5422 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5427 priv->stats.numqry_phystatusHT++;
5429 // (1)Get RSSI for HT rate
5431 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5433 // 2008/01/30 MH we will judge RF RX path now.
5434 if (priv->brfpath_rxenable[i])
5439 //Fixed by Jacken from Bryant 2008-03-20
5440 //Original value is 106
5441 #ifdef RTL8190P //Modify by Jacken 2008/03/31
5442 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5444 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 110;
5447 //Get Rx snr value in DB
5448 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5449 rx_snrX = (char)(tmp_rxsnr);
5451 priv->stats.rxSNRdB[i] = (long)rx_snrX;
5453 /* Translate DBM to percentage. */
5454 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5455 if (priv->brfpath_rxenable[i])
5458 /* Record Signal Strength for next packet */
5459 if(bpacket_match_bssid)
5461 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5462 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5468 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5470 //Fixed by Jacken from Bryant 2008-03-20
5471 //Original value is 106
5472 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5473 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5475 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5476 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5477 pstats->RecvSignalPower = rx_pwr_all;
5479 // (3)EVM of HT rate
5481 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5482 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5483 max_spatial_stream = 2; //both spatial stream make sense
5485 max_spatial_stream = 1; //only spatial stream 1 makes sense
5487 for(i=0; i<max_spatial_stream; i++)
5489 tmp_rxevm = pofdm_buf->rxevm_X[i];
5490 rx_evmX = (char)(tmp_rxevm);
5492 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5493 // fill most significant bit to "zero" when doing shifting operation which may change a negative
5494 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5497 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5499 EVM = SignalScaleMapping(EVM);//make it good looking, from 0~100
5501 if(bpacket_match_bssid)
5503 if(i==0) // Fill value in RFD, Get the first spatial stream only
5504 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5505 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5510 /* record rx statistics for debug */
5511 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5512 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5513 if(pdrvinfo->BW) //40M channel
5514 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5516 priv->stats.received_bwtype[0]++;
5519 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5520 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5523 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5528 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u1Byte)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u1Byte)(total_rssi/=RF90_PATH_MAX);
5529 // We can judge RX path number now.
5531 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5536 rtl8192_record_rxdesc_forlateruse(
5537 struct ieee80211_rx_stats * psrc_stats,
5538 struct ieee80211_rx_stats * ptarget_stats
5541 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5542 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5543 //ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5548 static void TranslateRxSignalStuff819xpci(struct net_device *dev,
5549 struct sk_buff *skb,
5550 struct ieee80211_rx_stats * pstats,
5551 prx_desc_819x_pci pdesc,
5552 prx_fwinfo_819x_pci pdrvinfo)
5554 // TODO: We must only check packet for current MAC address. Not finish
5555 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5556 bool bpacket_match_bssid, bpacket_toself;
5557 bool bPacketBeacon=false, bToSelfBA=false;
5558 static struct ieee80211_rx_stats previous_stats;
5559 struct ieee80211_hdr_3addr *hdr;
5562 // Get Signal Quality for only RX data queue (but not command queue)
5567 /* Get MAC frame start address. */
5568 tmp_buf = skb->data;
5570 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5571 fc = le16_to_cpu(hdr->frame_ctl);
5572 type = WLAN_FC_GET_TYPE(fc);
5573 praddr = hdr->addr1;
5575 /* Check if the received packet is acceptabe. */
5576 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5577 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5578 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5579 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5581 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5583 bPacketBeacon = true;
5584 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5586 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5588 if((eqMacAddr(praddr,dev->dev_addr)))
5590 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5594 if(bpacket_match_bssid)
5596 priv->stats.numpacket_matchbssid++;
5599 priv->stats.numpacket_toself++;
5602 // Process PHY information for previous packet (RSSI/PWDB/EVM)
5604 // Because phy information is contained in the last packet of AMPDU only, so driver
5605 // should process phy information of previous packet
5606 rtl8192_process_phyinfo(priv, tmp_buf,&previous_stats, pstats);
5607 rtl8192_query_rxphystatus(priv, pstats, pdesc, pdrvinfo, &previous_stats, bpacket_match_bssid,
5608 bpacket_toself ,bPacketBeacon, bToSelfBA);
5609 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
5614 static void rtl8192_tx_resume(struct net_device *dev)
5616 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5617 struct ieee80211_device *ieee = priv->ieee80211;
5618 struct sk_buff *skb;
5621 for(queue_index = BK_QUEUE; queue_index < TXCMD_QUEUE;queue_index++) {
5622 while((!skb_queue_empty(&ieee->skb_waitQ[queue_index]))&&
5623 (priv->ieee80211->check_nic_enough_desc(dev,queue_index) > 0)) {
5624 /* 1. dequeue the packet from the wait queue */
5625 skb = skb_dequeue(&ieee->skb_waitQ[queue_index]);
5626 /* 2. tx the packet directly */
5627 ieee->softmac_data_hard_start_xmit(skb,dev,0/* rate useless now*/);
5629 if(queue_index!=MGNT_QUEUE) {
5630 ieee->stats.tx_packets++;
5631 ieee->stats.tx_bytes += skb->len;
5638 static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv)
5640 rtl8192_tx_resume(priv->ieee80211->dev);
5643 /* Record the received data rate */
5644 static void UpdateReceivedRateHistogramStatistics8190(
5645 struct net_device *dev,
5646 struct ieee80211_rx_stats* pstats
5649 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5650 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
5652 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
5656 else if(pstats->bICV)
5659 if(pstats->bShortPreamble)
5660 preamble_guardinterval = 1;// short
5662 preamble_guardinterval = 0;// long
5664 switch(pstats->rate)
5669 case MGN_1M: rateIndex = 0; break;
5670 case MGN_2M: rateIndex = 1; break;
5671 case MGN_5_5M: rateIndex = 2; break;
5672 case MGN_11M: rateIndex = 3; break;
5676 case MGN_6M: rateIndex = 4; break;
5677 case MGN_9M: rateIndex = 5; break;
5678 case MGN_12M: rateIndex = 6; break;
5679 case MGN_18M: rateIndex = 7; break;
5680 case MGN_24M: rateIndex = 8; break;
5681 case MGN_36M: rateIndex = 9; break;
5682 case MGN_48M: rateIndex = 10; break;
5683 case MGN_54M: rateIndex = 11; break;
5685 // 11n High throughput rate
5687 case MGN_MCS0: rateIndex = 12; break;
5688 case MGN_MCS1: rateIndex = 13; break;
5689 case MGN_MCS2: rateIndex = 14; break;
5690 case MGN_MCS3: rateIndex = 15; break;
5691 case MGN_MCS4: rateIndex = 16; break;
5692 case MGN_MCS5: rateIndex = 17; break;
5693 case MGN_MCS6: rateIndex = 18; break;
5694 case MGN_MCS7: rateIndex = 19; break;
5695 case MGN_MCS8: rateIndex = 20; break;
5696 case MGN_MCS9: rateIndex = 21; break;
5697 case MGN_MCS10: rateIndex = 22; break;
5698 case MGN_MCS11: rateIndex = 23; break;
5699 case MGN_MCS12: rateIndex = 24; break;
5700 case MGN_MCS13: rateIndex = 25; break;
5701 case MGN_MCS14: rateIndex = 26; break;
5702 case MGN_MCS15: rateIndex = 27; break;
5703 default: rateIndex = 28; break;
5705 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
5706 priv->stats.received_rate_histogram[0][rateIndex]++; //total
5707 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
5710 static void rtl8192_rx(struct net_device *dev)
5712 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5713 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
5714 bool unicast_packet = false;
5715 struct ieee80211_rx_stats stats = {
5719 .freq = IEEE80211_24GHZ_BAND,
5721 unsigned int count = priv->rxringcount;
5723 stats.nic_type = NIC_8192E;
5726 rx_desc_819x_pci *pdesc = &priv->rx_ring[priv->rx_idx];//rx descriptor
5727 struct sk_buff *skb = priv->rx_buf[priv->rx_idx];//rx pkt
5730 /* wait data to be filled by hardware */
5733 stats.bICV = pdesc->ICV;
5734 stats.bCRC = pdesc->CRC32;
5735 stats.bHwError = pdesc->CRC32 | pdesc->ICV;
5737 stats.Length = pdesc->Length;
5738 if(stats.Length < 24)
5739 stats.bHwError |= 1;
5741 if(stats.bHwError) {
5742 stats.bShift = false;
5745 if (pdesc->Length <500)
5746 priv->stats.rxcrcerrmin++;
5747 else if (pdesc->Length >1000)
5748 priv->stats.rxcrcerrmax++;
5750 priv->stats.rxcrcerrmid++;
5754 prx_fwinfo_819x_pci pDrvInfo = NULL;
5755 struct sk_buff *new_skb = dev_alloc_skb(priv->rxbuffersize);
5757 if (unlikely(!new_skb)) {
5761 stats.RxDrvInfoSize = pdesc->RxDrvInfoSize;
5762 stats.RxBufShift = ((pdesc->Shift)&0x03);
5763 stats.Decrypted = !pdesc->SWDec;
5765 pci_dma_sync_single_for_cpu(priv->pdev,
5766 *((dma_addr_t *)skb->cb),
5768 PCI_DMA_FROMDEVICE);
5769 skb_put(skb, pdesc->Length);
5770 pDrvInfo = (rx_fwinfo_819x_pci *)(skb->data + stats.RxBufShift);
5771 skb_reserve(skb, stats.RxDrvInfoSize + stats.RxBufShift);
5773 stats.rate = HwRateToMRate90((bool)pDrvInfo->RxHT, (u8)pDrvInfo->RxRate);
5774 stats.bShortPreamble = pDrvInfo->SPLCP;
5776 /* it is debug only. It should be disabled in released driver.
5777 * 2007.1.11 by Emily
5779 UpdateReceivedRateHistogramStatistics8190(dev, &stats);
5781 stats.bIsAMPDU = (pDrvInfo->PartAggr==1);
5782 stats.bFirstMPDU = (pDrvInfo->PartAggr==1) && (pDrvInfo->FirstAGGR==1);
5784 stats.TimeStampLow = pDrvInfo->TSFL;
5785 stats.TimeStampHigh = read_nic_dword(dev, TSFR+4);
5787 UpdateRxPktTimeStamp8190(dev, &stats);
5790 // Get Total offset of MPDU Frame Body
5792 if((stats.RxBufShift + stats.RxDrvInfoSize) > 0)
5795 stats.RxIs40MHzPacket = pDrvInfo->BW;
5798 TranslateRxSignalStuff819xpci(dev,skb, &stats, pdesc, pDrvInfo);
5801 if(pDrvInfo->FirstAGGR==1 || pDrvInfo->PartAggr == 1)
5802 RT_TRACE(COMP_RXDESC, "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
5803 pDrvInfo->FirstAGGR, pDrvInfo->PartAggr);
5804 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5805 /* rx packets statistics */
5806 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5807 unicast_packet = false;
5809 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5811 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5814 /* unicast packet */
5815 unicast_packet = true;
5818 stats.packetlength = stats.Length-4;
5819 stats.fraglength = stats.packetlength;
5820 stats.fragoffset = 0;
5821 stats.ntotalfrag = 1;
5823 if(!ieee80211_rtl_rx(priv->ieee80211, skb, &stats)){
5824 dev_kfree_skb_any(skb);
5827 if(unicast_packet) {
5828 priv->stats.rxbytesunicast += skb->len;
5833 priv->rx_buf[priv->rx_idx] = skb;
5834 *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev, skb_tail_pointer(skb), priv->rxbuffersize, PCI_DMA_FROMDEVICE);
5839 pdesc->BufferAddress = cpu_to_le32(*((dma_addr_t *)skb->cb));
5841 pdesc->Length = priv->rxbuffersize;
5842 if (priv->rx_idx == priv->rxringcount-1)
5844 priv->rx_idx = (priv->rx_idx + 1) % priv->rxringcount;
5849 static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
5851 rtl8192_rx(priv->ieee80211->dev);
5853 write_nic_dword(priv->ieee80211->dev, INTA_MASK,read_nic_dword(priv->ieee80211->dev, INTA_MASK) | IMR_RDU);
5856 static const struct net_device_ops rtl8192_netdev_ops = {
5857 .ndo_open = rtl8192_open,
5858 .ndo_stop = rtl8192_close,
5859 .ndo_tx_timeout = tx_timeout,
5860 .ndo_do_ioctl = rtl8192_ioctl,
5861 .ndo_set_multicast_list = r8192_set_multicast,
5862 .ndo_set_mac_address = r8192_set_mac_adr,
5863 .ndo_start_xmit = ieee80211_rtl_xmit,
5866 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
5867 const struct pci_device_id *id)
5869 unsigned long ioaddr = 0;
5870 struct net_device *dev = NULL;
5871 struct r8192_priv *priv= NULL;
5875 #ifdef CONFIG_RTL8192_IO_MAP
5876 unsigned long pio_start, pio_len, pio_flags;
5878 unsigned long pmem_start, pmem_len, pmem_flags;
5879 #endif //end #ifdef RTL_IO_MAP
5881 RT_TRACE(COMP_INIT,"Configuring chip resources");
5883 if( pci_enable_device (pdev) ){
5884 RT_TRACE(COMP_ERR,"Failed to enable PCI device");
5888 pci_set_master(pdev);
5889 //pci_set_wmi(pdev);
5890 pci_set_dma_mask(pdev, 0xffffff00ULL);
5891 pci_set_consistent_dma_mask(pdev,0xffffff00ULL);
5892 dev = alloc_ieee80211(sizeof(struct r8192_priv));
5898 pci_set_drvdata(pdev, dev);
5899 SET_NETDEV_DEV(dev, &pdev->dev);
5900 priv = ieee80211_priv(dev);
5901 priv->ieee80211 = netdev_priv(dev);
5903 if((pdev->subsystem_vendor == PCI_VENDOR_ID_DLINK)&&(pdev->subsystem_device == 0x3304)){
5904 priv->ieee80211->bSupportRemoteWakeUp = 1;
5907 priv->ieee80211->bSupportRemoteWakeUp = 0;
5910 #ifdef CONFIG_RTL8192_IO_MAP
5912 pio_start = (unsigned long)pci_resource_start (pdev, 0);
5913 pio_len = (unsigned long)pci_resource_len (pdev, 0);
5914 pio_flags = (unsigned long)pci_resource_flags (pdev, 0);
5916 if (!(pio_flags & IORESOURCE_IO)) {
5917 RT_TRACE(COMP_ERR,"region #0 not a PIO resource, aborting");
5921 //DMESG("IO space @ 0x%08lx", pio_start );
5922 if( ! request_region( pio_start, pio_len, RTL819xE_MODULE_NAME ) ){
5923 RT_TRACE(COMP_ERR,"request_region failed!");
5928 dev->base_addr = ioaddr; // device I/O address
5932 pmem_start = pci_resource_start(pdev, 1);
5933 pmem_len = pci_resource_len(pdev, 1);
5934 pmem_flags = pci_resource_flags (pdev, 1);
5936 if (!(pmem_flags & IORESOURCE_MEM)) {
5937 RT_TRACE(COMP_ERR,"region #1 not a MMIO resource, aborting");
5941 //DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
5942 if( ! request_mem_region(pmem_start, pmem_len, RTL819xE_MODULE_NAME)) {
5943 RT_TRACE(COMP_ERR,"request_mem_region failed!");
5948 ioaddr = (unsigned long)ioremap_nocache( pmem_start, pmem_len);
5949 if( ioaddr == (unsigned long)NULL ){
5950 RT_TRACE(COMP_ERR,"ioremap failed!");
5951 // release_mem_region( pmem_start, pmem_len );
5955 dev->mem_start = ioaddr; // shared mem start
5956 dev->mem_end = ioaddr + pci_resource_len(pdev, 0); // shared mem end
5958 #endif //end #ifdef RTL_IO_MAP
5960 /* We disable the RETRY_TIMEOUT register (0x41) to keep
5961 * PCI Tx retries from interfering with C3 CPU state */
5962 pci_write_config_byte(pdev, 0x41, 0x00);
5965 pci_read_config_byte(pdev, 0x05, &unit);
5966 pci_write_config_byte(pdev, 0x05, unit & (~0x04));
5968 dev->irq = pdev->irq;
5971 dev->netdev_ops = &rtl8192_netdev_ops;
5973 dev->open = rtl8192_open;
5974 dev->stop = rtl8192_close;
5975 //dev->hard_start_xmit = rtl8192_8023_hard_start_xmit;
5976 dev->tx_timeout = tx_timeout;
5977 //dev->wireless_handlers = &r8192_wx_handlers_def;
5978 dev->do_ioctl = rtl8192_ioctl;
5979 dev->set_multicast_list = r8192_set_multicast;
5980 dev->set_mac_address = r8192_set_mac_adr;
5983 //DMESG("Oops: i'm coming\n");
5984 #if WIRELESS_EXT >= 12
5985 #if WIRELESS_EXT < 17
5986 dev->get_wireless_stats = r8192_get_wireless_stats;
5988 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
5990 //dev->get_wireless_stats = r8192_get_wireless_stats;
5991 dev->type=ARPHRD_ETHER;
5993 dev->watchdog_timeo = HZ*3; //modified by john, 0805
5995 if (dev_alloc_name(dev, ifname) < 0){
5996 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
5997 strcpy(ifname, "wlan%d");
5998 dev_alloc_name(dev, ifname);
6001 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
6002 if(rtl8192_init(dev)!=0){
6003 RT_TRACE(COMP_ERR, "Initialization failed");
6007 netif_carrier_off(dev);
6008 netif_stop_queue(dev);
6010 register_netdev(dev);
6011 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
6012 rtl8192_proc_init_one(dev);
6015 RT_TRACE(COMP_INIT, "Driver probe completed\n");
6020 #ifdef CONFIG_RTL8180_IO_MAP
6022 if( dev->base_addr != 0 ){
6024 release_region(dev->base_addr,
6025 pci_resource_len(pdev, 0) );
6028 if( dev->mem_start != (unsigned long)NULL ){
6029 iounmap( (void *)dev->mem_start );
6030 release_mem_region( pci_resource_start(pdev, 1),
6031 pci_resource_len(pdev, 1) );
6033 #endif //end #ifdef RTL_IO_MAP
6039 free_irq(dev->irq, dev);
6042 free_ieee80211(dev);
6046 pci_disable_device(pdev);
6048 DMESG("wlan driver load failed\n");
6049 pci_set_drvdata(pdev, NULL);
6054 /* detach all the work and timer structure declared or inititialized
6055 * in r8192_init function.
6057 static void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
6059 /* call cancel_work_sync instead of cancel_delayed_work if and only if Linux_version_code
6060 * is or is newer than 2.6.20 and work structure is defined to be struct work_struct.
6061 * Otherwise call cancel_delayed_work is enough.
6062 * FIXME (2.6.20 should 2.6.22, work_struct should not cancel)
6064 cancel_delayed_work(&priv->watch_dog_wq);
6065 cancel_delayed_work(&priv->update_beacon_wq);
6066 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
6067 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
6069 cancel_delayed_work(&priv->gpio_change_rf_wq);
6071 cancel_work_sync(&priv->reset_wq);
6072 cancel_work_sync(&priv->qos_activate);
6073 //cancel_work_sync(&priv->SetBWModeWorkItem);
6074 //cancel_work_sync(&priv->SwChnlWorkItem);
6079 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev)
6081 struct net_device *dev = pci_get_drvdata(pdev);
6082 struct r8192_priv *priv ;
6086 unregister_netdev(dev);
6088 priv=ieee80211_priv(dev);
6090 rtl8192_proc_remove_one(dev);
6093 if (priv->pFirmware)
6095 vfree(priv->pFirmware);
6096 priv->pFirmware = NULL;
6098 // priv->rf_close(dev);
6099 // rtl8192_usb_deleteendpoints(dev);
6100 destroy_workqueue(priv->priv_wq);
6101 /* redundant with rtl8192_down */
6102 // rtl8192_irq_disable(dev);
6103 // rtl8192_reset(dev);
6107 /* free tx/rx rings */
6108 rtl8192_free_rx_ring(dev);
6109 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
6110 rtl8192_free_tx_ring(dev, i);
6115 printk("Freeing irq %d\n",dev->irq);
6116 free_irq(dev->irq, dev);
6123 // free_beacon_desc_ring(dev,priv->txbeaconcount);
6125 #ifdef CONFIG_RTL8180_IO_MAP
6127 if( dev->base_addr != 0 ){
6129 release_region(dev->base_addr,
6130 pci_resource_len(pdev, 0) );
6133 if( dev->mem_start != (unsigned long)NULL ){
6134 iounmap( (void *)dev->mem_start );
6135 release_mem_region( pci_resource_start(pdev, 1),
6136 pci_resource_len(pdev, 1) );
6138 #endif /*end #ifdef RTL_IO_MAP*/
6139 free_ieee80211(dev);
6143 pci_disable_device(pdev);
6144 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
6147 extern int ieee80211_rtl_init(void);
6148 extern void ieee80211_rtl_exit(void);
6150 static int __init rtl8192_pci_module_init(void)
6154 retval = ieee80211_rtl_init();
6158 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
6159 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
6160 RT_TRACE(COMP_INIT, "Initializing module");
6161 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
6162 rtl8192_proc_module_init();
6163 if(0!=pci_register_driver(&rtl8192_pci_driver))
6165 DMESG("No device found");
6166 /*pci_unregister_driver (&rtl8192_pci_driver);*/
6173 static void __exit rtl8192_pci_module_exit(void)
6175 pci_unregister_driver(&rtl8192_pci_driver);
6177 RT_TRACE(COMP_DOWN, "Exiting");
6178 rtl8192_proc_module_remove();
6179 ieee80211_rtl_exit();
6182 //warning message WB
6183 static irqreturn_t rtl8192_interrupt(int irq, void *netdev)
6185 struct net_device *dev = (struct net_device *) netdev;
6186 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6187 unsigned long flags;
6189 /* We should return IRQ_NONE, but for now let me keep this */
6190 if(priv->irq_enabled == 0){
6194 spin_lock_irqsave(&priv->irq_th_lock,flags);
6198 inta = read_nic_dword(dev, ISR);// & priv->IntrMask;
6199 write_nic_dword(dev,ISR,inta); // reset int situation
6201 priv->stats.shints++;
6202 //DMESG("Enter interrupt, ISR value = 0x%08x", inta);
6204 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6207 most probably we can safely return IRQ_NONE,
6208 but for now is better to avoid problems
6214 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6220 DMESG("NIC irq %x",inta);
6222 //priv->irqpending = inta;
6225 if(!netif_running(dev)) {
6226 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6230 if(inta & IMR_TIMEOUT0){
6231 // write_nic_dword(dev, TimerInt, 0);
6232 //DMESG("=================>waking up");
6233 // rtl8180_hw_wakeup(dev);
6236 if(inta & IMR_TBDOK){
6237 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6238 rtl8192_tx_isr(dev, BEACON_QUEUE);
6239 priv->stats.txbeaconokint++;
6242 if(inta & IMR_TBDER){
6243 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6244 rtl8192_tx_isr(dev, BEACON_QUEUE);
6245 priv->stats.txbeaconerr++;
6248 if(inta & IMR_MGNTDOK ) {
6249 RT_TRACE(COMP_INTR, "Manage ok interrupt!\n");
6250 priv->stats.txmanageokint++;
6251 rtl8192_tx_isr(dev,MGNT_QUEUE);
6255 if(inta & IMR_COMDOK)
6257 priv->stats.txcmdpktokint++;
6258 rtl8192_tx_isr(dev,TXCMD_QUEUE);
6263 DMESG("Frame arrived !");
6265 priv->stats.rxint++;
6266 tasklet_schedule(&priv->irq_rx_tasklet);
6269 if(inta & IMR_BcnInt) {
6270 RT_TRACE(COMP_INTR, "prepare beacon for interrupt!\n");
6271 tasklet_schedule(&priv->irq_prepare_beacon_tasklet);
6275 RT_TRACE(COMP_INTR, "rx descriptor unavailable!\n");
6276 priv->stats.rxrdu++;
6277 /* reset int situation */
6278 write_nic_dword(dev,INTA_MASK,read_nic_dword(dev, INTA_MASK) & ~IMR_RDU);
6279 tasklet_schedule(&priv->irq_rx_tasklet);
6282 if(inta & IMR_RXFOVW){
6283 RT_TRACE(COMP_INTR, "rx overflow !\n");
6284 priv->stats.rxoverflow++;
6285 tasklet_schedule(&priv->irq_rx_tasklet);
6288 if(inta & IMR_TXFOVW) priv->stats.txoverflow++;
6290 if(inta & IMR_BKDOK){
6291 RT_TRACE(COMP_INTR, "BK Tx OK interrupt!\n");
6292 priv->stats.txbkokint++;
6293 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6294 rtl8192_tx_isr(dev,BK_QUEUE);
6295 rtl8192_try_wake_queue(dev, BK_QUEUE);
6298 if(inta & IMR_BEDOK){
6299 RT_TRACE(COMP_INTR, "BE TX OK interrupt!\n");
6300 priv->stats.txbeokint++;
6301 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6302 rtl8192_tx_isr(dev,BE_QUEUE);
6303 rtl8192_try_wake_queue(dev, BE_QUEUE);
6306 if(inta & IMR_VIDOK){
6307 RT_TRACE(COMP_INTR, "VI TX OK interrupt!\n");
6308 priv->stats.txviokint++;
6309 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6310 rtl8192_tx_isr(dev,VI_QUEUE);
6311 rtl8192_try_wake_queue(dev, VI_QUEUE);
6314 if(inta & IMR_VODOK){
6315 priv->stats.txvookint++;
6316 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6317 rtl8192_tx_isr(dev,VO_QUEUE);
6318 rtl8192_try_wake_queue(dev, VO_QUEUE);
6321 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6326 static void rtl8192_try_wake_queue(struct net_device *dev, int pri)
6331 void EnableHWSecurityConfig8192(struct net_device *dev)
6333 u8 SECR_value = 0x0;
6334 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6335 struct ieee80211_device* ieee = priv->ieee80211;
6337 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
6339 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
6341 SECR_value |= SCR_RxUseDK;
6342 SECR_value |= SCR_TxUseDK;
6344 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
6346 SECR_value |= SCR_RxUseDK;
6347 SECR_value |= SCR_TxUseDK;
6352 //add HWSec active enable here.
6353 //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
6354 ieee->hwsec_active = 1;
6356 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
6358 ieee->hwsec_active = 0;
6359 SECR_value &= ~SCR_RxDecEnable;
6362 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__,
6363 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
6365 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
6369 #define TOTAL_CAM_ENTRY 32
6370 //#define CAM_CONTENT_COUNT 8
6371 void setKey( struct net_device *dev,
6379 u32 TargetCommand = 0;
6380 u32 TargetContent = 0;
6384 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6385 RT_RF_POWER_STATE rtState;
6386 rtState = priv->ieee80211->eRFPowerState;
6387 if(priv->ieee80211->PowerSaveControl.bInactivePs){
6388 if(rtState == eRfOff){
6389 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
6391 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
6392 //up(&priv->wx_sem);
6396 down(&priv->ieee80211->ips_sem);
6398 up(&priv->ieee80211->ips_sem);
6402 priv->ieee80211->is_set_key = true;
6404 if (EntryNo >= TOTAL_CAM_ENTRY)
6405 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
6407 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
6410 usConfig |= BIT15 | (KeyType<<2);
6412 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
6413 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
6416 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
6417 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
6418 TargetCommand |= BIT31|BIT16;
6420 if(i==0){//MAC|Config
6421 TargetContent = (u32)(*(MacAddr+0)) << 16|
6422 (u32)(*(MacAddr+1)) << 24|
6425 write_nic_dword(dev, WCAMI, TargetContent);
6426 write_nic_dword(dev, RWCAM, TargetCommand);
6427 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6430 TargetContent = (u32)(*(MacAddr+2)) |
6431 (u32)(*(MacAddr+3)) << 8|
6432 (u32)(*(MacAddr+4)) << 16|
6433 (u32)(*(MacAddr+5)) << 24;
6434 write_nic_dword(dev, WCAMI, TargetContent);
6435 write_nic_dword(dev, RWCAM, TargetCommand);
6437 else { //Key Material
6438 if(KeyContent != NULL)
6440 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6441 write_nic_dword(dev, RWCAM, TargetCommand);
6445 RT_TRACE(COMP_SEC,"=========>after set key, usconfig:%x\n", usConfig);
6448 bool NicIFEnableNIC(struct net_device* dev)
6450 RT_STATUS init_status = RT_STATUS_SUCCESS;
6451 struct r8192_priv* priv = ieee80211_priv(dev);
6452 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
6456 RT_TRACE(COMP_ERR, "ERR!!! %s(): Driver is already down!\n",__FUNCTION__);
6457 priv->bdisable_nic = false; //YJ,add,091111
6460 // <1> Reset memory: descriptor, buffer,..
6461 //NicIFResetMemory(Adapter);
6463 // <2> Enable Adapter
6464 //priv->bfirst_init = true;
6465 init_status = rtl8192_adapter_start(dev);
6466 if (init_status != RT_STATUS_SUCCESS) {
6467 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
6468 priv->bdisable_nic = false; //YJ,add,091111
6471 //printk("start adapter finished\n");
6472 RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
6473 //priv->bfirst_init = false;
6475 // <3> Enable Interrupt
6476 rtl8192_irq_enable(dev);
6477 priv->bdisable_nic = false;
6479 return (init_status == RT_STATUS_SUCCESS);
6482 bool NicIFDisableNIC(struct net_device* dev)
6485 struct r8192_priv* priv = ieee80211_priv(dev);
6487 // <1> Disable Interrupt
6489 priv->bdisable_nic = true; //YJ,move,091109
6490 tmp_state = priv->ieee80211->state;
6492 ieee80211_softmac_stop_protocol(priv->ieee80211, false);
6494 priv->ieee80211->state = tmp_state;
6495 rtl8192_cancel_deferred_work(priv);
6496 rtl8192_irq_disable(dev);
6497 // <2> Stop all timer
6499 // <3> Disable Adapter
6500 rtl8192_halt_adapter(dev, false);
6501 // priv->bdisable_nic = true;
6506 module_init(rtl8192_pci_module_init);
6507 module_exit(rtl8192_pci_module_exit);