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>
29 #undef RX_DONT_PASS_UL
31 #undef DEBUG_RX_VERBOSE
37 #undef DEBUG_TX_FILLDESC
42 #undef DEBUG_REGISTERS
44 #undef DEBUG_IRQ_TASKLET
48 //#define CONFIG_RTL8192_IO_MAP
49 #include <linux/vmalloc.h>
50 #include <linux/slab.h>
51 #include <asm/uaccess.h>
52 #include "r8192E_hw.h"
54 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
55 #include "r8180_93cx6.h" /* Card EEPROM */
56 #include "r8192E_wx.h"
57 #include "r819xE_phy.h" //added by WB 4.30.2008
58 #include "r819xE_phyreg.h"
59 #include "r819xE_cmdpkt.h"
60 #include "r8192E_dm.h"
67 #include "ieee80211/dot11d.h"
70 //set here to open your trace code. //WB
71 u32 rt_global_debug_component =
89 // COMP_POWER_TRACKING |
91 COMP_ERR ; //always open err flags on
93 static const struct pci_device_id rtl8192_pci_id_tbl[] __devinitdata = {
97 { PCI_DEVICE(0x10ec, 0x8190) },
99 { PCI_DEVICE(0x07aa, 0x0045) },
100 { PCI_DEVICE(0x07aa, 0x0046) },
103 { PCI_DEVICE(0x10ec, 0x8192) },
106 { PCI_DEVICE(0x07aa, 0x0044) },
107 { PCI_DEVICE(0x07aa, 0x0047) },
112 static char ifname[IFNAMSIZ] = "wlan%d";
113 static int hwwep = 1; //default use hw. set 0 to use software security
114 static int channels = 0x3fff;
116 MODULE_LICENSE("GPL");
117 MODULE_VERSION("V 1.1");
118 MODULE_DEVICE_TABLE(pci, rtl8192_pci_id_tbl);
119 //MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
120 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
123 module_param_string(ifname, ifname, sizeof(ifname), S_IRUGO|S_IWUSR);
124 //module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
125 module_param(hwwep,int, S_IRUGO|S_IWUSR);
126 module_param(channels,int, S_IRUGO|S_IWUSR);
128 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
129 //MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
130 MODULE_PARM_DESC(hwwep," Try to use hardware WEP support. Still broken and not available on all cards");
131 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
133 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
134 const struct pci_device_id *id);
135 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev);
137 static struct pci_driver rtl8192_pci_driver = {
138 .name = RTL819xE_MODULE_NAME, /* Driver name */
139 .id_table = rtl8192_pci_id_tbl, /* PCI_ID table */
140 .probe = rtl8192_pci_probe, /* probe fn */
141 .remove = __devexit_p(rtl8192_pci_disconnect), /* remove fn */
143 .suspend = rtl8192E_suspend, /* PM suspend fn */
144 .resume = rtl8192E_resume, /* PM resume fn */
146 .suspend = NULL, /* PM suspend fn */
147 .resume = NULL, /* PM resume fn */
151 static void rtl8192_start_beacon(struct net_device *dev);
152 static void rtl8192_stop_beacon(struct net_device *dev);
153 static void rtl819x_watchdog_wqcallback(struct work_struct *work);
154 static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
155 static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv);
156 static void rtl8192_prepare_beacon(struct r8192_priv *priv);
157 static irqreturn_t rtl8192_interrupt(int irq, void *netdev);
158 static void rtl8192_try_wake_queue(struct net_device *dev, int pri);
159 static void rtl819xE_tx_cmd(struct net_device *dev, struct sk_buff *skb);
160 static void rtl8192_update_ratr_table(struct net_device* dev);
161 static void rtl8192_restart(struct work_struct *work);
162 static void watch_dog_timer_callback(unsigned long data);
163 static int _rtl8192_up(struct net_device *dev);
164 static void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
168 typedef struct _CHANNEL_LIST
172 }CHANNEL_LIST, *PCHANNEL_LIST;
174 static const CHANNEL_LIST ChannelPlan[] = {
175 {{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
176 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
179 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
180 {{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
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
182 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
183 {{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
184 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
185 {{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
188 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
190 int i, max_chan=-1, min_chan=-1;
191 struct ieee80211_device* ieee = priv->ieee80211;
192 switch (channel_plan)
194 case COUNTRY_CODE_FCC:
195 case COUNTRY_CODE_IC:
196 case COUNTRY_CODE_ETSI:
197 case COUNTRY_CODE_SPAIN:
198 case COUNTRY_CODE_FRANCE:
199 case COUNTRY_CODE_MKK:
200 case COUNTRY_CODE_MKK1:
201 case COUNTRY_CODE_ISRAEL:
202 case COUNTRY_CODE_TELEC:
203 case COUNTRY_CODE_MIC:
206 ieee->bGlobalDomain = false;
207 //acturally 8225 & 8256 rf chip only support B,G,24N mode
208 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256))
215 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
217 if (ChannelPlan[channel_plan].Len != 0){
218 // Clear old channel map
219 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
220 // Set new channel map
221 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
223 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
225 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
230 case COUNTRY_CODE_GLOBAL_DOMAIN:
232 GET_DOT11D_INFO(ieee)->bEnabled = 0; //this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain setting
234 ieee->bGlobalDomain = true;
244 #define eqMacAddr(a,b) ( ((a)[0]==(b)[0] && (a)[1]==(b)[1] && (a)[2]==(b)[2] && (a)[3]==(b)[3] && (a)[4]==(b)[4] && (a)[5]==(b)[5]) ? 1:0 )
245 /* 2007/07/25 MH Defien temp tx fw info. */
246 static TX_FWINFO_T Tmp_TxFwInfo;
249 #define rx_hal_is_cck_rate(_pdrvinfo)\
250 (_pdrvinfo->RxRate == DESC90_RATE1M ||\
251 _pdrvinfo->RxRate == DESC90_RATE2M ||\
252 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
253 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
257 void CamResetAllEntry(struct net_device *dev)
263 ulcommand |= BIT31|BIT30;
264 write_nic_dword(dev, RWCAM, ulcommand);
266 for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
267 CAM_mark_invalid(dev, ucIndex);
268 for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
269 CAM_empty_entry(dev, ucIndex);
274 void write_cam(struct net_device *dev, u8 addr, u32 data)
276 write_nic_dword(dev, WCAMI, data);
277 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
279 u32 read_cam(struct net_device *dev, u8 addr)
281 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
282 return read_nic_dword(dev, 0xa8);
285 ////////////////////////////////////////////////////////////
286 #ifdef CONFIG_RTL8180_IO_MAP
288 u8 read_nic_byte(struct net_device *dev, int x)
290 return 0xff&inb(dev->base_addr +x);
293 u32 read_nic_dword(struct net_device *dev, int x)
295 return inl(dev->base_addr +x);
298 u16 read_nic_word(struct net_device *dev, int x)
300 return inw(dev->base_addr +x);
303 void write_nic_byte(struct net_device *dev, int x,u8 y)
305 outb(y&0xff,dev->base_addr +x);
308 void write_nic_word(struct net_device *dev, int x,u16 y)
310 outw(y,dev->base_addr +x);
313 void write_nic_dword(struct net_device *dev, int x,u32 y)
315 outl(y,dev->base_addr +x);
318 #else /* RTL_IO_MAP */
320 u8 read_nic_byte(struct net_device *dev, int x)
322 return 0xff&readb((u8*)dev->mem_start +x);
325 u32 read_nic_dword(struct net_device *dev, int x)
327 return readl((u8*)dev->mem_start +x);
330 u16 read_nic_word(struct net_device *dev, int x)
332 return readw((u8*)dev->mem_start +x);
335 void write_nic_byte(struct net_device *dev, int x,u8 y)
337 writeb(y,(u8*)dev->mem_start +x);
341 void write_nic_dword(struct net_device *dev, int x,u32 y)
343 writel(y,(u8*)dev->mem_start +x);
347 void write_nic_word(struct net_device *dev, int x,u16 y)
349 writew(y,(u8*)dev->mem_start +x);
353 #endif /* RTL_IO_MAP */
355 u8 rtl8192e_ap_sec_type(struct ieee80211_device *ieee)
357 //struct r8192_priv* priv = ieee80211_priv(dev);
358 //struct ieee80211_device *ieee = priv->ieee80211;
360 static const u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
361 static const u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
362 int wpa_ie_len= ieee->wpa_ie_len;
363 struct ieee80211_crypt_data* crypt;
366 crypt = ieee->crypt[ieee->tx_keyidx];
368 encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY) ||
369 (ieee->host_encrypt && crypt && crypt->ops &&
370 (0 == strcmp(crypt->ops->name,"WEP")));
373 if(encrypt && (wpa_ie_len == 0)) {
374 // wep encryption, no N mode setting */
376 } else if((wpa_ie_len != 0)) {
377 // parse pairwise key type */
378 if (((ieee->wpa_ie[0] == 0xdd) && (!memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) ||
379 ((ieee->wpa_ie[0] == 0x30) && (!memcmp(&ieee->wpa_ie[10],ccmp_rsn_ie, 4))))
389 rtl8192e_SetHwReg(struct net_device *dev,u8 variable,u8* val)
391 struct r8192_priv* priv = ieee80211_priv(dev);
397 write_nic_dword(dev, BSSIDR, ((u32*)(val))[0]);
398 write_nic_word(dev, BSSIDR+2, ((u16*)(val+2))[0]);
401 case HW_VAR_MEDIA_STATUS:
403 RT_OP_MODE OpMode = *((RT_OP_MODE *)(val));
404 //LED_CTL_MODE LedAction = LED_CTL_NO_LINK;
405 u8 btMsr = read_nic_byte(dev, MSR);
411 case RT_OP_MODE_INFRASTRUCTURE:
413 //LedAction = LED_CTL_LINK;
416 case RT_OP_MODE_IBSS:
418 // led link set separate
423 //LedAction = LED_CTL_LINK;
431 write_nic_byte(dev, MSR, btMsr);
433 //priv->ieee80211->LedControlHandler(dev, LedAction);
437 case HW_VAR_CECHK_BSSID:
441 Type = ((u8*)(val))[0];
442 //priv->ieee80211->GetHwRegHandler(dev, HW_VAR_RCR, (u8*)(&RegRCR));
443 RegRCR = read_nic_dword(dev,RCR);
444 priv->ReceiveConfig = RegRCR;
447 RegRCR |= (RCR_CBSSID);
448 else if (Type == false)
449 RegRCR &= (~RCR_CBSSID);
451 //priv->ieee80211->SetHwRegHandler( dev, HW_VAR_RCR, (u8*)(&RegRCR) );
452 write_nic_dword(dev, RCR,RegRCR);
453 priv->ReceiveConfig = RegRCR;
458 case HW_VAR_SLOT_TIME:
460 //PSTA_QOS pStaQos = Adapter->MgntInfo.pStaQos;
463 priv->slot_time = val[0];
464 write_nic_byte(dev, SLOT_TIME, val[0]);
469 case HW_VAR_ACK_PREAMBLE:
472 priv->short_preamble = (bool)(*(u8*)val );
473 regTmp = priv->basic_rate;
474 if (priv->short_preamble)
475 regTmp |= BRSR_AckShortPmb;
476 write_nic_dword(dev, RRSR, regTmp);
481 write_nic_dword(dev, CPU_GEN, ((u32*)(val))[0]);
491 ///////////////////////////////////////////////////////////
493 //u8 read_phy_cck(struct net_device *dev, u8 adr);
494 //u8 read_phy_ofdm(struct net_device *dev, u8 adr);
495 /* this might still called in what was the PHY rtl8185/rtl8192 common code
496 * plans are to possibilty turn it again in one common code...
498 void force_pci_posting(struct net_device *dev)
503 //static struct net_device_stats *rtl8192_stats(struct net_device *dev);
504 //void rtl8192_rq_tx_ack(struct work_struct *work);
506 /****************************************************************************
507 -----------------------------PROCFS STUFF-------------------------
508 *****************************************************************************/
510 static struct proc_dir_entry *rtl8192_proc = NULL;
514 static int proc_get_stats_ap(char *page, char **start,
515 off_t offset, int count,
516 int *eof, void *data)
518 struct net_device *dev = data;
519 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
520 struct ieee80211_device *ieee = priv->ieee80211;
521 struct ieee80211_network *target;
525 list_for_each_entry(target, &ieee->network_list, list) {
527 len += snprintf(page + len, count - len,
528 "%s ", target->ssid);
530 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
531 len += snprintf(page + len, count - len,
535 len += snprintf(page + len, count - len,
545 static int proc_get_registers(char *page, char **start,
546 off_t offset, int count,
547 int *eof, void *data)
549 struct net_device *dev = data;
550 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
557 /* This dump the current register page */
558 len += snprintf(page + len, count - len,
559 "\n####################page 0##################\n ");
563 //printk( "\nD: %2x> ", n);
564 len += snprintf(page + len, count - len,
567 for(i=0;i<16 && n<=max;i++,n++)
568 len += snprintf(page + len, count - len,
569 "%2x ",read_nic_byte(dev,n));
571 // printk("%2x ",read_nic_byte(dev,n));
573 len += snprintf(page + len, count - len,"\n");
574 len += snprintf(page + len, count - len,
575 "\n####################page 1##################\n ");
578 //printk( "\nD: %2x> ", n);
579 len += snprintf(page + len, count - len,
582 for(i=0;i<16 && n<=max;i++,n++)
583 len += snprintf(page + len, count - len,
584 "%2x ",read_nic_byte(dev,0x100|n));
586 // printk("%2x ",read_nic_byte(dev,n));
589 len += snprintf(page + len, count - len,
590 "\n####################page 3##################\n ");
593 //printk( "\nD: %2x> ", n);
594 len += snprintf(page + len, count - len,
597 for(i=0;i<16 && n<=max;i++,n++)
598 len += snprintf(page + len, count - len,
599 "%2x ",read_nic_byte(dev,0x300|n));
601 // printk("%2x ",read_nic_byte(dev,n));
612 static int proc_get_stats_tx(char *page, char **start,
613 off_t offset, int count,
614 int *eof, void *data)
616 struct net_device *dev = data;
617 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
621 len += snprintf(page + len, count - len,
622 "TX VI priority ok int: %lu\n"
623 // "TX VI priority error int: %lu\n"
624 "TX VO priority ok int: %lu\n"
625 // "TX VO priority error int: %lu\n"
626 "TX BE priority ok int: %lu\n"
627 // "TX BE priority error int: %lu\n"
628 "TX BK priority ok int: %lu\n"
629 // "TX BK priority error int: %lu\n"
630 "TX MANAGE priority ok int: %lu\n"
631 // "TX MANAGE priority error int: %lu\n"
632 "TX BEACON priority ok int: %lu\n"
633 "TX BEACON priority error int: %lu\n"
634 "TX CMDPKT priority ok int: %lu\n"
635 // "TX high priority ok int: %lu\n"
636 // "TX high priority failed error int: %lu\n"
637 // "TX queue resume: %lu\n"
638 "TX queue stopped?: %d\n"
639 "TX fifo overflow: %lu\n"
640 // "TX beacon: %lu\n"
641 // "TX VI queue: %d\n"
642 // "TX VO queue: %d\n"
643 // "TX BE queue: %d\n"
644 // "TX BK queue: %d\n"
645 // "TX HW queue: %d\n"
646 // "TX VI dropped: %lu\n"
647 // "TX VO dropped: %lu\n"
648 // "TX BE dropped: %lu\n"
649 // "TX BK dropped: %lu\n"
650 "TX total data packets %lu\n"
651 "TX total data bytes :%lu\n",
652 // "TX beacon aborted: %lu\n",
653 priv->stats.txviokint,
654 // priv->stats.txvierr,
655 priv->stats.txvookint,
656 // priv->stats.txvoerr,
657 priv->stats.txbeokint,
658 // priv->stats.txbeerr,
659 priv->stats.txbkokint,
660 // priv->stats.txbkerr,
661 priv->stats.txmanageokint,
662 // priv->stats.txmanageerr,
663 priv->stats.txbeaconokint,
664 priv->stats.txbeaconerr,
665 priv->stats.txcmdpktokint,
666 // priv->stats.txhpokint,
667 // priv->stats.txhperr,
668 // priv->stats.txresumed,
669 netif_queue_stopped(dev),
670 priv->stats.txoverflow,
671 // priv->stats.txbeacon,
672 // atomic_read(&(priv->tx_pending[VI_QUEUE])),
673 // atomic_read(&(priv->tx_pending[VO_QUEUE])),
674 // atomic_read(&(priv->tx_pending[BE_QUEUE])),
675 // atomic_read(&(priv->tx_pending[BK_QUEUE])),
676 // read_nic_byte(dev, TXFIFOCOUNT),
677 // priv->stats.txvidrop,
678 // priv->stats.txvodrop,
679 priv->ieee80211->stats.tx_packets,
680 priv->ieee80211->stats.tx_bytes
683 // priv->stats.txbedrop,
684 // priv->stats.txbkdrop
685 // priv->stats.txdatapkt
686 // priv->stats.txbeaconerr
695 static int proc_get_stats_rx(char *page, char **start,
696 off_t offset, int count,
697 int *eof, void *data)
699 struct net_device *dev = data;
700 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
704 len += snprintf(page + len, count - len,
707 "RX rx overflow error: %lu\n"
708 "RX invalid urb error: %lu\n",
711 priv->stats.rxoverflow,
712 priv->stats.rxurberr);
718 static void rtl8192_proc_module_init(void)
720 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
721 rtl8192_proc=create_proc_entry(RTL819xE_MODULE_NAME, S_IFDIR, init_net.proc_net);
725 static void rtl8192_proc_module_remove(void)
727 remove_proc_entry(RTL819xE_MODULE_NAME, init_net.proc_net);
731 static void rtl8192_proc_remove_one(struct net_device *dev)
733 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
735 printk("dev name=======> %s\n",dev->name);
738 // remove_proc_entry("stats-hw", priv->dir_dev);
739 remove_proc_entry("stats-tx", priv->dir_dev);
740 remove_proc_entry("stats-rx", priv->dir_dev);
741 // remove_proc_entry("stats-ieee", priv->dir_dev);
742 remove_proc_entry("stats-ap", priv->dir_dev);
743 remove_proc_entry("registers", priv->dir_dev);
744 // remove_proc_entry("cck-registers",priv->dir_dev);
745 // remove_proc_entry("ofdm-registers",priv->dir_dev);
746 //remove_proc_entry(dev->name, rtl8192_proc);
747 remove_proc_entry("wlan0", rtl8192_proc);
748 priv->dir_dev = NULL;
753 static void rtl8192_proc_init_one(struct net_device *dev)
755 struct proc_dir_entry *e;
756 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
757 priv->dir_dev = create_proc_entry(dev->name,
758 S_IFDIR | S_IRUGO | S_IXUGO,
760 if (!priv->dir_dev) {
761 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
765 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
766 priv->dir_dev, proc_get_stats_rx, dev);
769 RT_TRACE(COMP_ERR,"Unable to initialize "
770 "/proc/net/rtl8192/%s/stats-rx\n",
775 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
776 priv->dir_dev, proc_get_stats_tx, dev);
779 RT_TRACE(COMP_ERR, "Unable to initialize "
780 "/proc/net/rtl8192/%s/stats-tx\n",
784 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
785 priv->dir_dev, proc_get_stats_ap, dev);
788 RT_TRACE(COMP_ERR, "Unable to initialize "
789 "/proc/net/rtl8192/%s/stats-ap\n",
793 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
794 priv->dir_dev, proc_get_registers, dev);
796 RT_TRACE(COMP_ERR, "Unable to initialize "
797 "/proc/net/rtl8192/%s/registers\n",
801 /****************************************************************************
802 -----------------------------MISC STUFF-------------------------
803 *****************************************************************************/
805 short check_nic_enough_desc(struct net_device *dev, int prio)
807 struct r8192_priv *priv = ieee80211_priv(dev);
808 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
810 /* for now we reserve two free descriptor as a safety boundary
811 * between the tail and the head
813 return (ring->entries - skb_queue_len(&ring->queue) >= 2);
816 static void tx_timeout(struct net_device *dev)
818 struct r8192_priv *priv = ieee80211_priv(dev);
819 //rtl8192_commit(dev);
821 schedule_work(&priv->reset_wq);
826 /****************************************************************************
827 ------------------------------HW STUFF---------------------------
828 *****************************************************************************/
831 static void rtl8192_irq_enable(struct net_device *dev)
833 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
834 priv->irq_enabled = 1;
835 write_nic_dword(dev,INTA_MASK, priv->irq_mask);
839 void rtl8192_irq_disable(struct net_device *dev)
841 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
843 write_nic_dword(dev,INTA_MASK,0);
844 force_pci_posting(dev);
845 priv->irq_enabled = 0;
850 static void rtl8192_set_mode(struct net_device *dev,int mode)
853 ecmd=read_nic_byte(dev, EPROM_CMD);
854 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
855 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
856 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
857 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
858 write_nic_byte(dev, EPROM_CMD, ecmd);
862 void rtl8192_update_msr(struct net_device *dev)
864 struct r8192_priv *priv = ieee80211_priv(dev);
867 msr = read_nic_byte(dev, MSR);
868 msr &= ~ MSR_LINK_MASK;
870 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
871 * msr must be updated if the state is ASSOCIATING.
872 * this is intentional and make sense for ad-hoc and
873 * master (see the create BSS/IBSS func)
875 if (priv->ieee80211->state == IEEE80211_LINKED){
877 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
878 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
879 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
880 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
881 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
882 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
885 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
887 write_nic_byte(dev, MSR, msr);
890 void rtl8192_set_chan(struct net_device *dev,short ch)
892 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
893 RT_TRACE(COMP_RF, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
896 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC ||
897 priv->ieee80211->iw_mode == IW_MODE_MASTER){
899 priv->ieee80211->link_state = WLAN_LINK_ASSOCIATED;
900 priv->ieee80211->master_chan = ch;
901 rtl8192_update_beacon_ch(dev);
905 /* this hack should avoid frame TX during channel setting*/
908 // tx = read_nic_dword(dev,TX_CONF);
909 // tx &= ~TX_LOOPBACK_MASK;
913 // write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
915 //need to implement rf set channel here WB
917 if (priv->rf_set_chan)
918 priv->rf_set_chan(dev,priv->chan);
920 // write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
924 void rtl8192_rx_enable(struct net_device *dev)
926 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
927 write_nic_dword(dev, RDQDA,priv->rx_ring_dma);
930 /* the TX_DESC_BASE setting is according to the following queue index
939 * BEACON_QUEUE ===> 8
941 static const u32 TX_DESC_BASE[] = {BKQDA, BEQDA, VIQDA, VOQDA, HCCAQDA, CQDA, MQDA, HQDA, BQDA};
942 void rtl8192_tx_enable(struct net_device *dev)
944 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
946 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
947 write_nic_dword(dev, TX_DESC_BASE[i], priv->tx_ring[i].dma);
949 ieee80211_reset_queue(priv->ieee80211);
953 static void rtl8192_free_rx_ring(struct net_device *dev)
955 struct r8192_priv *priv = ieee80211_priv(dev);
958 for (i = 0; i < priv->rxringcount; i++) {
959 struct sk_buff *skb = priv->rx_buf[i];
963 pci_unmap_single(priv->pdev,
964 *((dma_addr_t *)skb->cb),
965 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
969 pci_free_consistent(priv->pdev, sizeof(*priv->rx_ring) * priv->rxringcount,
970 priv->rx_ring, priv->rx_ring_dma);
971 priv->rx_ring = NULL;
974 static void rtl8192_free_tx_ring(struct net_device *dev, unsigned int prio)
976 struct r8192_priv *priv = ieee80211_priv(dev);
977 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
979 while (skb_queue_len(&ring->queue)) {
980 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
981 struct sk_buff *skb = __skb_dequeue(&ring->queue);
983 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
984 skb->len, PCI_DMA_TODEVICE);
986 ring->idx = (ring->idx + 1) % ring->entries;
989 pci_free_consistent(priv->pdev, sizeof(*ring->desc)*ring->entries,
990 ring->desc, ring->dma);
995 static void rtl8192_beacon_disable(struct net_device *dev)
997 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1000 reg = read_nic_dword(priv->ieee80211->dev,INTA_MASK);
1002 /* disable Beacon realted interrupt signal */
1003 reg &= ~(IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
1004 write_nic_dword(priv->ieee80211->dev, INTA_MASK, reg);
1008 void PHY_SetRtl8192eRfOff(struct net_device* dev )
1010 //struct r8192_priv *priv = ieee80211_priv(dev);
1012 //disable RF-Chip A/B
1013 rtl8192_setBBreg(dev, rFPGA0_XA_RFInterfaceOE, BIT4, 0x0);
1014 //analog to digital off, for power save
1015 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0x300, 0x0);
1016 //digital to analog off, for power save
1017 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x18, 0x0);
1019 rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, 0xf, 0x0);
1021 rtl8192_setBBreg(dev, rOFDM1_TRxPathEnable, 0xf, 0x0);
1022 //analog to digital part2 off, for power save
1023 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x60, 0x0);
1024 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x4, 0x0);
1025 // Analog parameter!!Change bias and Lbus control.
1026 write_nic_byte(dev, ANAPAR_FOR_8192PciE, 0x07);
1030 void rtl8192_halt_adapter(struct net_device *dev, bool reset)
1033 struct r8192_priv *priv = ieee80211_priv(dev);
1039 OpMode = RT_OP_MODE_NO_LINK;
1040 priv->ieee80211->SetHwRegHandler(dev, HW_VAR_MEDIA_STATUS, &OpMode);
1043 if(!priv->ieee80211->bSupportRemoteWakeUp)
1045 u1bTmp = 0x0; // disable tx/rx. In 8185 we write 0x10 (Reset bit), but here we make reference to WMAC and wirte 0x0. 2006.11.21 Emily
1046 //priv->ieee80211->SetHwRegHandler(dev, HW_VAR_COMMAND, &u1bTmp ); // Using HW_VAR_COMMAND instead of writing CMDR directly. Rewrited by Annie, 2006-04-07.
1047 write_nic_byte(dev, CMDR, u1bTmp);
1050 cmd=read_nic_byte(dev,CMDR);
1051 write_nic_byte(dev, CMDR, cmd &~ (CR_TE|CR_RE));
1058 //PlatformStallExecution(150000);
1062 priv->bHwRfOffAction = 2;
1066 // Call MgntActSet_RF_State instead to prevent RF config race condition.
1067 // By Bruce, 2008-01-17.
1069 if(!priv->ieee80211->bSupportRemoteWakeUp)
1071 //MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_INIT);
1072 //MgntActSet_RF_State(Adapter, eRfOff, Adapter->MgntInfo.RfOffReason);
1073 //if(Adapter->HardwareType == HARDWARE_TYPE_RTL8190P)
1075 PHY_SetRtl8192eRfOff(dev);
1077 // 2006.11.30. System reset bit
1078 //priv->ieee80211->GetHwRegHandler(dev, HW_VAR_CPU_RST, (u32*)(&ulRegRead) );
1079 ulRegRead = read_nic_dword(dev,CPU_GEN);
1080 ulRegRead|=CPU_GEN_SYSTEM_RESET;
1081 //priv->ieee80211->SetHwRegHandler(dev, HW_VAR_CPU_RST, &ulRegRead);
1082 write_nic_dword(dev,CPU_GEN, ulRegRead);
1086 //2008.06.03 for WOL
1087 write_nic_dword(dev, WFCRC0, 0xffffffff);
1088 write_nic_dword(dev, WFCRC1, 0xffffffff);
1089 write_nic_dword(dev, WFCRC2, 0xffffffff);
1091 //Write PMR register
1092 write_nic_byte(dev, PMR, 0x5);
1093 //Disable tx, enanble rx
1094 write_nic_byte(dev, MacBlkCtrl, 0xa);
1098 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
1099 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
1101 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
1102 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
1105 skb_queue_purge(&priv->skb_queue);
1109 static void rtl8192_reset(struct net_device *dev)
1111 rtl8192_irq_disable(dev);
1112 printk("This is RTL819xP Reset procedure\n");
1116 static const u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
1117 inline u16 rtl8192_rate2rate(short rate)
1119 if (rate >11) return 0;
1120 return rtl_rate[rate];
1126 static void rtl8192_data_hard_stop(struct net_device *dev)
1130 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1131 priv->dma_poll_mask |= (1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
1132 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
1133 write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
1134 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
1139 static void rtl8192_data_hard_resume(struct net_device *dev)
1143 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1144 priv->dma_poll_mask &= ~(1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
1145 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
1146 write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
1147 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
1151 /* this function TX data frames when the ieee80211 stack requires this.
1152 * It checks also if we need to stop the ieee tx queue, eventually do it
1154 static void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
1156 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1158 //unsigned long flags;
1159 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1160 u8 queue_index = tcb_desc->queue_index;
1161 /* shall not be referred by command packet */
1162 assert(queue_index != TXCMD_QUEUE);
1164 if (priv->bHwRadioOff ||(!priv->up))
1170 //spin_lock_irqsave(&priv->tx_lock,flags);
1172 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1174 tcb_desc->RATRIndex = 7;
1175 tcb_desc->bTxDisableRateFallBack = 1;
1176 tcb_desc->bTxUseDriverAssingedRate = 1;
1177 tcb_desc->bTxEnableFwCalcDur = 1;
1179 skb_push(skb, priv->ieee80211->tx_headroom);
1180 ret = rtl8192_tx(dev, skb);
1186 if(queue_index!=MGNT_QUEUE) {
1187 priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1188 priv->ieee80211->stats.tx_packets++;
1191 //spin_unlock_irqrestore(&priv->tx_lock,flags);
1196 /* This is a rough attempt to TX a frame
1197 * This is called by the ieee 80211 stack to TX management frames.
1198 * If the ring is full packet are dropped (for data frame the queue
1199 * is stopped before this can happen).
1201 static int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1203 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1207 //unsigned long flags;
1208 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1209 u8 queue_index = tcb_desc->queue_index;
1211 if(queue_index != TXCMD_QUEUE){
1212 if (priv->bHwRadioOff ||(!priv->up))
1219 //spin_lock_irqsave(&priv->tx_lock,flags);
1221 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1222 if(queue_index == TXCMD_QUEUE) {
1223 // skb_push(skb, USB_HWDESC_HEADER_LEN);
1224 rtl819xE_tx_cmd(dev, skb);
1226 //spin_unlock_irqrestore(&priv->tx_lock,flags);
1229 // RT_TRACE(COMP_SEND, "To send management packet\n");
1230 tcb_desc->RATRIndex = 7;
1231 tcb_desc->bTxDisableRateFallBack = 1;
1232 tcb_desc->bTxUseDriverAssingedRate = 1;
1233 tcb_desc->bTxEnableFwCalcDur = 1;
1234 skb_push(skb, priv->ieee80211->tx_headroom);
1235 ret = rtl8192_tx(dev, skb);
1241 // priv->ieee80211->stats.tx_bytes+=skb->len;
1242 // priv->ieee80211->stats.tx_packets++;
1244 //spin_unlock_irqrestore(&priv->tx_lock,flags);
1251 static void rtl8192_tx_isr(struct net_device *dev, int prio)
1253 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1255 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
1257 while (skb_queue_len(&ring->queue)) {
1258 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1259 struct sk_buff *skb;
1261 /* beacon packet will only use the first descriptor defaultly,
1262 * and the OWN may not be cleared by the hardware
1264 if(prio != BEACON_QUEUE) {
1267 ring->idx = (ring->idx + 1) % ring->entries;
1270 skb = __skb_dequeue(&ring->queue);
1271 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1272 skb->len, PCI_DMA_TODEVICE);
1276 if (prio == MGNT_QUEUE){
1277 if (priv->ieee80211->ack_tx_to_ieee){
1278 if (rtl8192_is_tx_queue_empty(dev)){
1279 priv->ieee80211->ack_tx_to_ieee = 0;
1280 ieee80211_ps_tx_ack(priv->ieee80211, 1);
1285 if(prio != BEACON_QUEUE) {
1286 /* try to deal with the pending packets */
1287 tasklet_schedule(&priv->irq_tx_tasklet);
1292 static void rtl8192_stop_beacon(struct net_device *dev)
1294 //rtl8192_beacon_disable(dev);
1297 static void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1299 struct r8192_priv *priv = ieee80211_priv(dev);
1300 struct ieee80211_network *net;
1301 u8 i=0, basic_rate = 0;
1302 net = & priv->ieee80211->current_network;
1304 for (i=0; i<net->rates_len; i++)
1306 basic_rate = net->rates[i]&0x7f;
1309 case MGN_1M: *rate_config |= RRSR_1M; break;
1310 case MGN_2M: *rate_config |= RRSR_2M; break;
1311 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1312 case MGN_11M: *rate_config |= RRSR_11M; break;
1313 case MGN_6M: *rate_config |= RRSR_6M; break;
1314 case MGN_9M: *rate_config |= RRSR_9M; break;
1315 case MGN_12M: *rate_config |= RRSR_12M; break;
1316 case MGN_18M: *rate_config |= RRSR_18M; break;
1317 case MGN_24M: *rate_config |= RRSR_24M; break;
1318 case MGN_36M: *rate_config |= RRSR_36M; break;
1319 case MGN_48M: *rate_config |= RRSR_48M; break;
1320 case MGN_54M: *rate_config |= RRSR_54M; break;
1323 for (i=0; i<net->rates_ex_len; i++)
1325 basic_rate = net->rates_ex[i]&0x7f;
1328 case MGN_1M: *rate_config |= RRSR_1M; break;
1329 case MGN_2M: *rate_config |= RRSR_2M; break;
1330 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1331 case MGN_11M: *rate_config |= RRSR_11M; break;
1332 case MGN_6M: *rate_config |= RRSR_6M; break;
1333 case MGN_9M: *rate_config |= RRSR_9M; break;
1334 case MGN_12M: *rate_config |= RRSR_12M; break;
1335 case MGN_18M: *rate_config |= RRSR_18M; break;
1336 case MGN_24M: *rate_config |= RRSR_24M; break;
1337 case MGN_36M: *rate_config |= RRSR_36M; break;
1338 case MGN_48M: *rate_config |= RRSR_48M; break;
1339 case MGN_54M: *rate_config |= RRSR_54M; break;
1345 #define SHORT_SLOT_TIME 9
1346 #define NON_SHORT_SLOT_TIME 20
1348 static void rtl8192_update_cap(struct net_device* dev, u16 cap)
1351 struct r8192_priv *priv = ieee80211_priv(dev);
1352 struct ieee80211_network *net = &priv->ieee80211->current_network;
1353 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1354 tmp = priv->basic_rate;
1355 if (priv->short_preamble)
1356 tmp |= BRSR_AckShortPmb;
1357 write_nic_dword(dev, RRSR, tmp);
1359 if (net->mode & (IEEE_G|IEEE_N_24G))
1362 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1364 slot_time = SHORT_SLOT_TIME;
1366 else //long slot time
1367 slot_time = NON_SHORT_SLOT_TIME;
1368 priv->slot_time = slot_time;
1369 write_nic_byte(dev, SLOT_TIME, slot_time);
1374 static void rtl8192_net_update(struct net_device *dev)
1377 struct r8192_priv *priv = ieee80211_priv(dev);
1378 struct ieee80211_network *net;
1379 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1380 u16 rate_config = 0;
1381 net = &priv->ieee80211->current_network;
1382 //update Basic rate: RR, BRSR
1383 rtl8192_config_rate(dev, &rate_config);
1384 // 2007.01.16, by Emily
1385 // Select RRSR (in Legacy-OFDM and CCK)
1386 // For 8190, we select only 24M, 12M, 6M, 11M, 5.5M, 2M, and 1M from the Basic rate.
1387 // We do not use other rates.
1388 priv->basic_rate = rate_config &= 0x15f;
1390 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1391 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1394 rtl8192_update_msr(dev);
1398 // rtl8192_update_cap(dev, net->capability);
1399 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1401 write_nic_word(dev, ATIMWND, 2);
1402 write_nic_word(dev, BCN_DMATIME, 256);
1403 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1404 // write_nic_word(dev, BcnIntTime, 100);
1405 //BIT15 of BCN_DRV_EARLY_INT will indicate whether software beacon or hw beacon is applied.
1406 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
1407 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1409 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1410 // TODO: BcnIFS may required to be changed on ASIC
1411 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1413 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1419 void rtl819xE_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1421 struct r8192_priv *priv = ieee80211_priv(dev);
1422 struct rtl8192_tx_ring *ring;
1423 tx_desc_819x_pci *entry;
1427 unsigned long flags;
1429 ring = &priv->tx_ring[TXCMD_QUEUE];
1430 mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1432 spin_lock_irqsave(&priv->irq_th_lock,flags);
1433 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1434 entry = &ring->desc[idx];
1436 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1438 entry->LINIP = tcb_desc->bLastIniPkt;
1439 entry->FirstSeg = 1;//first segment
1440 entry->LastSeg = 1; //last segment
1441 if(tcb_desc->bCmdOrInit == DESC_PACKET_TYPE_INIT) {
1442 entry->CmdInit = DESC_PACKET_TYPE_INIT;
1444 entry->CmdInit = DESC_PACKET_TYPE_NORMAL;
1445 entry->Offset = sizeof(TX_FWINFO_8190PCI) + 8;
1446 entry->PktSize = (u16)(tcb_desc->pkt_size + entry->Offset);
1447 entry->QueueSelect = QSLT_CMD;
1448 entry->TxFWInfoSize = 0x08;
1449 entry->RATid = (u8)DESC_PACKET_TYPE_INIT;
1451 entry->TxBufferSize = skb->len;
1452 entry->TxBuffAddr = cpu_to_le32(mapping);
1455 #ifdef JOHN_DUMP_TXDESC
1457 tx_desc_819x_pci *entry1 = &ring->desc[0];
1458 unsigned int *ptr= (unsigned int *)entry1;
1459 printk("<Tx descriptor>:\n");
1460 for (i = 0; i < 8; i++)
1461 printk("%8x ", ptr[i]);
1465 __skb_queue_tail(&ring->queue, skb);
1466 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1468 write_nic_byte(dev, TPPoll, TPPoll_CQ);
1474 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1475 * in TxFwInfo data structure
1476 * 2006.10.30 by Emily
1478 * \param QUEUEID Software Queue
1480 static u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1482 u8 QueueSelect = 0x0; //defualt set to
1486 QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
1490 QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
1494 QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
1498 QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
1501 QueueSelect = QSLT_MGNT;
1505 QueueSelect = QSLT_BEACON;
1508 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
1509 // TODO: Remove Assertions
1510 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
1512 QueueSelect = QSLT_CMD;
1516 //QueueSelect = QSLT_HIGH;
1520 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
1526 static u8 MRateToHwRate8190Pci(u8 rate)
1528 u8 ret = DESC90_RATE1M;
1531 case MGN_1M: ret = DESC90_RATE1M; break;
1532 case MGN_2M: ret = DESC90_RATE2M; break;
1533 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
1534 case MGN_11M: ret = DESC90_RATE11M; break;
1535 case MGN_6M: ret = DESC90_RATE6M; break;
1536 case MGN_9M: ret = DESC90_RATE9M; break;
1537 case MGN_12M: ret = DESC90_RATE12M; break;
1538 case MGN_18M: ret = DESC90_RATE18M; break;
1539 case MGN_24M: ret = DESC90_RATE24M; break;
1540 case MGN_36M: ret = DESC90_RATE36M; break;
1541 case MGN_48M: ret = DESC90_RATE48M; break;
1542 case MGN_54M: ret = DESC90_RATE54M; break;
1544 // HT rate since here
1545 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
1546 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
1547 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
1548 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
1549 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
1550 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
1551 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
1552 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
1553 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
1554 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
1555 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1556 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1557 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1558 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1559 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1560 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1561 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1569 static u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1573 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1575 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1582 * The tx procedure is just as following,
1583 * skb->cb will contain all the following information,
1584 * priority, morefrag, rate, &dev.
1586 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
1588 struct r8192_priv *priv = ieee80211_priv(dev);
1589 struct rtl8192_tx_ring *ring;
1590 unsigned long flags;
1591 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1592 tx_desc_819x_pci *pdesc = NULL;
1593 TX_FWINFO_8190PCI *pTxFwInfo = NULL;
1595 bool multi_addr=false,broad_addr=false,uni_addr=false;
1596 u8* pda_addr = NULL;
1599 if(priv->bdisable_nic){
1600 RT_TRACE(COMP_ERR,"%s: ERR!! Nic is disabled! Can't tx packet len=%d qidx=%d!!!\n", __FUNCTION__, skb->len, tcb_desc->queue_index);
1605 priv->ieee80211->bAwakePktSent = true;
1608 mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1609 /* collect the tx packets statitcs */
1610 pda_addr = ((u8*)skb->data) + sizeof(TX_FWINFO_8190PCI);
1611 if(is_multicast_ether_addr(pda_addr))
1613 else if(is_broadcast_ether_addr(pda_addr))
1619 priv->stats.txbytesunicast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1621 priv->stats.txbytesmulticast +=(u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1623 priv->stats.txbytesbroadcast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1625 /* fill tx firmware */
1626 pTxFwInfo = (PTX_FWINFO_8190PCI)skb->data;
1627 memset(pTxFwInfo,0,sizeof(TX_FWINFO_8190PCI));
1628 pTxFwInfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
1629 pTxFwInfo->TxRate = MRateToHwRate8190Pci((u8)tcb_desc->data_rate);
1630 pTxFwInfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1631 pTxFwInfo->Short = QueryIsShort(pTxFwInfo->TxHT, pTxFwInfo->TxRate, tcb_desc);
1633 /* Aggregation related */
1634 if(tcb_desc->bAMPDUEnable) {
1635 pTxFwInfo->AllowAggregation = 1;
1636 pTxFwInfo->RxMF = tcb_desc->ampdu_factor;
1637 pTxFwInfo->RxAMD = tcb_desc->ampdu_density;
1639 pTxFwInfo->AllowAggregation = 0;
1640 pTxFwInfo->RxMF = 0;
1641 pTxFwInfo->RxAMD = 0;
1645 // Protection mode related
1647 pTxFwInfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
1648 pTxFwInfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
1649 pTxFwInfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
1650 pTxFwInfo->RtsHT= (tcb_desc->rts_rate&0x80)?1:0;
1651 pTxFwInfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1652 pTxFwInfo->RtsBandwidth = 0;
1653 pTxFwInfo->RtsSubcarrier = tcb_desc->RTSSC;
1654 pTxFwInfo->RtsShort = (pTxFwInfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):(tcb_desc->bRTSUseShortGI?1:0);
1656 // Set Bandwidth and sub-channel settings.
1658 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
1660 if(tcb_desc->bPacketBW)
1662 pTxFwInfo->TxBandwidth = 1;
1664 pTxFwInfo->TxSubCarrier = 3;
1666 pTxFwInfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode, cosa 04012008
1671 pTxFwInfo->TxBandwidth = 0;
1672 pTxFwInfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1675 pTxFwInfo->TxBandwidth = 0;
1676 pTxFwInfo->TxSubCarrier = 0;
1681 /* 2007/07/25 MH Copy current TX FW info.*/
1682 memcpy((void*)(&Tmp_TxFwInfo), (void*)(pTxFwInfo), sizeof(TX_FWINFO_8190PCI));
1683 printk("&&&&&&&&&&&&&&&&&&&&&&====>print out fwinf\n");
1684 printk("===>enable fwcacl:%d\n", Tmp_TxFwInfo.EnableCPUDur);
1685 printk("===>RTS STBC:%d\n", Tmp_TxFwInfo.RtsSTBC);
1686 printk("===>RTS Subcarrier:%d\n", Tmp_TxFwInfo.RtsSubcarrier);
1687 printk("===>Allow Aggregation:%d\n", Tmp_TxFwInfo.AllowAggregation);
1688 printk("===>TX HT bit:%d\n", Tmp_TxFwInfo.TxHT);
1689 printk("===>Tx rate:%d\n", Tmp_TxFwInfo.TxRate);
1690 printk("===>Received AMPDU Density:%d\n", Tmp_TxFwInfo.RxAMD);
1691 printk("===>Received MPDU Factor:%d\n", Tmp_TxFwInfo.RxMF);
1692 printk("===>TxBandwidth:%d\n", Tmp_TxFwInfo.TxBandwidth);
1693 printk("===>TxSubCarrier:%d\n", Tmp_TxFwInfo.TxSubCarrier);
1695 printk("<=====**********************out of print\n");
1698 spin_lock_irqsave(&priv->irq_th_lock,flags);
1699 ring = &priv->tx_ring[tcb_desc->queue_index];
1700 if (tcb_desc->queue_index != BEACON_QUEUE) {
1701 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1706 pdesc = &ring->desc[idx];
1707 if((pdesc->OWN == 1) && (tcb_desc->queue_index != BEACON_QUEUE)) {
1708 RT_TRACE(COMP_ERR,"No more TX desc@%d, ring->idx = %d,idx = %d,%x",
1709 tcb_desc->queue_index,ring->idx, idx,skb->len);
1710 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1714 /* fill tx descriptor */
1715 memset((u8*)pdesc,0,12);
1719 pdesc->Offset = sizeof(TX_FWINFO_8190PCI) + 8; //We must add 8!! Emily
1720 pdesc->PktSize = (u16)skb->len-sizeof(TX_FWINFO_8190PCI);
1724 pdesc->RATid = tcb_desc->RATRIndex;
1728 pdesc->SecType = 0x0;
1729 if (tcb_desc->bHwSec) {
1730 switch (priv->ieee80211->pairwise_key_type) {
1731 case KEY_TYPE_WEP40:
1732 case KEY_TYPE_WEP104:
1733 pdesc->SecType = 0x1;
1737 pdesc->SecType = 0x2;
1741 pdesc->SecType = 0x3;
1745 pdesc->SecType = 0x0;
1756 pdesc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1757 pdesc->TxFWInfoSize = sizeof(TX_FWINFO_8190PCI);
1759 pdesc->DISFB = tcb_desc->bTxDisableRateFallBack;
1760 pdesc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1764 pdesc->TxBufferSize = skb->len;
1766 pdesc->TxBuffAddr = cpu_to_le32(mapping);
1767 __skb_queue_tail(&ring->queue, skb);
1769 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1770 dev->trans_start = jiffies;
1771 write_nic_word(dev,TPPoll,0x01<<tcb_desc->queue_index);
1775 static short rtl8192_alloc_rx_desc_ring(struct net_device *dev)
1777 struct r8192_priv *priv = ieee80211_priv(dev);
1778 rx_desc_819x_pci *entry = NULL;
1781 priv->rx_ring = pci_alloc_consistent(priv->pdev,
1782 sizeof(*priv->rx_ring) * priv->rxringcount, &priv->rx_ring_dma);
1784 if (!priv->rx_ring || (unsigned long)priv->rx_ring & 0xFF) {
1785 RT_TRACE(COMP_ERR,"Cannot allocate RX ring\n");
1789 memset(priv->rx_ring, 0, sizeof(*priv->rx_ring) * priv->rxringcount);
1792 for (i = 0; i < priv->rxringcount; i++) {
1793 struct sk_buff *skb = dev_alloc_skb(priv->rxbuffersize);
1794 dma_addr_t *mapping;
1795 entry = &priv->rx_ring[i];
1798 priv->rx_buf[i] = skb;
1799 mapping = (dma_addr_t *)skb->cb;
1800 *mapping = pci_map_single(priv->pdev, skb_tail_pointer(skb),
1801 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
1803 entry->BufferAddress = cpu_to_le32(*mapping);
1805 entry->Length = priv->rxbuffersize;
1813 static int rtl8192_alloc_tx_desc_ring(struct net_device *dev,
1814 unsigned int prio, unsigned int entries)
1816 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1817 tx_desc_819x_pci *ring;
1821 ring = pci_alloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma);
1822 if (!ring || (unsigned long)ring & 0xFF) {
1823 RT_TRACE(COMP_ERR, "Cannot allocate TX ring (prio = %d)\n", prio);
1827 memset(ring, 0, sizeof(*ring)*entries);
1828 priv->tx_ring[prio].desc = ring;
1829 priv->tx_ring[prio].dma = dma;
1830 priv->tx_ring[prio].idx = 0;
1831 priv->tx_ring[prio].entries = entries;
1832 skb_queue_head_init(&priv->tx_ring[prio].queue);
1834 for (i = 0; i < entries; i++)
1835 ring[i].NextDescAddress =
1836 cpu_to_le32((u32)dma + ((i + 1) % entries) * sizeof(*ring));
1842 static short rtl8192_pci_initdescring(struct net_device *dev)
1846 struct r8192_priv *priv = ieee80211_priv(dev);
1848 ret = rtl8192_alloc_rx_desc_ring(dev);
1854 /* general process for other queue */
1855 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1856 ret = rtl8192_alloc_tx_desc_ring(dev, i, priv->txringcount);
1858 goto err_free_rings;
1862 /* specific process for hardware beacon process */
1863 ret = rtl8192_alloc_tx_desc_ring(dev, MAX_TX_QUEUE_COUNT - 1, 2);
1865 goto err_free_rings;
1871 rtl8192_free_rx_ring(dev);
1872 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
1873 if (priv->tx_ring[i].desc)
1874 rtl8192_free_tx_ring(dev, i);
1878 static void rtl8192_pci_resetdescring(struct net_device *dev)
1880 struct r8192_priv *priv = ieee80211_priv(dev);
1883 /* force the rx_idx to the first one */
1885 rx_desc_819x_pci *entry = NULL;
1886 for (i = 0; i < priv->rxringcount; i++) {
1887 entry = &priv->rx_ring[i];
1893 /* after reset, release previous pending packet, and force the
1894 * tx idx to the first one */
1895 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1896 if (priv->tx_ring[i].desc) {
1897 struct rtl8192_tx_ring *ring = &priv->tx_ring[i];
1899 while (skb_queue_len(&ring->queue)) {
1900 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1901 struct sk_buff *skb = __skb_dequeue(&ring->queue);
1903 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1904 skb->len, PCI_DMA_TODEVICE);
1906 ring->idx = (ring->idx + 1) % ring->entries;
1914 static void rtl8192_link_change(struct net_device *dev)
1918 struct r8192_priv *priv = ieee80211_priv(dev);
1919 struct ieee80211_device* ieee = priv->ieee80211;
1920 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
1921 if (ieee->state == IEEE80211_LINKED)
1923 rtl8192_net_update(dev);
1924 rtl8192_update_ratr_table(dev);
1926 //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
1927 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
1928 EnableHWSecurityConfig8192(dev);
1933 write_nic_byte(dev, 0x173, 0);
1935 /*update timing params*/
1936 //rtl8192_set_chan(dev, priv->chan);
1938 rtl8192_update_msr(dev);
1940 // 2007/10/16 MH MAC Will update TSF according to all received beacon, so we have
1941 // // To set CBSSID bit when link with any AP or STA.
1942 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
1945 reg = read_nic_dword(dev, RCR);
1946 if (priv->ieee80211->state == IEEE80211_LINKED)
1947 priv->ReceiveConfig = reg |= RCR_CBSSID;
1949 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
1950 write_nic_dword(dev, RCR, reg);
1956 static const struct ieee80211_qos_parameters def_qos_parameters = {
1957 {3,3,3,3},/* cw_min */
1958 {7,7,7,7},/* cw_max */
1959 {2,2,2,2},/* aifs */
1960 {0,0,0,0},/* flags */
1961 {0,0,0,0} /* tx_op_limit */
1964 static void rtl8192_update_beacon(struct work_struct * work)
1966 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
1967 struct net_device *dev = priv->ieee80211->dev;
1968 struct ieee80211_device* ieee = priv->ieee80211;
1969 struct ieee80211_network* net = &ieee->current_network;
1971 if (ieee->pHTInfo->bCurrentHTSupport)
1972 HTUpdateSelfAndPeerSetting(ieee, net);
1973 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
1974 rtl8192_update_cap(dev, net->capability);
1977 * background support to run QoS activate functionality
1979 static const int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
1980 static void rtl8192_qos_activate(struct work_struct * work)
1982 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
1983 struct net_device *dev = priv->ieee80211->dev;
1984 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
1985 u8 mode = priv->ieee80211->current_network.mode;
1986 // u32 size = sizeof(struct ieee80211_qos_parameters);
1991 mutex_lock(&priv->mutex);
1992 if(priv->ieee80211->state != IEEE80211_LINKED)
1994 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
1995 /* It better set slot time at first */
1996 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
1997 /* update the ac parameter to related registers */
1998 for(i = 0; i < QOS_QUEUE_NUM; i++) {
1999 //Mode G/A: slotTimeTimer = 9; Mode B: 20
2000 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
2001 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
2002 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
2003 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
2004 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
2005 //printk("===>u4bAcParam:%x, ", u4bAcParam);
2006 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
2007 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
2011 mutex_unlock(&priv->mutex);
2014 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
2016 struct ieee80211_network *network)
2019 u32 size = sizeof(struct ieee80211_qos_parameters);
2021 if(priv->ieee80211->state !=IEEE80211_LINKED)
2024 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2027 if (network->flags & NETWORK_HAS_QOS_MASK) {
2028 if (active_network &&
2029 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
2030 network->qos_data.active = network->qos_data.supported;
2032 if ((network->qos_data.active == 1) && (active_network == 1) &&
2033 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
2034 (network->qos_data.old_param_count !=
2035 network->qos_data.param_count)) {
2036 network->qos_data.old_param_count =
2037 network->qos_data.param_count;
2038 queue_work(priv->priv_wq, &priv->qos_activate);
2039 RT_TRACE (COMP_QOS, "QoS parameters change call "
2043 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
2044 &def_qos_parameters, size);
2046 if ((network->qos_data.active == 1) && (active_network == 1)) {
2047 queue_work(priv->priv_wq, &priv->qos_activate);
2048 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
2050 network->qos_data.active = 0;
2051 network->qos_data.supported = 0;
2057 /* handle manage frame frame beacon and probe response */
2058 static int rtl8192_handle_beacon(struct net_device * dev,
2059 struct ieee80211_beacon * beacon,
2060 struct ieee80211_network * network)
2062 struct r8192_priv *priv = ieee80211_priv(dev);
2064 rtl8192_qos_handle_probe_response(priv,1,network);
2066 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
2072 * handling the beaconing responses. if we get different QoS setting
2073 * off the network from the associated setting, adjust the QoS
2076 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
2077 struct ieee80211_network *network)
2080 unsigned long flags;
2081 u32 size = sizeof(struct ieee80211_qos_parameters);
2082 int set_qos_param = 0;
2084 if ((priv == NULL) || (network == NULL))
2087 if(priv->ieee80211->state !=IEEE80211_LINKED)
2090 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2093 spin_lock_irqsave(&priv->ieee80211->lock, flags);
2094 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
2095 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
2096 &network->qos_data.parameters,
2097 sizeof(struct ieee80211_qos_parameters));
2098 priv->ieee80211->current_network.qos_data.active = 1;
2100 if((priv->ieee80211->current_network.qos_data.param_count !=
2101 network->qos_data.param_count))
2105 /* update qos parameter for current network */
2106 priv->ieee80211->current_network.qos_data.old_param_count =
2107 priv->ieee80211->current_network.qos_data.param_count;
2108 priv->ieee80211->current_network.qos_data.param_count =
2109 network->qos_data.param_count;
2112 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
2113 &def_qos_parameters, size);
2114 priv->ieee80211->current_network.qos_data.active = 0;
2115 priv->ieee80211->current_network.qos_data.supported = 0;
2119 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
2121 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
2122 if (set_qos_param == 1)
2123 queue_work(priv->priv_wq, &priv->qos_activate);
2129 static int rtl8192_handle_assoc_response(struct net_device *dev,
2130 struct ieee80211_assoc_response_frame *resp,
2131 struct ieee80211_network *network)
2133 struct r8192_priv *priv = ieee80211_priv(dev);
2134 rtl8192_qos_association_resp(priv, network);
2139 //updateRATRTabel for MCS only. Basic rate is not implement.
2140 static void rtl8192_update_ratr_table(struct net_device* dev)
2141 // POCTET_STRING posLegacyRate,
2143 // PRT_WLAN_STA pEntry)
2145 struct r8192_priv* priv = ieee80211_priv(dev);
2146 struct ieee80211_device* ieee = priv->ieee80211;
2147 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2148 //struct ieee80211_network *net = &ieee->current_network;
2152 rtl8192_config_rate(dev, (u16*)(&ratr_value));
2153 ratr_value |= (*(u16*)(pMcsRate)) << 12;
2154 // switch (net->mode)
2158 ratr_value &= 0x00000FF0;
2161 ratr_value &= 0x0000000F;
2164 ratr_value &= 0x00000FF7;
2168 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
2169 ratr_value &= 0x0007F007;
2171 if (priv->rf_type == RF_1T2R)
2172 ratr_value &= 0x000FF007;
2174 ratr_value &= 0x0F81F007;
2180 ratr_value &= 0x0FFFFFFF;
2181 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
2182 ratr_value |= 0x80000000;
2183 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
2184 ratr_value |= 0x80000000;
2186 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2187 write_nic_byte(dev, UFWP, 1);
2191 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
2192 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2195 static bool GetNmodeSupportBySecCfg8190Pci(struct net_device*dev)
2199 struct r8192_priv *priv = ieee80211_priv(dev);
2200 struct ieee80211_device *ieee = priv->ieee80211;
2201 return !(ieee->rtllib_ap_sec_type &&
2202 (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP)));
2204 struct r8192_priv* priv = ieee80211_priv(dev);
2205 struct ieee80211_device* ieee = priv->ieee80211;
2206 int wpa_ie_len= ieee->wpa_ie_len;
2207 struct ieee80211_crypt_data* crypt;
2210 crypt = ieee->crypt[ieee->tx_keyidx];
2211 encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2214 if(encrypt && (wpa_ie_len == 0)) {
2215 /* wep encryption, no N mode setting */
2217 // } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
2218 } else if((wpa_ie_len != 0)) {
2219 /* parse pairwise key type */
2220 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
2221 if (((ieee->wpa_ie[0] == 0xdd) && (!memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) || ((ieee->wpa_ie[0] == 0x30) && (!memcmp(&ieee->wpa_ie[10],ccmp_rsn_ie, 4))))
2226 //RT_TRACE(COMP_ERR,"In %s The GroupEncAlgorithm is [4]\n",__FUNCTION__ );
2234 static void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2236 struct ieee80211_device* ieee = priv->ieee80211;
2237 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
2238 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2240 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2241 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
2242 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
2245 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2248 static u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2250 struct r8192_priv *priv = ieee80211_priv(dev);
2252 switch(priv->rf_chip)
2257 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2260 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2263 ret = WIRELESS_MODE_B;
2269 static void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2271 struct r8192_priv *priv = ieee80211_priv(dev);
2272 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2275 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2277 if(bSupportMode & WIRELESS_MODE_N_24G)
2279 wireless_mode = WIRELESS_MODE_N_24G;
2281 else if(bSupportMode & WIRELESS_MODE_N_5G)
2283 wireless_mode = WIRELESS_MODE_N_5G;
2285 else if((bSupportMode & WIRELESS_MODE_A))
2287 wireless_mode = WIRELESS_MODE_A;
2289 else if((bSupportMode & WIRELESS_MODE_G))
2291 wireless_mode = WIRELESS_MODE_G;
2293 else if((bSupportMode & WIRELESS_MODE_B))
2295 wireless_mode = WIRELESS_MODE_B;
2298 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2299 wireless_mode = WIRELESS_MODE_B;
2302 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2303 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2305 priv->ieee80211->mode = wireless_mode;
2307 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2308 priv->ieee80211->pHTInfo->bEnableHT = 1;
2310 priv->ieee80211->pHTInfo->bEnableHT = 0;
2311 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2312 rtl8192_refresh_supportrate(priv);
2316 //init priv variables here
2318 static bool GetHalfNmodeSupportByAPs819xPci(struct net_device* dev)
2320 struct r8192_priv* priv = ieee80211_priv(dev);
2321 struct ieee80211_device* ieee = priv->ieee80211;
2323 return ieee->bHalfWirelessN24GMode;
2326 short rtl8192_is_tx_queue_empty(struct net_device *dev)
2329 struct r8192_priv *priv = ieee80211_priv(dev);
2330 for (i=0; i<=MGNT_QUEUE; i++)
2332 if ((i== TXCMD_QUEUE) || (i == HCCA_QUEUE) )
2334 if (skb_queue_len(&(&priv->tx_ring[i])->queue) > 0){
2335 printk("===>tx queue is not empty:%d, %d\n", i, skb_queue_len(&(&priv->tx_ring[i])->queue));
2341 static void rtl8192_hw_sleep_down(struct net_device *dev)
2343 struct r8192_priv *priv = ieee80211_priv(dev);
2344 unsigned long flags = 0;
2346 spin_lock_irqsave(&priv->rf_ps_lock,flags);
2347 if (priv->RFChangeInProgress) {
2348 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2349 RT_TRACE(COMP_RF, "rtl8192_hw_sleep_down(): RF Change in progress! \n");
2350 printk("rtl8192_hw_sleep_down(): RF Change in progress!\n");
2353 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2354 //RT_TRACE(COMP_PS, "%s()============>come to sleep down\n", __FUNCTION__);
2356 MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
2358 static void rtl8192_hw_sleep_wq (struct work_struct *work)
2360 // struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
2361 // struct ieee80211_device * ieee = (struct ieee80211_device*)
2362 // container_of(work, struct ieee80211_device, watch_dog_wq);
2363 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2364 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
2365 struct net_device *dev = ieee->dev;
2367 rtl8192_hw_sleep_down(dev);
2370 static void rtl8192_hw_wakeup(struct net_device* dev)
2372 struct r8192_priv *priv = ieee80211_priv(dev);
2373 unsigned long flags = 0;
2375 spin_lock_irqsave(&priv->rf_ps_lock,flags);
2376 if (priv->RFChangeInProgress) {
2377 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2378 RT_TRACE(COMP_RF, "rtl8192_hw_wakeup(): RF Change in progress! \n");
2379 printk("rtl8192_hw_wakeup(): RF Change in progress! schedule wake up task again\n");
2380 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
2383 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2385 //RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __FUNCTION__);
2386 MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS);
2389 void rtl8192_hw_wakeup_wq (struct work_struct *work)
2391 // struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
2392 // struct ieee80211_device * ieee = (struct ieee80211_device*)
2393 // container_of(work, struct ieee80211_device, watch_dog_wq);
2394 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2395 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
2396 struct net_device *dev = ieee->dev;
2397 rtl8192_hw_wakeup(dev);
2401 #define MIN_SLEEP_TIME 50
2402 #define MAX_SLEEP_TIME 10000
2403 static void rtl8192_hw_to_sleep(struct net_device *dev, u32 th, u32 tl)
2405 struct r8192_priv *priv = ieee80211_priv(dev);
2408 unsigned long flags;
2410 spin_lock_irqsave(&priv->ps_lock,flags);
2412 // Writing HW register with 0 equals to disable
2413 // the timer, that is not really what we want
2415 tl -= MSECS(8+16+7);
2417 // If the interval in witch we are requested to sleep is too
2418 // short then give up and remain awake
2419 // when we sleep after send null frame, the timer will be too short to sleep.
2421 if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
2422 ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
2423 spin_unlock_irqrestore(&priv->ps_lock,flags);
2424 printk("too short to sleep::%x, %x, %lx\n",tl, rb, MSECS(MIN_SLEEP_TIME));
2428 if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
2429 ((tl < rb) && (tl>MSECS(69)) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))||
2430 ((tl<rb)&&(tl<MSECS(69))&&((tl+0xffffffff-rb)>MSECS(MAX_SLEEP_TIME)))) {
2431 printk("========>too long to sleep:%x, %x, %lx\n", tl, rb, MSECS(MAX_SLEEP_TIME));
2432 spin_unlock_irqrestore(&priv->ps_lock,flags);
2436 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
2437 queue_delayed_work(priv->ieee80211->wq,
2438 &priv->ieee80211->hw_wakeup_wq,tmp);
2439 //PowerSave not supported when kernel version less 2.6.20
2441 queue_delayed_work(priv->ieee80211->wq,
2442 (void *)&priv->ieee80211->hw_sleep_wq,0);
2443 spin_unlock_irqrestore(&priv->ps_lock,flags);
2446 static void rtl8192_init_priv_variable(struct net_device* dev)
2448 struct r8192_priv *priv = ieee80211_priv(dev);
2450 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
2452 // Default Halt the NIC if RF is OFF.
2453 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_HALT_NIC;
2454 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_CLK_REQ;
2455 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_ASPM;
2456 pPSC->RegRfPsLevel |= RT_RF_LPS_LEVEL_ASPM;
2457 pPSC->bLeisurePs = true;
2458 pPSC->RegMaxLPSAwakeIntvl = 5;
2459 priv->bHwRadioOff = false;
2461 priv->being_init_adapter = false;
2462 priv->txbuffsize = 1600;//1024;
2463 priv->txfwbuffersize = 4096;
2464 priv->txringcount = 64;//32;
2465 //priv->txbeaconcount = priv->txringcount;
2466 priv->txbeaconcount = 2;
2467 priv->rxbuffersize = 9100;//2048;//1024;
2468 priv->rxringcount = MAX_RX_COUNT;//64;
2469 priv->irq_enabled=0;
2470 priv->card_8192 = NIC_8192E;
2471 priv->rx_skb_complete = 1;
2472 priv->chan = 1; //set to channel 1
2473 priv->RegWirelessMode = WIRELESS_MODE_AUTO;
2474 priv->RegChannelPlan = 0xf;
2475 priv->nrxAMPDU_size = 0;
2476 priv->nrxAMPDU_aggr_num = 0;
2477 priv->last_rxdesc_tsf_high = 0;
2478 priv->last_rxdesc_tsf_low = 0;
2479 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2480 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2481 priv->ieee80211->ieee_up=0;
2482 priv->retry_rts = DEFAULT_RETRY_RTS;
2483 priv->retry_data = DEFAULT_RETRY_DATA;
2484 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2485 priv->ieee80211->rate = 110; //11 mbps
2486 priv->ieee80211->short_slot = 1;
2487 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2488 priv->bcck_in_ch14 = false;
2489 priv->bfsync_processing = false;
2490 priv->CCKPresentAttentuation = 0;
2491 priv->rfa_txpowertrackingindex = 0;
2492 priv->rfc_txpowertrackingindex = 0;
2494 priv->ScanDelay = 50;//for Scan TODO
2495 //added by amy for silent reset
2496 priv->ResetProgress = RESET_TYPE_NORESET;
2497 priv->bForcedSilentReset = 0;
2498 priv->bDisableNormalResetCheck = false;
2499 priv->force_reset = false;
2500 //added by amy for power save
2502 priv->ieee80211->RfOffReason = 0;
2503 priv->RFChangeInProgress = false;
2504 priv->bHwRfOffAction = 0;
2505 priv->SetRFPowerStateInProgress = false;
2506 priv->ieee80211->PowerSaveControl.bInactivePs = true;
2507 priv->ieee80211->PowerSaveControl.bIPSModeBackup = false;
2509 priv->txpower_checkcnt = 0;
2510 priv->thermal_readback_index =0;
2511 priv->txpower_tracking_callback_cnt = 0;
2512 priv->ccktxpower_adjustcnt_ch14 = 0;
2513 priv->ccktxpower_adjustcnt_not_ch14 = 0;
2515 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2516 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2517 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2518 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2519 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;/* |
2520 IEEE_SOFTMAC_BEACONS;*///added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2522 priv->ieee80211->active_scan = 1;
2523 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2524 priv->ieee80211->host_encrypt = 1;
2525 priv->ieee80211->host_decrypt = 1;
2526 //priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2527 //priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2528 priv->ieee80211->start_send_beacons = rtl8192_start_beacon;//+by david 081107
2529 priv->ieee80211->stop_send_beacons = rtl8192_stop_beacon;//+by david 081107
2530 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2531 priv->ieee80211->set_chan = rtl8192_set_chan;
2532 priv->ieee80211->link_change = rtl8192_link_change;
2533 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2534 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2535 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2536 priv->ieee80211->init_wmmparam_flag = 0;
2537 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2538 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2539 priv->ieee80211->tx_headroom = sizeof(TX_FWINFO_8190PCI);
2540 priv->ieee80211->qos_support = 1;
2541 priv->ieee80211->dot11PowerSaveMode = 0;
2543 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2544 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2545 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2546 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2548 priv->ieee80211->sta_wake_up = rtl8192_hw_wakeup;
2549 // priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
2550 priv->ieee80211->enter_sleep_state = rtl8192_hw_to_sleep;
2551 priv->ieee80211->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
2553 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8190Pci;
2554 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2555 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xPci;
2558 priv->ieee80211->InitialGainHandler = InitialGain819xPci;
2561 priv->ieee80211->ieee80211_ips_leave_wq = ieee80211_ips_leave_wq;
2562 priv->ieee80211->ieee80211_ips_leave = ieee80211_ips_leave;
2565 priv->ieee80211->LeisurePSLeave = LeisurePSLeave;
2568 priv->ieee80211->SetHwRegHandler = rtl8192e_SetHwReg;
2569 priv->ieee80211->rtllib_ap_sec_type = rtl8192e_ap_sec_type;
2571 priv->card_type = USB;
2573 priv->ShortRetryLimit = 0x30;
2574 priv->LongRetryLimit = 0x30;
2576 priv->EarlyRxThreshold = 7;
2577 priv->enable_gpio0 = 0;
2579 priv->TransmitConfig = 0;
2581 priv->ReceiveConfig = RCR_ADD3 |
2582 RCR_AMF | RCR_ADF | //accept management/data
2583 RCR_AICV | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2584 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2585 RCR_AAP | ((u32)7<<RCR_MXDMA_OFFSET) |
2586 ((u32)7 << RCR_FIFO_OFFSET) | RCR_ONLYERLPKT;
2588 priv->irq_mask = (u32)(IMR_ROK | IMR_VODOK | IMR_VIDOK | IMR_BEDOK | IMR_BKDOK |
2589 IMR_HCCADOK | IMR_MGNTDOK | IMR_COMDOK | IMR_HIGHDOK |
2590 IMR_BDOK | IMR_RXCMDOK | IMR_TIMEOUT0 | IMR_RDU | IMR_RXFOVW |
2591 IMR_TXFOVW | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
2593 priv->AcmControl = 0;
2594 priv->pFirmware = (rt_firmware*)vmalloc(sizeof(rt_firmware));
2595 if (priv->pFirmware)
2596 memset(priv->pFirmware, 0, sizeof(rt_firmware));
2598 /* rx related queue */
2599 skb_queue_head_init(&priv->rx_queue);
2600 skb_queue_head_init(&priv->skb_queue);
2602 /* Tx related queue */
2603 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2604 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2606 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2607 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2609 priv->rf_set_chan = rtl8192_phy_SwChnl;
2613 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2615 spin_lock_init(&priv->tx_lock);
2616 spin_lock_init(&priv->irq_lock);//added by thomas
2617 spin_lock_init(&priv->irq_th_lock);
2618 spin_lock_init(&priv->rf_ps_lock);
2619 spin_lock_init(&priv->ps_lock);
2620 //spin_lock_init(&priv->rf_lock);
2621 sema_init(&priv->wx_sem,1);
2622 sema_init(&priv->rf_sem,1);
2623 mutex_init(&priv->mutex);
2626 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2627 #define DRV_NAME "wlan0"
2628 static void rtl8192_init_priv_task(struct net_device* dev)
2630 struct r8192_priv *priv = ieee80211_priv(dev);
2632 #ifdef PF_SYNCTHREAD
2633 priv->priv_wq = create_workqueue(DRV_NAME,0);
2635 priv->priv_wq = create_workqueue(DRV_NAME);
2639 INIT_WORK(&priv->ieee80211->ips_leave_wq, (void*)IPSLeave_wq);
2642 // INIT_WORK(&priv->reset_wq, (void(*)(void*)) rtl8192_restart);
2643 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2644 // INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2645 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2646 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2647 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2648 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2649 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2650 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2651 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2652 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq);
2653 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq);
2655 tasklet_init(&priv->irq_rx_tasklet,
2656 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2657 (unsigned long)priv);
2658 tasklet_init(&priv->irq_tx_tasklet,
2659 (void(*)(unsigned long))rtl8192_irq_tx_tasklet,
2660 (unsigned long)priv);
2661 tasklet_init(&priv->irq_prepare_beacon_tasklet,
2662 (void(*)(unsigned long))rtl8192_prepare_beacon,
2663 (unsigned long)priv);
2666 static void rtl8192_get_eeprom_size(struct net_device* dev)
2669 struct r8192_priv *priv = ieee80211_priv(dev);
2670 RT_TRACE(COMP_INIT, "===========>%s()\n", __FUNCTION__);
2671 curCR = read_nic_dword(dev, EPROM_CMD);
2672 RT_TRACE(COMP_INIT, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD, curCR);
2673 //whether need I consider BIT5?
2674 priv->epromtype = (curCR & EPROM_CMD_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2675 RT_TRACE(COMP_INIT, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2678 //used to swap endian. as ntohl & htonl are not neccessary to swap endian, so use this instead.
2679 static inline u16 endian_swap(u16* data)
2682 *data = (tmp >> 8) | (tmp << 8);
2687 * Note: Adapter->EEPROMAddressSize should be set before this function call.
2688 * EEPROM address size can be got through GetEEPROMSize8185()
2690 static void rtl8192_read_eeprom_info(struct net_device* dev)
2692 struct r8192_priv *priv = ieee80211_priv(dev);
2696 u8 ICVer8192, ICVer8256;
2698 u16 i,usValue, IC_Version;
2701 u8 offset;//, tmpAFR;
2702 u8 EepromTxPower[100];
2704 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01};
2705 RT_TRACE(COMP_INIT, "====> rtl8192_read_eeprom_info\n");
2708 // TODO: I don't know if we need to apply EF function to EEPROM read function
2710 //2 Read EEPROM ID to make sure autoload is success
2711 EEPROMId = eprom_read(dev, 0);
2712 if( EEPROMId != RTL8190_EEPROM_ID )
2714 RT_TRACE(COMP_ERR, "EEPROM ID is invalid:%x, %x\n", EEPROMId, RTL8190_EEPROM_ID);
2715 priv->AutoloadFailFlag=true;
2719 priv->AutoloadFailFlag=false;
2723 // Assign Chip Version ID
2725 // Read IC Version && Channel Plan
2726 if(!priv->AutoloadFailFlag)
2729 priv->eeprom_vid = eprom_read(dev, (EEPROM_VID >> 1));
2730 priv->eeprom_did = eprom_read(dev, (EEPROM_DID >> 1));
2732 usValue = eprom_read(dev, (u16)(EEPROM_Customer_ID>>1)) >> 8 ;
2733 priv->eeprom_CustomerID = (u8)( usValue & 0xff);
2734 usValue = eprom_read(dev, (EEPROM_ICVersion_ChannelPlan>>1));
2735 priv->eeprom_ChannelPlan = usValue&0xff;
2736 IC_Version = ((usValue&0xff00)>>8);
2739 priv->card_8192_version = (VERSION_8190)(IC_Version);
2742 ICVer8192 = (IC_Version&0xf); //bit0~3; 1:A cut, 2:B cut, 3:C cut...
2743 ICVer8256 = ((IC_Version&0xf0)>>4);//bit4~6, bit7 reserved for other RF chip; 1:A cut, 2:B cut, 3:C cut...
2744 RT_TRACE(COMP_INIT, "\nICVer8192 = 0x%x\n", ICVer8192);
2745 RT_TRACE(COMP_INIT, "\nICVer8256 = 0x%x\n", ICVer8256);
2746 if(ICVer8192 == 0x2) //B-cut
2748 if(ICVer8256 == 0x5) //E-cut
2749 priv->card_8192_version= VERSION_8190_BE;
2753 switch(priv->card_8192_version)
2755 case VERSION_8190_BD:
2756 case VERSION_8190_BE:
2759 priv->card_8192_version = VERSION_8190_BD;
2762 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", priv->card_8192_version);
2766 priv->card_8192_version = VERSION_8190_BD;
2767 priv->eeprom_vid = 0;
2768 priv->eeprom_did = 0;
2769 priv->eeprom_CustomerID = 0;
2770 priv->eeprom_ChannelPlan = 0;
2771 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", 0xff);
2774 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
2775 RT_TRACE(COMP_INIT, "EEPROM DID = 0x%4x\n", priv->eeprom_did);
2776 RT_TRACE(COMP_INIT,"EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
2778 //2 Read Permanent MAC address
2779 if(!priv->AutoloadFailFlag)
2781 for(i = 0; i < 6; i += 2)
2783 usValue = eprom_read(dev, (u16) ((EEPROM_NODE_ADDRESS_BYTE_0+i)>>1));
2784 *(u16*)(&dev->dev_addr[i]) = usValue;
2787 // when auto load failed, the last address byte set to be a random one.
2788 // added by david woo.2007/11/7
2789 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2792 RT_TRACE(COMP_INIT, "Permanent Address = %pM\n", dev->dev_addr);
2794 //2 TX Power Check EEPROM Fail or not
2795 if(priv->card_8192_version > VERSION_8190_BD) {
2796 priv->bTXPowerDataReadFromEEPORM = true;
2798 priv->bTXPowerDataReadFromEEPORM = false;
2801 // 2007/11/15 MH 8190PCI Default=2T4R, 8192PCIE default=1T2R
2802 priv->rf_type = RTL819X_DEFAULT_RF_TYPE;
2804 if(priv->card_8192_version > VERSION_8190_BD)
2806 // Read RF-indication and Tx Power gain index diff of legacy to HT OFDM rate.
2807 if(!priv->AutoloadFailFlag)
2809 tempval = (eprom_read(dev, (EEPROM_RFInd_PowerDiff>>1))) & 0xff;
2810 priv->EEPROMLegacyHTTxPowerDiff = tempval & 0xf; // bit[3:0]
2812 if (tempval&0x80) //RF-indication, bit[7]
2813 priv->rf_type = RF_1T2R;
2815 priv->rf_type = RF_2T4R;
2819 priv->EEPROMLegacyHTTxPowerDiff = EEPROM_Default_LegacyHTTxPowerDiff;
2821 RT_TRACE(COMP_INIT, "EEPROMLegacyHTTxPowerDiff = %d\n",
2822 priv->EEPROMLegacyHTTxPowerDiff);
2824 // Read ThermalMeter from EEPROM
2825 if(!priv->AutoloadFailFlag)
2827 priv->EEPROMThermalMeter = (u8)(((eprom_read(dev, (EEPROM_ThermalMeter>>1))) & 0xff00)>>8);
2831 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2833 RT_TRACE(COMP_INIT, "ThermalMeter = %d\n", priv->EEPROMThermalMeter);
2834 //vivi, for tx power track
2835 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2837 if(priv->epromtype == EPROM_93c46)
2839 // Read antenna tx power offset of B/C/D to A and CrystalCap from EEPROM
2840 if(!priv->AutoloadFailFlag)
2842 usValue = eprom_read(dev, (EEPROM_TxPwDiff_CrystalCap>>1));
2843 priv->EEPROMAntPwDiff = (usValue&0x0fff);
2844 priv->EEPROMCrystalCap = (u8)((usValue&0xf000)>>12);
2848 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2849 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2851 RT_TRACE(COMP_INIT, "EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2852 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2855 // Get per-channel Tx Power Level
2857 for(i=0; i<14; i+=2)
2859 if(!priv->AutoloadFailFlag)
2861 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_CCK+i)>>1) );
2865 usValue = EEPROM_Default_TxPower;
2867 *((u16*)(&priv->EEPROMTxPowerLevelCCK[i])) = usValue;
2868 RT_TRACE(COMP_INIT,"CCK Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK[i]);
2869 RT_TRACE(COMP_INIT, "CCK Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelCCK[i+1]);
2871 for(i=0; i<14; i+=2)
2873 if(!priv->AutoloadFailFlag)
2875 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_OFDM_24G+i)>>1) );
2879 usValue = EEPROM_Default_TxPower;
2881 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[i])) = usValue;
2882 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelOFDM24G[i]);
2883 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelOFDM24G[i+1]);
2886 else if(priv->epromtype== EPROM_93c56)
2889 // Read CrystalCap from EEPROM
2890 if(!priv->AutoloadFailFlag)
2892 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2893 priv->EEPROMCrystalCap = (u8)(((eprom_read(dev, (EEPROM_C56_CrystalCap>>1))) & 0xf000)>>12);
2897 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2898 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2900 RT_TRACE(COMP_INIT,"EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2901 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2903 // Get Tx Power Level by Channel
2904 if(!priv->AutoloadFailFlag)
2906 // Read Tx power of Channel 1 ~ 14 from EEPROM.
2907 for(i = 0; i < 12; i+=2)
2910 offset = EEPROM_C56_RfA_CCK_Chnl1_TxPwIndex + i;
2912 offset = EEPROM_C56_RfC_CCK_Chnl1_TxPwIndex + i - 6;
2913 usValue = eprom_read(dev, (offset>>1));
2914 *((u16*)(&EepromTxPower[i])) = usValue;
2917 for(i = 0; i < 12; i++)
2920 priv->EEPROMRfACCKChnl1TxPwLevel[i] = EepromTxPower[i];
2921 else if ((i >=3 )&&(i <= 5))
2922 priv->EEPROMRfAOfdmChnlTxPwLevel[i-3] = EepromTxPower[i];
2923 else if ((i >=6 )&&(i <= 8))
2924 priv->EEPROMRfCCCKChnl1TxPwLevel[i-6] = EepromTxPower[i];
2926 priv->EEPROMRfCOfdmChnlTxPwLevel[i-9] = EepromTxPower[i];
2931 priv->EEPROMRfACCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2932 priv->EEPROMRfACCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2933 priv->EEPROMRfACCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2935 priv->EEPROMRfAOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2936 priv->EEPROMRfAOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2937 priv->EEPROMRfAOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2939 priv->EEPROMRfCCCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2940 priv->EEPROMRfCCCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2941 priv->EEPROMRfCCCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2943 priv->EEPROMRfCOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2944 priv->EEPROMRfCOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2945 priv->EEPROMRfCOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2947 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[0]);
2948 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[1]);
2949 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[2]);
2950 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[0]);
2951 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[1]);
2952 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[2]);
2953 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[0]);
2954 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[1]);
2955 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[2]);
2956 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[0]);
2957 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[1]);
2958 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[2]);
2963 // Update HAL variables.
2965 if(priv->epromtype == EPROM_93c46)
2969 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK[i];
2970 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[i];
2972 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2973 // Antenna B gain offset to antenna A, bit0~3
2974 priv->AntennaTxPwDiff[0] = (priv->EEPROMAntPwDiff & 0xf);
2975 // Antenna C gain offset to antenna A, bit4~7
2976 priv->AntennaTxPwDiff[1] = ((priv->EEPROMAntPwDiff & 0xf0)>>4);
2977 // Antenna D gain offset to antenna A, bit8~11
2978 priv->AntennaTxPwDiff[2] = ((priv->EEPROMAntPwDiff & 0xf00)>>8);
2979 // CrystalCap, bit12~15
2980 priv->CrystalCap = priv->EEPROMCrystalCap;
2981 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2982 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
2983 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
2985 else if(priv->epromtype == EPROM_93c56)
2987 //char cck_pwr_diff_a=0, cck_pwr_diff_c=0;
2989 //cck_pwr_diff_a = pHalData->EEPROMRfACCKChnl7TxPwLevel - pHalData->EEPROMRfAOfdmChnlTxPwLevel[1];
2990 //cck_pwr_diff_c = pHalData->EEPROMRfCCCKChnl7TxPwLevel - pHalData->EEPROMRfCOfdmChnlTxPwLevel[1];
2991 for(i=0; i<3; i++) // channel 1~3 use the same Tx Power Level.
2993 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[0];
2994 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[0];
2995 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[0];
2996 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[0];
2998 for(i=3; i<9; i++) // channel 4~9 use the same Tx Power Level
3000 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[1];
3001 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[1];
3002 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[1];
3003 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[1];
3005 for(i=9; i<14; i++) // channel 10~14 use the same Tx Power Level
3007 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[2];
3008 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[2];
3009 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[2];
3010 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[2];
3013 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_A[i]);
3015 RT_TRACE(COMP_INIT,"priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_A[i]);
3017 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_C[i]);
3019 RT_TRACE(COMP_INIT, "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_C[i]);
3020 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
3021 priv->AntennaTxPwDiff[0] = 0;
3022 priv->AntennaTxPwDiff[1] = 0;
3023 priv->AntennaTxPwDiff[2] = 0;
3024 priv->CrystalCap = priv->EEPROMCrystalCap;
3025 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
3026 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
3027 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
3031 if(priv->rf_type == RF_1T2R)
3033 RT_TRACE(COMP_INIT, "\n1T2R config\n");
3035 else if (priv->rf_type == RF_2T4R)
3037 RT_TRACE(COMP_INIT, "\n2T4R config\n");
3040 // 2008/01/16 MH We can only know RF type in the function. So we have to init
3041 // DIG RATR table again.
3042 init_rate_adaptive(dev);
3044 //1 Make a copy for following variables and we can change them if we want
3046 priv->rf_chip= RF_8256;
3048 if(priv->RegChannelPlan == 0xf)
3050 priv->ChannelPlan = priv->eeprom_ChannelPlan;
3054 priv->ChannelPlan = priv->RegChannelPlan;
3058 // Used PID and DID to Set CustomerID
3060 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304 )
3062 priv->CustomerID = RT_CID_DLINK;
3065 switch(priv->eeprom_CustomerID)
3067 case EEPROM_CID_DEFAULT:
3068 priv->CustomerID = RT_CID_DEFAULT;
3070 case EEPROM_CID_CAMEO:
3071 priv->CustomerID = RT_CID_819x_CAMEO;
3073 case EEPROM_CID_RUNTOP:
3074 priv->CustomerID = RT_CID_819x_RUNTOP;
3076 case EEPROM_CID_NetCore:
3077 priv->CustomerID = RT_CID_819x_Netcore;
3079 case EEPROM_CID_TOSHIBA: // Merge by Jacken, 2008/01/31
3080 priv->CustomerID = RT_CID_TOSHIBA;
3081 if(priv->eeprom_ChannelPlan&0x80)
3082 priv->ChannelPlan = priv->eeprom_ChannelPlan&0x7f;
3084 priv->ChannelPlan = 0x0;
3085 RT_TRACE(COMP_INIT, "Toshiba ChannelPlan = 0x%x\n",
3088 case EEPROM_CID_Nettronix:
3089 priv->ScanDelay = 100; //cosa add for scan
3090 priv->CustomerID = RT_CID_Nettronix;
3092 case EEPROM_CID_Pronet:
3093 priv->CustomerID = RT_CID_PRONET;
3095 case EEPROM_CID_DLINK:
3096 priv->CustomerID = RT_CID_DLINK;
3099 case EEPROM_CID_WHQL:
3100 //Adapter->bInHctTest = TRUE;//do not supported
3102 //priv->bSupportTurboMode = FALSE;
3103 //priv->bAutoTurboBy8186 = FALSE;
3105 //pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
3106 //pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
3107 //pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
3111 // value from RegCustomerID
3115 //Avoid the channel plan array overflow, by Bruce, 2007-08-27.
3116 if(priv->ChannelPlan > CHANNEL_PLAN_LEN - 1)
3117 priv->ChannelPlan = 0; //FCC
3119 switch(priv->CustomerID)
3121 case RT_CID_DEFAULT:
3123 priv->LedStrategy = HW_LED;
3126 priv->LedStrategy = SW_LED_MODE1;
3131 case RT_CID_819x_CAMEO:
3132 priv->LedStrategy = SW_LED_MODE2;
3135 case RT_CID_819x_RUNTOP:
3136 priv->LedStrategy = SW_LED_MODE3;
3139 case RT_CID_819x_Netcore:
3140 priv->LedStrategy = SW_LED_MODE4;
3143 case RT_CID_Nettronix:
3144 priv->LedStrategy = SW_LED_MODE5;
3148 priv->LedStrategy = SW_LED_MODE6;
3151 case RT_CID_TOSHIBA: //Modify by Jacken 2008/01/31
3157 priv->LedStrategy = HW_LED;
3160 priv->LedStrategy = SW_LED_MODE1;
3167 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304)
3168 priv->ieee80211->bSupportRemoteWakeUp = true;
3170 priv->ieee80211->bSupportRemoteWakeUp = false;
3173 RT_TRACE(COMP_INIT, "RegChannelPlan(%d)\n", priv->RegChannelPlan);
3174 RT_TRACE(COMP_INIT, "ChannelPlan = %d \n", priv->ChannelPlan);
3175 RT_TRACE(COMP_INIT, "LedStrategy = %d \n", priv->LedStrategy);
3176 RT_TRACE(COMP_TRACE, "<==== ReadAdapterInfo\n");
3182 static short rtl8192_get_channel_map(struct net_device * dev)
3184 struct r8192_priv *priv = ieee80211_priv(dev);
3185 #ifdef ENABLE_DOT11D
3186 if(priv->ChannelPlan> COUNTRY_CODE_GLOBAL_DOMAIN){
3187 printk("rtl8180_init:Error channel plan! Set to default.\n");
3188 priv->ChannelPlan= 0;
3190 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
3192 rtl819x_set_channel_map(priv->ChannelPlan, priv);
3195 //Set Default Channel Plan
3197 DMESG("No channels, aborting");
3201 priv->ChannelPlan= 0;//hikaru
3202 // set channels 1..14 allowed in given locale
3203 for (i=1; i<=14; i++) {
3204 (priv->ieee80211->channel_map)[i] = (u8)(ch & 0x01);
3211 static short rtl8192_init(struct net_device *dev)
3213 struct r8192_priv *priv = ieee80211_priv(dev);
3214 memset(&(priv->stats),0,sizeof(struct Stats));
3215 rtl8192_init_priv_variable(dev);
3216 rtl8192_init_priv_lock(priv);
3217 rtl8192_init_priv_task(dev);
3218 rtl8192_get_eeprom_size(dev);
3219 rtl8192_read_eeprom_info(dev);
3220 rtl8192_get_channel_map(dev);
3222 init_timer(&priv->watch_dog_timer);
3223 priv->watch_dog_timer.data = (unsigned long)dev;
3224 priv->watch_dog_timer.function = watch_dog_timer_callback;
3225 #if defined(IRQF_SHARED)
3226 if(request_irq(dev->irq, (void*)rtl8192_interrupt, IRQF_SHARED, dev->name, dev)){
3228 if(request_irq(dev->irq, (void *)rtl8192_interrupt, SA_SHIRQ, dev->name, dev)){
3230 printk("Error allocating IRQ %d",dev->irq);
3234 printk("IRQ %d",dev->irq);
3236 if(rtl8192_pci_initdescring(dev)!=0){
3237 printk("Endopoints initialization failed");
3241 //rtl8192_rx_enable(dev);
3242 //rtl8192_adapter_start(dev);
3246 /******************************************************************************
3247 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
3248 * not to do all the hw config as its name says
3249 * input: net_device dev
3252 * notice: This part need to modified according to the rate set we filtered
3253 * ****************************************************************************/
3254 static void rtl8192_hwconfig(struct net_device* dev)
3256 u32 regRATR = 0, regRRSR = 0;
3257 u8 regBwOpMode = 0, regTmp = 0;
3258 struct r8192_priv *priv = ieee80211_priv(dev);
3260 // Set RRSR, RATR, and BW_OPMODE registers
3262 switch(priv->ieee80211->mode)
3264 case WIRELESS_MODE_B:
3265 regBwOpMode = BW_OPMODE_20MHZ;
3266 regRATR = RATE_ALL_CCK;
3267 regRRSR = RATE_ALL_CCK;
3269 case WIRELESS_MODE_A:
3270 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
3271 regRATR = RATE_ALL_OFDM_AG;
3272 regRRSR = RATE_ALL_OFDM_AG;
3274 case WIRELESS_MODE_G:
3275 regBwOpMode = BW_OPMODE_20MHZ;
3276 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3277 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3279 case WIRELESS_MODE_AUTO:
3280 case WIRELESS_MODE_N_24G:
3281 // It support CCK rate by default.
3282 // CCK rate will be filtered out only when associated AP does not support it.
3283 regBwOpMode = BW_OPMODE_20MHZ;
3284 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3285 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3287 case WIRELESS_MODE_N_5G:
3288 regBwOpMode = BW_OPMODE_5G;
3289 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3290 regRRSR = RATE_ALL_OFDM_AG;
3294 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
3297 ratr_value = regRATR;
3298 if (priv->rf_type == RF_1T2R)
3300 ratr_value &= ~(RATE_ALL_OFDM_2SS);
3302 write_nic_dword(dev, RATR0, ratr_value);
3303 write_nic_byte(dev, UFWP, 1);
3305 regTmp = read_nic_byte(dev, 0x313);
3306 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
3307 write_nic_dword(dev, RRSR, regRRSR);
3310 // Set Retry Limit here
3312 write_nic_word(dev, RETRY_LIMIT,
3313 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT |
3314 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3315 // Set Contention Window here
3319 // Set Tx Antenna including Feedback control
3321 // Set Auto Rate fallback control
3327 static RT_STATUS rtl8192_adapter_start(struct net_device *dev)
3329 struct r8192_priv *priv = ieee80211_priv(dev);
3330 // struct ieee80211_device *ieee = priv->ieee80211;
3332 RT_STATUS rtStatus = RT_STATUS_SUCCESS;
3333 // static char szMACPHYRegFile[] = RTL819X_PHY_MACPHY_REG;
3334 // static char szMACPHYRegPGFile[] = RTL819X_PHY_MACPHY_REG_PG;
3338 u8 ICVersion,SwitchingRegulatorOutput;
3340 bool bfirmwareok = true;
3344 u32 tmpRegA, tmpRegC, TempCCk;
3346 // u32 dwRegRead = 0;
3348 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3349 priv->being_init_adapter = true;
3350 rtl8192_pci_resetdescring(dev);
3351 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
3352 priv->Rf_Mode = RF_OP_By_SW_3wire;
3355 if(priv->ResetProgress == RESET_TYPE_NORESET)
3357 write_nic_byte(dev, ANAPAR, 0x37);
3358 // Accordign to designer's explain, LBUS active will never > 10ms. We delay 10ms
3359 // Joseph increae the time to prevent firmware download fail
3363 //PlatformSleepUs(10000);
3364 // For any kind of InitializeAdapter process, we shall use system now!!
3365 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3367 // Set to eRfoff in order not to count receive count.
3368 if(priv->RegRfOff == TRUE)
3369 priv->ieee80211->eRFPowerState = eRfOff;
3372 //3 //Config CPUReset Register
3374 //3 Firmware Reset Or Not
3375 ulRegRead = read_nic_dword(dev, CPU_GEN);
3376 if(priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3377 { //called from MPInitialized. do nothing
3378 ulRegRead |= CPU_GEN_SYSTEM_RESET;
3379 }else if(priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3380 ulRegRead |= CPU_GEN_FIRMWARE_RESET; // Called from MPReset
3382 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3385 //2008.06.03, for WOL 90 hw bug
3386 ulRegRead &= (~(CPU_GEN_GPIO_UART));
3389 write_nic_dword(dev, CPU_GEN, ulRegRead);
3395 //3 //Fix the issue of E-cut high temperature issue
3398 ICVersion = read_nic_byte(dev, IC_VERRSION);
3399 if(ICVersion >= 0x4) //E-cut only
3401 // HW SD suggest that we should not wirte this register too often, so driver
3402 // should readback this register. This register will be modified only when
3404 SwitchingRegulatorOutput = read_nic_byte(dev, SWREGULATOR);
3405 if(SwitchingRegulatorOutput != 0xb8)
3407 write_nic_byte(dev, SWREGULATOR, 0xa8);
3409 write_nic_byte(dev, SWREGULATOR, 0xb8);
3416 //3// Initialize BB before MAC
3418 RT_TRACE(COMP_INIT, "BB Config Start!\n");
3419 rtStatus = rtl8192_BBConfig(dev);
3420 if(rtStatus != RT_STATUS_SUCCESS)
3422 RT_TRACE(COMP_ERR, "BB Config failed\n");
3425 RT_TRACE(COMP_INIT,"BB Config Finished!\n");
3427 //3//Set Loopback mode or Normal mode
3429 //2006.12.13 by emily. Note!We should not merge these two CPU_GEN register writings
3430 // because setting of System_Reset bit reset MAC to default transmission mode.
3431 //Loopback mode or not
3432 priv->LoopbackMode = RTL819X_NO_LOOPBACK;
3433 //priv->LoopbackMode = RTL819X_MAC_LOOPBACK;
3434 if(priv->ResetProgress == RESET_TYPE_NORESET)
3436 ulRegRead = read_nic_dword(dev, CPU_GEN);
3437 if(priv->LoopbackMode == RTL819X_NO_LOOPBACK)
3439 ulRegRead = ((ulRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3441 else if (priv->LoopbackMode == RTL819X_MAC_LOOPBACK )
3443 ulRegRead |= CPU_CCK_LOOPBACK;
3447 RT_TRACE(COMP_ERR,"Serious error: wrong loopback mode setting\n");
3450 //2008.06.03, for WOL
3451 //ulRegRead &= (~(CPU_GEN_GPIO_UART));
3452 write_nic_dword(dev, CPU_GEN, ulRegRead);
3454 // 2006.11.29. After reset cpu, we sholud wait for a second, otherwise, it may fail to write registers. Emily
3457 //3Set Hardware(Do nothing now)
3458 rtl8192_hwconfig(dev);
3459 //2=======================================================
3460 // Common Setting for all of the FPGA platform. (part 1)
3461 //2=======================================================
3462 // If there is changes, please make sure it applies to all of the FPGA version
3464 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3468 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3469 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) |
3473 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3474 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) ));
3478 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3479 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3481 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3483 //3 Initialize Number of Reserved Pages in Firmware Queue
3485 if(priv->bInHctTest)
3487 PlatformEFIOWrite4Byte(Adapter, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK_DTM << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3488 NUM_OF_PAGE_IN_FW_QUEUE_BE_DTM << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3489 NUM_OF_PAGE_IN_FW_QUEUE_VI_DTM << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3490 NUM_OF_PAGE_IN_FW_QUEUE_VO_DTM <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3491 PlatformEFIOWrite4Byte(Adapter, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3492 PlatformEFIOWrite4Byte(Adapter, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3493 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3494 NUM_OF_PAGE_IN_FW_QUEUE_PUB_DTM<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3499 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3500 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3501 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3502 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3503 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3504 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3505 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3506 NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3509 rtl8192_tx_enable(dev);
3510 rtl8192_rx_enable(dev);
3511 //3Set Response Rate Setting Register
3512 // CCK rate is supported by default.
3513 // CCK rate will be filtered out only when associated AP does not support it.
3514 ulRegRead = (0xFFF00000 & read_nic_dword(dev, RRSR)) | RATE_ALL_OFDM_AG | RATE_ALL_CCK;
3515 write_nic_dword(dev, RRSR, ulRegRead);
3516 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3519 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3520 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3522 //rtl8192_actset_wirelessmode(dev,priv->RegWirelessMode);
3523 if(priv->ResetProgress == RESET_TYPE_NORESET)
3524 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3525 //-----------------------------------------------------------------------------
3526 // Set up security related. 070106, by rcnjko:
3527 // 1. Clear all H/W keys.
3528 // 2. Enable H/W encryption/decryption.
3529 //-----------------------------------------------------------------------------
3530 CamResetAllEntry(dev);
3532 u8 SECR_value = 0x0;
3533 SECR_value |= SCR_TxEncEnable;
3534 SECR_value |= SCR_RxDecEnable;
3535 SECR_value |= SCR_NoSKMC;
3536 write_nic_byte(dev, SECR, SECR_value);
3539 write_nic_word(dev, ATIMWND, 2);
3540 write_nic_word(dev, BCN_INTERVAL, 100);
3541 for (i=0; i<QOS_QUEUE_NUM; i++)
3542 write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
3544 // Switching regulator controller: This is set temporarily.
3545 // It's not sure if this can be removed in the future.
3546 // PJ advised to leave it by default.
3548 write_nic_byte(dev, 0xbe, 0xc0);
3550 //2=======================================================
3551 // Set PHY related configuration defined in MAC register bank
3552 //2=======================================================
3553 rtl8192_phy_configmac(dev);
3555 if (priv->card_8192_version > (u8) VERSION_8190_BD) {
3556 rtl8192_phy_getTxPower(dev);
3557 rtl8192_phy_setTxPower(dev, priv->chan);
3561 tmpvalue = read_nic_byte(dev, IC_VERRSION);
3562 priv->IC_Cut = tmpvalue;
3563 RT_TRACE(COMP_INIT, "priv->IC_Cut = 0x%x\n", priv->IC_Cut);
3564 if(priv->IC_Cut >= IC_VersionCut_D)
3566 //pHalData->bDcut = TRUE;
3567 if(priv->IC_Cut == IC_VersionCut_D)
3568 RT_TRACE(COMP_INIT, "D-cut\n");
3569 if(priv->IC_Cut == IC_VersionCut_E)
3571 RT_TRACE(COMP_INIT, "E-cut\n");
3572 // HW SD suggest that we should not wirte this register too often, so driver
3573 // should readback this register. This register will be modified only when
3579 //pHalData->bDcut = FALSE;
3580 RT_TRACE(COMP_INIT, "Before C-cut\n");
3585 RT_TRACE(COMP_INIT, "Load Firmware!\n");
3586 bfirmwareok = init_firmware(dev);
3587 if(bfirmwareok != true) {
3588 rtStatus = RT_STATUS_FAILURE;
3591 RT_TRACE(COMP_INIT, "Load Firmware finished!\n");
3594 if(priv->ResetProgress == RESET_TYPE_NORESET)
3596 RT_TRACE(COMP_INIT, "RF Config Started!\n");
3597 rtStatus = rtl8192_phy_RFConfig(dev);
3598 if(rtStatus != RT_STATUS_SUCCESS)
3600 RT_TRACE(COMP_ERR, "RF Config failed\n");
3603 RT_TRACE(COMP_INIT, "RF Config Finished!\n");
3605 rtl8192_phy_updateInitGain(dev);
3607 /*---- Set CCK and OFDM Block "ON"----*/
3608 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3609 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3613 write_nic_byte(dev, 0x87, 0x0);
3616 //2008.06.03, for WOL
3617 ucRegRead = read_nic_byte(dev, GPE);
3619 write_nic_byte(dev, GPE, ucRegRead);
3621 ucRegRead = read_nic_byte(dev, GPO);
3623 write_nic_byte(dev, GPO, ucRegRead);
3626 //2=======================================================
3628 //2=======================================================
3632 if(priv->RegRfOff == TRUE)
3633 { // User disable RF via registry.
3634 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RegRfOff ----------\n",__FUNCTION__);
3635 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW);
3636 #if 0//cosa, ask SD3 willis and he doesn't know what is this for
3637 // Those action will be discard in MgntActSet_RF_State because off the same state
3638 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3639 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3642 else if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS)
3643 { // H/W or S/W RF OFF before sleep.
3644 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3645 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3647 else if(priv->ieee80211->RfOffReason >= RF_CHANGE_BY_IPS)
3648 { // H/W or S/W RF OFF before sleep.
3649 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3650 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3654 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): RF-ON \n",__FUNCTION__);
3655 priv->ieee80211->eRFPowerState = eRfOn;
3656 priv->ieee80211->RfOffReason = 0;
3657 //DrvIFIndicateCurrentPhyStatus(Adapter);
3659 //Adapter->HalFunc.LedControlHandler(Adapter, LED_CTL_POWER_ON);
3662 // If inactive power mode is enabled, disable rf while in disconnected state.
3663 // But we should still tell upper layer we are in rf on state.
3664 // 2007.07.16, by shien chang.
3666 //if(!Adapter->bInHctTest)
3667 //IPSEnter(Adapter);
3674 // We can force firmware to do RF-R/W
3675 if(priv->ieee80211->FwRWRF)
3676 priv->Rf_Mode = RF_OP_By_FW;
3678 priv->Rf_Mode = RF_OP_By_SW_3wire;
3680 priv->Rf_Mode = RF_OP_By_SW_3wire;
3684 if(priv->ResetProgress == RESET_TYPE_NORESET)
3686 dm_initialize_txpower_tracking(dev);
3688 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3689 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3691 if(priv->rf_type == RF_2T4R){
3692 for(i = 0; i<TxBBGainTableLength; i++)
3694 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3696 priv->rfa_txpowertrackingindex= (u8)i;
3697 priv->rfa_txpowertrackingindex_real= (u8)i;
3698 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3703 for(i = 0; i<TxBBGainTableLength; i++)
3705 if(tmpRegC == priv->txbbgain_table[i].txbbgain_value)
3707 priv->rfc_txpowertrackingindex= (u8)i;
3708 priv->rfc_txpowertrackingindex_real= (u8)i;
3709 priv->rfc_txpowertracking_default = priv->rfc_txpowertrackingindex;
3713 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3715 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3717 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3719 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3723 priv->CCKPresentAttentuation_40Mdefault = 0;
3724 priv->CCKPresentAttentuation_difference = 0;
3725 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3726 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3727 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3728 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_initial = %d\n", priv->rfc_txpowertrackingindex);
3729 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_real_initial = %d\n", priv->rfc_txpowertrackingindex_real);
3730 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3731 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3735 if(priv->ResetProgress == RESET_TYPE_NORESET)
3737 dm_initialize_txpower_tracking(dev);
3739 if(priv->IC_Cut >= IC_VersionCut_D)
3741 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3742 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3743 for(i = 0; i<TxBBGainTableLength; i++)
3745 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3747 priv->rfa_txpowertrackingindex= (u8)i;
3748 priv->rfa_txpowertrackingindex_real= (u8)i;
3749 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3754 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3756 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3758 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3760 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3764 priv->CCKPresentAttentuation_40Mdefault = 0;
3765 priv->CCKPresentAttentuation_difference = 0;
3766 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3767 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3768 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3769 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3770 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3771 priv->btxpower_tracking = FALSE;//TEMPLY DISABLE
3776 rtl8192_irq_enable(dev);
3777 priv->being_init_adapter = false;
3782 static void rtl8192_prepare_beacon(struct r8192_priv *priv)
3784 struct sk_buff *skb;
3785 //unsigned long flags;
3788 skb = ieee80211_get_beacon(priv->ieee80211);
3789 tcb_desc = (cb_desc *)(skb->cb + 8);
3790 //printk("===========> %s\n", __FUNCTION__);
3791 //spin_lock_irqsave(&priv->tx_lock,flags);
3792 /* prepare misc info for the beacon xmit */
3793 tcb_desc->queue_index = BEACON_QUEUE;
3794 /* IBSS does not support HT yet, use 1M defaultly */
3795 tcb_desc->data_rate = 2;
3796 tcb_desc->RATRIndex = 7;
3797 tcb_desc->bTxDisableRateFallBack = 1;
3798 tcb_desc->bTxUseDriverAssingedRate = 1;
3800 skb_push(skb, priv->ieee80211->tx_headroom);
3802 rtl8192_tx(priv->ieee80211->dev,skb);
3804 //spin_unlock_irqrestore (&priv->tx_lock, flags);
3808 /* this configures registers for beacon tx and enables it via
3809 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3810 * be used to stop beacon transmission
3812 static void rtl8192_start_beacon(struct net_device *dev)
3814 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3815 struct ieee80211_network *net = &priv->ieee80211->current_network;
3820 DMESG("Enabling beacon TX");
3821 //rtl8192_prepare_beacon(dev);
3822 rtl8192_irq_disable(dev);
3823 //rtl8192_beacon_tx_enable(dev);
3826 write_nic_word(dev, ATIMWND, 2);
3828 /* Beacon interval (in unit of TU) */
3829 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
3832 * DrvErlyInt (in unit of TU).
3833 * (Time to send interrupt to notify driver to c
3834 * hange beacon content)
3836 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
3839 * BcnDMATIM(in unit of us).
3840 * Indicates the time before TBTT to perform beacon queue DMA
3842 write_nic_word(dev, BCN_DMATIME, 256);
3845 * Force beacon frame transmission even after receiving
3846 * beacon frame from other ad hoc STA
3848 write_nic_byte(dev, BCN_ERR_THRESH, 100);
3850 /* Set CW and IFS */
3851 BcnTimeCfg |= BcnCW<<BCN_TCFG_CW_SHIFT;
3852 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
3853 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
3856 /* enable the interrupt for ad-hoc process */
3857 rtl8192_irq_enable(dev);
3859 /***************************************************************************
3860 -------------------------------NET STUFF---------------------------
3861 ***************************************************************************/
3865 static bool HalTxCheckStuck8190Pci(struct net_device *dev)
3867 u16 RegTxCounter = read_nic_word(dev, 0x128);
3868 struct r8192_priv *priv = ieee80211_priv(dev);
3869 bool bStuck = FALSE;
3870 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3871 if(priv->TxCounter==RegTxCounter)
3874 priv->TxCounter = RegTxCounter;
3880 * <Assumption: RT_TX_SPINLOCK is acquired.>
3881 * First added: 2006.11.19 by emily
3884 TxCheckStuck(struct net_device *dev)
3886 struct r8192_priv *priv = ieee80211_priv(dev);
3888 ptx_ring head=NULL,tail=NULL,txring = NULL;
3889 u8 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3890 bool bCheckFwTxCnt = false;
3891 //unsigned long flags;
3894 // Decide Stuch threshold according to current power save mode
3896 //printk("++++++++++++>%s()\n",__FUNCTION__);
3897 switch (priv->ieee80211->dot11PowerSaveMode)
3899 // The threshold value may required to be adjusted .
3900 case eActive: // Active/Continuous access.
3901 ResetThreshold = NIC_SEND_HANG_THRESHOLD_NORMAL;
3903 case eMaxPs: // Max power save mode.
3904 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3906 case eFastPs: // Fast power save mode.
3907 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3912 // Check whether specific tcb has been queued for a specific time
3914 for(QueueID = 0; QueueID < MAX_TX_QUEUE; QueueID++)
3918 if(QueueID == TXCMD_QUEUE)
3923 tail=priv->txmapringtail;
3924 head=priv->txmapringhead;
3928 tail=priv->txbkpringtail;
3929 head=priv->txbkpringhead;
3933 tail=priv->txbepringtail;
3934 head=priv->txbepringhead;
3938 tail=priv->txvipringtail;
3939 head=priv->txvipringhead;
3943 tail=priv->txvopringtail;
3944 head=priv->txvopringhead;
3959 RT_TRACE(COMP_ERR,"%s():txring is NULL , BUG!\n",__FUNCTION__);
3962 txring->nStuckCount++;
3963 bCheckFwTxCnt = TRUE;
3969 if(HalTxCheckStuck8190Pci(dev))
3971 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3972 return RESET_TYPE_SILENT;
3976 return RESET_TYPE_NORESET;
3980 static bool HalRxCheckStuck8190Pci(struct net_device *dev)
3982 struct r8192_priv *priv = ieee80211_priv(dev);
3983 u16 RegRxCounter = read_nic_word(dev, 0x130);
3984 bool bStuck = FALSE;
3985 static u8 rx_chk_cnt = 0;
3986 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3987 // If rssi is small, we should check rx for long time because of bad rx.
3988 // or maybe it will continuous silent reset every 2 seconds.
3990 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3992 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
3994 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3995 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3996 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
4008 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
4009 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
4010 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
4014 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
4020 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
4027 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
4033 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
4036 if(priv->RxCounter==RegRxCounter)
4039 priv->RxCounter = RegRxCounter;
4044 static RESET_TYPE RxCheckStuck(struct net_device *dev)
4047 if(HalRxCheckStuck8190Pci(dev))
4049 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
4050 return RESET_TYPE_SILENT;
4053 return RESET_TYPE_NORESET;
4057 rtl819x_ifcheck_resetornot(struct net_device *dev)
4059 struct r8192_priv *priv = ieee80211_priv(dev);
4060 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
4061 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
4062 RT_RF_POWER_STATE rfState;
4064 rfState = priv->ieee80211->eRFPowerState;
4066 TxResetType = TxCheckStuck(dev);
4068 if( rfState != eRfOff &&
4069 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
4070 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
4072 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
4073 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
4074 // if driver is in firmware download failure status, driver should initialize RF in the following
4075 // silent reset procedure Emily, 2008.01.21
4077 // Driver should not check RX stuck in IBSS mode because it is required to
4078 // set Check BSSID in order to send beacon, however, if check BSSID is
4079 // set, STA cannot hear any packet a all. Emily, 2008.04.12
4080 RxResetType = RxCheckStuck(dev);
4084 RT_TRACE(COMP_RESET,"%s(): TxResetType is %d, RxResetType is %d\n",__FUNCTION__,TxResetType,RxResetType);
4085 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
4086 return RESET_TYPE_NORMAL;
4087 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT)
4088 return RESET_TYPE_SILENT;
4090 return RESET_TYPE_NORESET;
4095 static void CamRestoreAllEntry(struct net_device *dev)
4098 struct r8192_priv *priv = ieee80211_priv(dev);
4099 const u8* MacAddr = priv->ieee80211->current_network.bssid;
4101 static const u8 CAM_CONST_ADDR[4][6] = {
4102 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
4103 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
4104 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
4105 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
4106 static const u8 CAM_CONST_BROAD[] =
4107 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
4109 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
4112 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
4113 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
4116 for(EntryId=0; EntryId<4; EntryId++)
4119 MacAddr = CAM_CONST_ADDR[EntryId];
4123 priv->ieee80211->pairwise_key_type,
4131 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
4135 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4139 priv->ieee80211->pairwise_key_type,
4147 priv->ieee80211->pairwise_key_type,
4153 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
4157 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4161 priv->ieee80211->pairwise_key_type,
4169 priv->ieee80211->pairwise_key_type,
4178 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
4180 MacAddr = CAM_CONST_BROAD;
4181 for(EntryId=1 ; EntryId<4 ; EntryId++)
4187 priv->ieee80211->group_key_type,
4193 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4197 priv->ieee80211->group_key_type,
4202 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
4204 MacAddr = CAM_CONST_BROAD;
4205 for(EntryId=1; EntryId<4 ; EntryId++)
4211 priv->ieee80211->group_key_type,
4218 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4222 priv->ieee80211->group_key_type,
4230 * This function is used to fix Tx/Rx stop bug temporarily.
4231 * This function will do "system reset" to NIC when Tx or Rx is stuck.
4232 * The method checking Tx/Rx stuck of this function is supported by FW,
4233 * which reports Tx and Rx counter to register 0x128 and 0x130.
4235 static void rtl819x_ifsilentreset(struct net_device *dev)
4237 struct r8192_priv *priv = ieee80211_priv(dev);
4239 int reset_status = 0;
4240 struct ieee80211_device *ieee = priv->ieee80211;
4245 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
4246 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
4248 if(priv->ResetProgress==RESET_TYPE_NORESET)
4252 //LZM for PS-Poll AID issue. 090429
4253 if(priv->ieee80211->state == IEEE80211_LINKED)
4254 LeisurePSLeave(dev);
4257 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
4259 // Set the variable for reset.
4260 priv->ResetProgress = RESET_TYPE_SILENT;
4261 // rtl8192_close(dev);
4263 down(&priv->wx_sem);
4266 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
4271 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
4272 if(!netif_queue_stopped(dev))
4273 netif_stop_queue(dev);
4275 dm_backup_dynamic_mechanism_state(dev);
4277 rtl8192_irq_disable(dev);
4278 rtl8192_cancel_deferred_work(priv);
4280 del_timer_sync(&priv->watch_dog_timer);
4281 ieee->sync_scan_hurryup = 1;
4282 if(ieee->state == IEEE80211_LINKED)
4284 down(&ieee->wx_sem);
4285 printk("ieee->state is IEEE80211_LINKED\n");
4286 ieee80211_stop_send_beacons(priv->ieee80211);
4287 del_timer_sync(&ieee->associate_timer);
4288 cancel_delayed_work(&ieee->associate_retry_wq);
4289 ieee80211_stop_scan(ieee);
4293 printk("ieee->state is NOT LINKED\n");
4294 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4296 rtl8192_halt_adapter(dev, true);
4298 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
4299 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
4300 reset_status = _rtl8192_up(dev);
4302 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
4303 if(reset_status == -1)
4312 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n",__FUNCTION__);
4316 ieee->is_silent_reset = 1;
4318 EnableHWSecurityConfig8192(dev);
4320 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4322 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4325 queue_work(ieee->wq, &ieee->associate_complete_wq);
4329 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
4331 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4332 ieee->link_change(ieee->dev);
4334 // notify_wx_assoc_event(ieee);
4336 ieee80211_start_send_beacons(ieee);
4338 if (ieee->data_hard_resume)
4339 ieee->data_hard_resume(ieee->dev);
4340 netif_carrier_on(ieee->dev);
4344 CamRestoreAllEntry(dev);
4346 // Restore the previous setting for all dynamic mechanism
4347 dm_restore_dynamic_mechanism_state(dev);
4349 priv->ResetProgress = RESET_TYPE_NORESET;
4350 priv->reset_count++;
4352 priv->bForcedSilentReset =false;
4353 priv->bResetInProgress = false;
4355 // For test --> force write UFWP.
4356 write_nic_byte(dev, UFWP, 1);
4357 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4363 void InactivePsWorkItemCallback(struct net_device *dev)
4365 struct r8192_priv *priv = ieee80211_priv(dev);
4366 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4369 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() ---------> \n");
4371 // This flag "bSwRfProcessing", indicates the status of IPS procedure, should be set if the IPS workitem
4372 // is really scheduled.
4373 // The old code, sets this flag before scheduling the IPS workitem and however, at the same time the
4374 // previous IPS workitem did not end yet, fails to schedule the current workitem. Thus, bSwRfProcessing
4375 // blocks the IPS procedure of switching RF.
4376 // By Bruce, 2007-12-25.
4378 pPSC->bSwRfProcessing = TRUE;
4380 RT_TRACE(COMP_RF, "InactivePsWorkItemCallback(): Set RF to %s.\n",
4381 pPSC->eInactivePowerState == eRfOff?"OFF":"ON");
4384 MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
4387 // To solve CAM values miss in RF OFF, rewrite CAM values after RF ON. By Bruce, 2007-09-20.
4389 pPSC->bSwRfProcessing = FALSE;
4390 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() <--------- \n");
4395 // Change current and default preamble mode.
4396 // 2005.01.06, by rcnjko.
4398 bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev, u8 rtPsMode)
4400 struct r8192_priv *priv = ieee80211_priv(dev);
4401 //PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4402 //u8 RpwmVal, FwPwrMode;
4404 // Currently, we do not change power save mode on IBSS mode.
4405 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4411 // <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
4412 // some AP will not response to our mgnt frames with PwrMgt bit set,
4413 // e.g. cannot associate the AP.
4414 // So I commented out it. 2005.02.16, by rcnjko.
4416 // // Change device's power save mode.
4417 // Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
4419 // Update power save mode configured.
4420 //RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__FUNCTION__,rtPsMode);
4421 if(!priv->ps_force) {
4422 priv->ieee80211->ps = rtPsMode;
4425 // Awake immediately
4426 if(priv->ieee80211->sta_sleep != 0 && rtPsMode == IEEE80211_PS_DISABLED)
4428 unsigned long flags;
4430 //PlatformSetTimer(Adapter, &(pMgntInfo->AwakeTimer), 0);
4431 // Notify the AP we awke.
4432 rtl8192_hw_wakeup(dev);
4433 priv->ieee80211->sta_sleep = 0;
4435 spin_lock_irqsave(&(priv->ieee80211->mgmt_tx_lock), flags);
4436 printk("LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
4437 ieee80211_sta_ps_send_null_frame(priv->ieee80211, 0);
4438 spin_unlock_irqrestore(&(priv->ieee80211->mgmt_tx_lock), flags);
4444 //================================================================================
4445 // Leisure Power Save in linked state.
4446 //================================================================================
4450 // Enter the leisure power save mode.
4452 void LeisurePSEnter(struct net_device *dev)
4454 struct r8192_priv *priv = ieee80211_priv(dev);
4455 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4457 //RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
4458 //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
4459 // pPSC->bLeisurePs, priv->ieee80211->ps,pPSC->LpsIdleCount,RT_CHECK_FOR_HANG_PERIOD);
4461 if(!((priv->ieee80211->iw_mode == IW_MODE_INFRA) &&
4462 (priv->ieee80211->state == IEEE80211_LINKED)) ||
4463 (priv->ieee80211->iw_mode == IW_MODE_ADHOC) ||
4464 (priv->ieee80211->iw_mode == IW_MODE_MASTER))
4467 if (pPSC->bLeisurePs)
4469 // Idle for a while if we connect to AP a while ago.
4470 if(pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) // 4 Sec
4473 if(priv->ieee80211->ps == IEEE80211_PS_DISABLED)
4476 //RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter 802.11 power save mode...\n");
4477 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST);
4482 pPSC->LpsIdleCount++;
4489 // Leave the leisure power save mode.
4491 void LeisurePSLeave(struct net_device *dev)
4493 struct r8192_priv *priv = ieee80211_priv(dev);
4494 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4497 //RT_TRACE(COMP_PS, "LeisurePSLeave()...\n");
4498 //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d\n",
4499 // pPSC->bLeisurePs, priv->ieee80211->ps);
4501 if (pPSC->bLeisurePs)
4503 if(priv->ieee80211->ps != IEEE80211_PS_DISABLED)
4505 // move to lps_wakecomplete()
4506 //RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n");
4507 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_DISABLED);
4517 // Enter the inactive power save mode. RF will be off
4518 // 2007.08.17, by shien chang.
4521 IPSEnter(struct net_device *dev)
4523 struct r8192_priv *priv = ieee80211_priv(dev);
4524 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4525 RT_RF_POWER_STATE rtState;
4527 if (pPSC->bInactivePs)
4529 rtState = priv->ieee80211->eRFPowerState;
4531 // Added by Bruce, 2007-12-25.
4532 // Do not enter IPS in the following conditions:
4533 // (1) RF is already OFF or Sleep
4534 // (2) bSwRfProcessing (indicates the IPS is still under going)
4535 // (3) Connectted (only disconnected can trigger IPS)
4536 // (4) IBSS (send Beacon)
4537 // (5) AP mode (send Beacon)
4539 if (rtState == eRfOn && !pPSC->bSwRfProcessing
4540 && (priv->ieee80211->state != IEEE80211_LINKED) )
4542 RT_TRACE(COMP_RF,"IPSEnter(): Turn off RF.\n");
4543 //printk("IPSEnter(): Turn off RF.\n");
4544 pPSC->eInactivePowerState = eRfOff;
4545 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4546 InactivePsWorkItemCallback(dev);
4553 // Leave the inactive power save mode, RF will be on.
4554 // 2007.08.17, by shien chang.
4557 IPSLeave(struct net_device *dev)
4559 struct r8192_priv *priv = ieee80211_priv(dev);
4560 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4561 RT_RF_POWER_STATE rtState;
4563 if (pPSC->bInactivePs)
4565 rtState = priv->ieee80211->eRFPowerState;
4566 if (rtState != eRfOn && !pPSC->bSwRfProcessing && priv->ieee80211->RfOffReason <= RF_CHANGE_BY_IPS)
4568 RT_TRACE(COMP_POWER, "IPSLeave(): Turn on RF.\n");
4569 //printk("IPSLeave(): Turn on RF.\n");
4570 pPSC->eInactivePowerState = eRfOn;
4571 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4572 InactivePsWorkItemCallback(dev);
4577 void IPSLeave_wq(void *data)
4579 struct ieee80211_device *ieee = container_of(data,struct ieee80211_device,ips_leave_wq);
4580 struct net_device *dev = ieee->dev;
4582 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4583 down(&priv->ieee80211->ips_sem);
4585 up(&priv->ieee80211->ips_sem);
4588 void ieee80211_ips_leave_wq(struct net_device *dev)
4590 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4591 RT_RF_POWER_STATE rtState;
4592 rtState = priv->ieee80211->eRFPowerState;
4594 if(priv->ieee80211->PowerSaveControl.bInactivePs){
4595 if(rtState == eRfOff){
4596 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
4598 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
4602 printk("=========>%s(): IPSLeave\n",__FUNCTION__);
4603 queue_work(priv->ieee80211->wq,&priv->ieee80211->ips_leave_wq);
4608 //added by amy 090331 end
4609 void ieee80211_ips_leave(struct net_device *dev)
4611 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4612 down(&priv->ieee80211->ips_sem);
4614 up(&priv->ieee80211->ips_sem);
4618 static void rtl819x_update_rxcounts(
4619 struct r8192_priv *priv,
4628 *TotalRxDataNum = 0;
4630 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4631 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4632 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4633 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4634 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4635 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4640 static void rtl819x_watchdog_wqcallback(struct work_struct *work)
4642 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4643 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4644 struct net_device *dev = priv->ieee80211->dev;
4645 struct ieee80211_device* ieee = priv->ieee80211;
4646 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4647 static u8 check_reset_cnt=0;
4648 unsigned long flags;
4649 bool bBusyTraffic = false;
4650 static u8 last_time = 0;
4651 bool bEnterPS = false;
4653 if ((!priv->up) || priv->bHwRadioOff)
4658 hal_dm_watchdog(dev);
4660 // printk("watch_dog ENABLE_IPS\n");
4661 if(ieee->actscanning == false){
4662 //printk("%d,%d,%d,%d\n", ieee->eRFPowerState, ieee->is_set_key, ieee->proto_stoppping, ieee->wx_set_enc);
4663 if((ieee->iw_mode == IW_MODE_INFRA) && (ieee->state == IEEE80211_NOLINK) &&
4664 (ieee->eRFPowerState == eRfOn)&&!ieee->is_set_key &&
4665 (!ieee->proto_stoppping) && !ieee->wx_set_enc){
4666 if(ieee->PowerSaveControl.ReturnPoint == IPS_CALLBACK_NONE){
4667 //printk("====================>haha:IPSEnter()\n");
4669 //ieee80211_stop_scan(priv->ieee80211);
4674 {//to get busy traffic condition
4675 if(ieee->state == IEEE80211_LINKED)
4677 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 100 ||
4678 ieee->LinkDetectInfo.NumTxOkInPeriod> 100 ) {
4679 bBusyTraffic = true;
4683 //added by amy for Leisure PS
4684 if( ((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod + ieee->LinkDetectInfo.NumTxOkInPeriod) > 8 ) ||
4685 (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2) )
4687 //printk("ieee->LinkDetectInfo.NumRxUnicastOkInPeriod is %d,ieee->LinkDetectInfo.NumTxOkInPeriod is %d\n",
4688 // ieee->LinkDetectInfo.NumRxUnicastOkInPeriod,ieee->LinkDetectInfo.NumTxOkInPeriod);
4696 //printk("***bEnterPS = %d\n", bEnterPS);
4697 // LeisurePS only work in infra mode.
4700 LeisurePSEnter(dev);
4704 LeisurePSLeave(dev);
4712 //RT_TRACE(COMP_LPS,"====>no link LPS leave\n");
4713 LeisurePSLeave(dev);
4717 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4718 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4719 ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
4720 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4724 //added by amy for AP roaming
4727 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4729 u32 TotalRxBcnNum = 0;
4730 u32 TotalRxDataNum = 0;
4732 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4733 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4735 if( ieee->eRFPowerState == eRfOff)
4736 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4737 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4738 // Dot11d_Reset(dev);
4739 ieee->state = IEEE80211_ASSOCIATING;
4740 notify_wx_assoc_event(priv->ieee80211);
4741 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4742 ieee->is_roaming = true;
4743 ieee->is_set_key = false;
4744 ieee->link_change(dev);
4745 queue_work(ieee->wq, &ieee->associate_procedure_wq);
4748 ieee->LinkDetectInfo.NumRecvBcnInPeriod=0;
4749 ieee->LinkDetectInfo.NumRecvDataInPeriod=0;
4752 //check if reset the driver
4753 spin_lock_irqsave(&priv->tx_lock,flags);
4754 if(check_reset_cnt++ >= 3 && !ieee->is_roaming && (last_time != 1))
4756 ResetType = rtl819x_ifcheck_resetornot(dev);
4757 check_reset_cnt = 3;
4758 //DbgPrint("Start to check silent reset\n");
4760 spin_unlock_irqrestore(&priv->tx_lock,flags);
4761 if(!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_NORMAL)
4763 priv->ResetProgress = RESET_TYPE_NORMAL;
4764 RT_TRACE(COMP_RESET,"%s(): NOMAL RESET\n",__FUNCTION__);
4767 /* disable silent reset temply 2008.9.11*/
4769 if( ((priv->force_reset) || (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT))) // This is control by OID set in Pomelo
4772 rtl819x_ifsilentreset(dev);
4777 priv->force_reset = false;
4778 priv->bForcedSilentReset = false;
4779 priv->bResetInProgress = false;
4780 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4784 void watch_dog_timer_callback(unsigned long data)
4786 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4787 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq,0);
4788 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4792 static int _rtl8192_up(struct net_device *dev)
4794 struct r8192_priv *priv = ieee80211_priv(dev);
4796 RT_STATUS init_status = RT_STATUS_SUCCESS;
4798 priv->ieee80211->ieee_up=1;
4799 priv->bdisable_nic = false; //YJ,add,091111
4800 RT_TRACE(COMP_INIT, "Bringing up iface");
4802 init_status = rtl8192_adapter_start(dev);
4803 if(init_status != RT_STATUS_SUCCESS)
4805 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
4808 RT_TRACE(COMP_INIT, "start adapter finished\n");
4810 if(priv->ieee80211->eRFPowerState!=eRfOn)
4811 MgntActSet_RF_State(dev, eRfOn, priv->ieee80211->RfOffReason);
4813 if(priv->ieee80211->state != IEEE80211_LINKED)
4814 ieee80211_softmac_start_protocol(priv->ieee80211);
4815 ieee80211_reset_queue(priv->ieee80211);
4816 watch_dog_timer_callback((unsigned long) dev);
4817 if(!netif_queue_stopped(dev))
4818 netif_start_queue(dev);
4820 netif_wake_queue(dev);
4826 static int rtl8192_open(struct net_device *dev)
4828 struct r8192_priv *priv = ieee80211_priv(dev);
4831 down(&priv->wx_sem);
4832 ret = rtl8192_up(dev);
4839 int rtl8192_up(struct net_device *dev)
4841 struct r8192_priv *priv = ieee80211_priv(dev);
4843 if (priv->up == 1) return -1;
4845 return _rtl8192_up(dev);
4849 static int rtl8192_close(struct net_device *dev)
4851 struct r8192_priv *priv = ieee80211_priv(dev);
4854 down(&priv->wx_sem);
4856 ret = rtl8192_down(dev);
4864 int rtl8192_down(struct net_device *dev)
4866 struct r8192_priv *priv = ieee80211_priv(dev);
4872 if (priv->up == 0) return -1;
4875 //LZM for PS-Poll AID issue. 090429
4876 if(priv->ieee80211->state == IEEE80211_LINKED)
4877 LeisurePSLeave(dev);
4881 priv->ieee80211->ieee_up = 0;
4882 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4884 if (!netif_queue_stopped(dev))
4885 netif_stop_queue(dev);
4887 rtl8192_irq_disable(dev);
4889 if(!priv->ieee80211->bSupportRemoteWakeUp) {
4890 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_INIT);
4891 // 2006.11.30. System reset bit
4892 ulRegRead = read_nic_dword(dev, CPU_GEN);
4893 ulRegRead|=CPU_GEN_SYSTEM_RESET;
4894 write_nic_dword(dev, CPU_GEN, ulRegRead);
4896 //2008.06.03 for WOL
4897 write_nic_dword(dev, WFCRC0, 0xffffffff);
4898 write_nic_dword(dev, WFCRC1, 0xffffffff);
4899 write_nic_dword(dev, WFCRC2, 0xffffffff);
4902 ucRegRead = read_nic_byte(dev, GPO);
4904 write_nic_byte(dev, GPO, ucRegRead);
4906 //Write PMR register
4907 write_nic_byte(dev, PMR, 0x5);
4908 //Disable tx, enanble rx
4909 write_nic_byte(dev, MacBlkCtrl, 0xa);
4912 // flush_scheduled_work();
4913 rtl8192_cancel_deferred_work(priv);
4915 del_timer_sync(&priv->watch_dog_timer);
4917 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4919 rtl8192_halt_adapter(dev,false);
4920 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4922 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4928 void rtl8192_commit(struct net_device *dev)
4930 struct r8192_priv *priv = ieee80211_priv(dev);
4932 if (priv->up == 0) return ;
4935 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4937 rtl8192_irq_disable(dev);
4938 rtl8192_halt_adapter(dev,true);
4942 static void rtl8192_restart(struct work_struct *work)
4944 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4945 struct net_device *dev = priv->ieee80211->dev;
4947 down(&priv->wx_sem);
4949 rtl8192_commit(dev);
4954 static void r8192_set_multicast(struct net_device *dev)
4956 struct r8192_priv *priv = ieee80211_priv(dev);
4959 //down(&priv->wx_sem);
4963 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4965 if (promisc != priv->promisc) {
4967 // rtl8192_commit(dev);
4970 priv->promisc = promisc;
4972 //schedule_work(&priv->reset_wq);
4973 //up(&priv->wx_sem);
4977 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
4979 struct r8192_priv *priv = ieee80211_priv(dev);
4980 struct sockaddr *addr = mac;
4982 down(&priv->wx_sem);
4984 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4986 schedule_work(&priv->reset_wq);
4992 /* based on ipw2200 driver */
4993 static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4995 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4996 struct iwreq *wrq = (struct iwreq *)rq;
4998 struct ieee80211_device *ieee = priv->ieee80211;
5000 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
5001 struct iw_point *p = &wrq->u.data;
5002 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
5004 down(&priv->wx_sem);
5007 if (p->length < sizeof(struct ieee_param) || !p->pointer){
5012 ipw = kmalloc(p->length, GFP_KERNEL);
5017 if (copy_from_user(ipw, p->pointer, p->length)) {
5024 case RTL_IOCTL_WPA_SUPPLICANT:
5025 //parse here for HW security
5026 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
5028 if (ipw->u.crypt.set_tx)
5030 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
5031 ieee->pairwise_key_type = KEY_TYPE_CCMP;
5032 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
5033 ieee->pairwise_key_type = KEY_TYPE_TKIP;
5034 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
5036 if (ipw->u.crypt.key_len == 13)
5037 ieee->pairwise_key_type = KEY_TYPE_WEP104;
5038 else if (ipw->u.crypt.key_len == 5)
5039 ieee->pairwise_key_type = KEY_TYPE_WEP40;
5042 ieee->pairwise_key_type = KEY_TYPE_NA;
5044 if (ieee->pairwise_key_type)
5046 memcpy((u8*)key, ipw->u.crypt.key, 16);
5047 EnableHWSecurityConfig8192(dev);
5048 //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!
5050 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
5051 if (ieee->auth_mode != 2) //LEAP WEP will never set this.
5052 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
5054 if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) && ieee->pHTInfo->bCurrentHTSupport){
5055 write_nic_byte(dev, 0x173, 1); //fix aes bug
5059 else //if (ipw->u.crypt.idx) //group key use idx > 0
5061 memcpy((u8*)key, ipw->u.crypt.key, 16);
5062 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
5063 ieee->group_key_type= KEY_TYPE_CCMP;
5064 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
5065 ieee->group_key_type = KEY_TYPE_TKIP;
5066 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
5068 if (ipw->u.crypt.key_len == 13)
5069 ieee->group_key_type = KEY_TYPE_WEP104;
5070 else if (ipw->u.crypt.key_len == 5)
5071 ieee->group_key_type = KEY_TYPE_WEP40;
5074 ieee->group_key_type = KEY_TYPE_NA;
5076 if (ieee->group_key_type)
5080 ipw->u.crypt.idx, //KeyIndex
5081 ieee->group_key_type, //KeyType
5082 broadcast_addr, //MacAddr
5092 printk("@@ wrq->u pointer = ");
5093 for(i=0;i<wrq->u.data.length;i++){
5094 if(i%10==0) printk("\n");
5095 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
5099 #endif /*JOHN_DEBUG*/
5100 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
5115 static u8 HwRateToMRate90(bool bIsHT, u8 rate)
5121 case DESC90_RATE1M: ret_rate = MGN_1M; break;
5122 case DESC90_RATE2M: ret_rate = MGN_2M; break;
5123 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
5124 case DESC90_RATE11M: ret_rate = MGN_11M; break;
5125 case DESC90_RATE6M: ret_rate = MGN_6M; break;
5126 case DESC90_RATE9M: ret_rate = MGN_9M; break;
5127 case DESC90_RATE12M: ret_rate = MGN_12M; break;
5128 case DESC90_RATE18M: ret_rate = MGN_18M; break;
5129 case DESC90_RATE24M: ret_rate = MGN_24M; break;
5130 case DESC90_RATE36M: ret_rate = MGN_36M; break;
5131 case DESC90_RATE48M: ret_rate = MGN_48M; break;
5132 case DESC90_RATE54M: ret_rate = MGN_54M; break;
5135 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
5141 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
5142 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
5143 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
5144 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
5145 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
5146 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
5147 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
5148 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
5149 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
5150 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
5151 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
5152 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
5153 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
5154 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
5155 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
5156 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
5157 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
5160 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
5169 * Function: UpdateRxPktTimeStamp
5170 * Overview: Recored down the TSF time stamp when receiving a packet
5178 * (pRfd->Status.TimeStampHigh is updated)
5179 * (pRfd->Status.TimeStampLow is updated)
5183 static void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
5185 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5187 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
5188 stats->mac_time[0] = priv->LastRxDescTSFLow;
5189 stats->mac_time[1] = priv->LastRxDescTSFHigh;
5191 priv->LastRxDescTSFLow = stats->mac_time[0];
5192 priv->LastRxDescTSFHigh = stats->mac_time[1];
5196 static long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
5198 long signal_power; // in dBm.
5200 // Translate to dBm (x=0.5y-95).
5201 signal_power = (long)((signal_strength_index + 1) >> 1);
5204 return signal_power;
5209 // Update Rx signal related information in the packet reeived
5210 // to RxStats. User application can query RxStats to realize
5211 // current Rx signal status.
5214 // In normal operation, user only care about the information of the BSS
5215 // and we shall invoke this function if the packet received is from the BSS.
5218 rtl819x_update_rxsignalstatistics8190pci(
5219 struct r8192_priv * priv,
5220 struct ieee80211_rx_stats * pprevious_stats
5225 //2 <ToDo> Update Rx Statistics (such as signal strength and signal quality).
5228 if(priv->stats.recv_signal_power == 0)
5229 priv->stats.recv_signal_power = pprevious_stats->RecvSignalPower;
5231 // To avoid the past result restricting the statistics sensitivity, weight the current power (5/6) to speed up the
5232 // reaction of smoothed Signal Power.
5233 if(pprevious_stats->RecvSignalPower > priv->stats.recv_signal_power)
5235 else if(pprevious_stats->RecvSignalPower < priv->stats.recv_signal_power)
5238 // We need more correct power of received packets and the "SignalStrength" of RxStats have been beautified or translated,
5239 // so we record the correct power in Dbm here. By Bruce, 2008-03-07.
5241 priv->stats.recv_signal_power = (priv->stats.recv_signal_power * 5 + pprevious_stats->RecvSignalPower + weighting) / 6;
5245 rtl8190_process_cck_rxpathsel(
5246 struct r8192_priv * priv,
5247 struct ieee80211_rx_stats * pprevious_stats
5250 #ifdef RTL8190P //Only 90P 2T4R need to check
5251 char last_cck_adc_pwdb[4]={0,0,0,0};
5253 //cosa add for Rx path selection
5254 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable)
5256 if(pprevious_stats->bIsCCK &&
5257 (pprevious_stats->bPacketToSelf ||pprevious_stats->bPacketBeacon))
5259 /* record the cck adc_pwdb to the sliding window. */
5260 if(priv->stats.cck_adc_pwdb.TotalNum++ >= PHY_RSSI_SLID_WIN_MAX)
5262 priv->stats.cck_adc_pwdb.TotalNum = PHY_RSSI_SLID_WIN_MAX;
5263 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5265 last_cck_adc_pwdb[i] = priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index];
5266 priv->stats.cck_adc_pwdb.TotalVal[i] -= last_cck_adc_pwdb[i];
5269 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5271 priv->stats.cck_adc_pwdb.TotalVal[i] += pprevious_stats->cck_adc_pwdb[i];
5272 priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index] = pprevious_stats->cck_adc_pwdb[i];
5274 priv->stats.cck_adc_pwdb.index++;
5275 if(priv->stats.cck_adc_pwdb.index >= PHY_RSSI_SLID_WIN_MAX)
5276 priv->stats.cck_adc_pwdb.index = 0;
5278 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5280 DM_RxPathSelTable.cck_pwdb_sta[i] = priv->stats.cck_adc_pwdb.TotalVal[i]/priv->stats.cck_adc_pwdb.TotalNum;
5283 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5285 if(pprevious_stats->cck_adc_pwdb[i] > (char)priv->undecorated_smoothed_cck_adc_pwdb[i])
5287 priv->undecorated_smoothed_cck_adc_pwdb[i] =
5288 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
5289 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
5290 priv->undecorated_smoothed_cck_adc_pwdb[i] = priv->undecorated_smoothed_cck_adc_pwdb[i] + 1;
5294 priv->undecorated_smoothed_cck_adc_pwdb[i] =
5295 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
5296 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
5305 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
5306 be a local static. Otherwise, it may increase when we return from S3/S4. The
5307 value will be kept in memory or disk. We must delcare the value in adapter
5308 and it will be reinitialized when return from S3/S4. */
5309 static void rtl8192_process_phyinfo(struct r8192_priv * priv, u8* buffer,struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
5311 bool bcheck = false;
5313 u32 nspatial_stream, tmp_val;
5315 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
5316 static u32 slide_evm_index=0, slide_evm_statistics=0;
5317 static u32 last_rssi=0, last_evm=0;
5318 //cosa add for rx path selection
5319 // static long slide_cck_adc_pwdb_index=0, slide_cck_adc_pwdb_statistics=0;
5320 // static char last_cck_adc_pwdb[4]={0,0,0,0};
5321 //cosa add for beacon rssi smoothing
5322 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
5323 static u32 last_beacon_adc_pwdb=0;
5325 struct ieee80211_hdr_3addr *hdr;
5327 unsigned int frag,seq;
5328 hdr = (struct ieee80211_hdr_3addr *)buffer;
5329 sc = le16_to_cpu(hdr->seq_ctl);
5330 frag = WLAN_GET_SEQ_FRAG(sc);
5331 seq = WLAN_GET_SEQ_SEQ(sc);
5332 //cosa add 04292008 to record the sequence number
5333 pcurrent_stats->Seq_Num = seq;
5335 // Check whether we should take the previous packet into accounting
5337 if(!pprevious_stats->bIsAMPDU)
5339 // if previous packet is not aggregated packet
5343 //remve for that we don't use AMPDU to calculate PWDB,because the reported PWDB of some AP is fault.
5345 // if previous packet is aggregated packet, and current packet
5347 // (2) is the first packet of one AMPDU
5348 // that means the previous packet is the last one aggregated packet
5349 if( !pcurrent_stats->bIsAMPDU || pcurrent_stats->bFirstMPDU)
5354 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
5356 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
5357 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
5358 priv->stats.slide_rssi_total -= last_rssi;
5360 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
5362 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
5363 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
5364 slide_rssi_index = 0;
5366 // <1> Showed on UI for user, in dbm
5367 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
5368 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
5369 pcurrent_stats->rssi = priv->stats.signal_strength;
5371 // If the previous packet does not match the criteria, neglect it
5373 if(!pprevious_stats->bPacketMatchBSSID)
5375 if(!pprevious_stats->bToSelfBA)
5382 rtl8190_process_cck_rxpathsel(priv,pprevious_stats);
5387 priv->stats.num_process_phyinfo++;
5389 /* record the general signal strength to the sliding window. */
5390 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
5392 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
5393 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
5394 priv->stats.slide_rssi_total -= last_rssi;
5396 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
5398 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
5399 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
5400 slide_rssi_index = 0;
5402 // <1> Showed on UI for user, in dbm
5403 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
5404 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
5407 // <2> Showed on UI for engineering
5408 // hardware does not provide rssi information for each rf path in CCK
5409 if(!pprevious_stats->bIsCCK && pprevious_stats->bPacketToSelf)
5411 for (rfpath = RF90_PATH_A; rfpath < RF90_PATH_C; rfpath++)
5413 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
5415 RT_TRACE(COMP_DBG,"Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d \n" ,pprevious_stats->RxMIMOSignalStrength[rfpath] );
5416 //Fixed by Jacken 2008-03-20
5417 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
5419 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
5420 //DbgPrint("MIMO RSSI initialize \n");
5422 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
5424 priv->stats.rx_rssi_percentage[rfpath] =
5425 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5426 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5427 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
5431 priv->stats.rx_rssi_percentage[rfpath] =
5432 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5433 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5435 RT_TRACE(COMP_DBG,"Jacken -> priv->RxStats.RxRSSIPercentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
5443 //cosa add for beacon rssi smoothing by average.
5444 if(pprevious_stats->bPacketBeacon)
5446 /* record the beacon pwdb to the sliding window. */
5447 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5449 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
5450 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
5451 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
5452 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
5453 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
5455 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
5456 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
5457 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
5458 slide_beacon_adc_pwdb_index++;
5459 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5460 slide_beacon_adc_pwdb_index = 0;
5461 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
5462 if(pprevious_stats->RxPWDBAll >= 3)
5463 pprevious_stats->RxPWDBAll -= 3;
5466 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
5467 pprevious_stats->bIsCCK? "CCK": "OFDM",
5468 pprevious_stats->RxPWDBAll);
5470 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5472 if(priv->undecorated_smoothed_pwdb < 0) // initialize
5474 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
5475 //DbgPrint("First pwdb initialize \n");
5478 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
5480 priv->undecorated_smoothed_pwdb =
5481 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5482 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5483 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
5487 priv->undecorated_smoothed_pwdb =
5488 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5489 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5492 //Fixed by Jacken 2008-03-20
5493 if(pPreviousRfd->Status.RxPWDBAll > (u32)pHalData->UndecoratedSmoothedPWDB)
5495 pHalData->UndecoratedSmoothedPWDB =
5496 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5497 pHalData->UndecoratedSmoothedPWDB = pHalData->UndecoratedSmoothedPWDB + 1;
5501 pHalData->UndecoratedSmoothedPWDB =
5502 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5505 rtl819x_update_rxsignalstatistics8190pci(priv,pprevious_stats);
5511 /* record the general EVM to the sliding window. */
5512 if(pprevious_stats->SignalQuality == 0)
5517 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
5518 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
5519 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
5520 last_evm = priv->stats.slide_evm[slide_evm_index];
5521 priv->stats.slide_evm_total -= last_evm;
5524 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
5526 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
5527 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
5528 slide_evm_index = 0;
5530 // <1> Showed on UI for user, in percentage.
5531 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
5532 priv->stats.signal_quality = tmp_val;
5533 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
5534 priv->stats.last_signal_strength_inpercent = tmp_val;
5537 // <2> Showed on UI for engineering
5538 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5540 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
5542 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
5544 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
5546 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
5548 priv->stats.rx_evm_percentage[nspatial_stream] =
5549 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
5550 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
5558 /*-----------------------------------------------------------------------------
5559 * Function: rtl819x_query_rxpwrpercentage()
5563 * Input: char antpower
5567 * Return: 0-100 percentage
5571 * 05/26/2008 amy Create Version 0 porting from windows code.
5573 *---------------------------------------------------------------------------*/
5574 static u8 rtl819x_query_rxpwrpercentage(
5578 if ((antpower <= -100) || (antpower >= 20))
5582 else if (antpower >= 0)
5588 return (100+antpower);
5594 rtl819x_evm_dbtopercentage(
5606 ret_val = 0 - ret_val;
5615 // We want good-looking for signal strength/quality
5616 // 2007/7/19 01:09, by cosa.
5618 static long rtl819x_signal_scale_mapping(long currsig)
5622 // Step 1. Scale mapping.
5623 if(currsig >= 61 && currsig <= 100)
5625 retsig = 90 + ((currsig - 60) / 4);
5627 else if(currsig >= 41 && currsig <= 60)
5629 retsig = 78 + ((currsig - 40) / 2);
5631 else if(currsig >= 31 && currsig <= 40)
5633 retsig = 66 + (currsig - 30);
5635 else if(currsig >= 21 && currsig <= 30)
5637 retsig = 54 + (currsig - 20);
5639 else if(currsig >= 5 && currsig <= 20)
5641 retsig = 42 + (((currsig - 5) * 2) / 3);
5643 else if(currsig == 4)
5647 else if(currsig == 3)
5651 else if(currsig == 2)
5655 else if(currsig == 1)
5667 static void rtl8192_query_rxphystatus(
5668 struct r8192_priv * priv,
5669 struct ieee80211_rx_stats * pstats,
5670 prx_desc_819x_pci pdesc,
5671 prx_fwinfo_819x_pci pdrvinfo,
5672 struct ieee80211_rx_stats * precord_stats,
5673 bool bpacket_match_bssid,
5674 bool bpacket_toself,
5679 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
5680 phy_sts_ofdm_819xpci_t* pofdm_buf;
5681 phy_sts_cck_819xpci_t * pcck_buf;
5682 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
5684 u8 i,max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
5685 char rx_pwr[4], rx_pwr_all=0;
5686 //long rx_avg_pwr = 0;
5687 char rx_snrX, rx_evmX;
5689 u32 RSSI, total_rssi=0;//, total_evm=0;
5690 // long signal_strength_index = 0;
5694 /* 2007/07/04 MH For OFDM RSSI. For high power or not. */
5695 static u8 check_reg824 = 0;
5696 static u32 reg824_bit9 = 0;
5698 priv->stats.numqry_phystatus++;
5700 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
5702 // Record it for next packet processing
5703 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
5704 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
5705 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
5706 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
5707 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
5708 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
5709 /*2007.08.30 requested by SD3 Jerry */
5710 if(check_reg824 == 0)
5712 reg824_bit9 = rtl8192_QueryBBReg(priv->ieee80211->dev, rFPGA0_XA_HSSIParameter2, 0x200);
5717 prxpkt = (u8*)pdrvinfo;
5719 /* Move pointer to the 16th bytes. Phy status start address. */
5720 prxpkt += sizeof(rx_fwinfo_819x_pci);
5722 /* Initial the cck and ofdm buffer pointer */
5723 pcck_buf = (phy_sts_cck_819xpci_t *)prxpkt;
5724 pofdm_buf = (phy_sts_ofdm_819xpci_t *)prxpkt;
5726 pstats->RxMIMOSignalQuality[0] = -1;
5727 pstats->RxMIMOSignalQuality[1] = -1;
5728 precord_stats->RxMIMOSignalQuality[0] = -1;
5729 precord_stats->RxMIMOSignalQuality[1] = -1;
5734 // (1)Hardware does not provide RSSI for CCK
5738 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5740 u8 report;//, cck_agc_rpt;
5743 char cck_adc_pwdb[4];
5745 priv->stats.numqry_phystatusCCK++;
5747 #ifdef RTL8190P //Only 90P 2T4R need to check
5748 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable && bpacket_match_bssid)
5750 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5752 tmp_pwdb = pcck_buf->adc_pwdb_X[i];
5753 cck_adc_pwdb[i] = (char)tmp_pwdb;
5754 cck_adc_pwdb[i] /= 2;
5755 pstats->cck_adc_pwdb[i] = precord_stats->cck_adc_pwdb[i] = cck_adc_pwdb[i];
5756 //DbgPrint("RF-%d tmp_pwdb = 0x%x, cck_adc_pwdb = %d", i, tmp_pwdb, cck_adc_pwdb[i]);
5763 report = pcck_buf->cck_agc_rpt & 0xc0;
5767 //Fixed by Jacken from Bryant 2008-03-20
5768 //Original value is -38 , -26 , -14 , -2
5769 //Fixed value is -35 , -23 , -11 , 6
5771 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
5774 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
5777 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
5780 rx_pwr_all = 8 - (pcck_buf->cck_agc_rpt & 0x3e);
5786 report = pcck_buf->cck_agc_rpt & 0x60;
5791 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5794 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
5797 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5800 rx_pwr_all = -8 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5805 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5806 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5807 pstats->RecvSignalPower = rx_pwr_all;
5810 // (3) Get Signal Quality (EVM)
5812 if(bpacket_match_bssid)
5816 if(pstats->RxPWDBAll > 40)
5821 sq = pcck_buf->sq_rpt;
5823 if(pcck_buf->sq_rpt > 64)
5825 else if (pcck_buf->sq_rpt < 20)
5828 sq = ((64-sq) * 100) / 44;
5830 pstats->SignalQuality = precord_stats->SignalQuality = sq;
5831 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5832 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5837 priv->stats.numqry_phystatusHT++;
5839 // (1)Get RSSI for HT rate
5841 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5843 // 2008/01/30 MH we will judge RF RX path now.
5844 if (priv->brfpath_rxenable[i])
5849 //Fixed by Jacken from Bryant 2008-03-20
5850 //Original value is 106
5851 #ifdef RTL8190P //Modify by Jacken 2008/03/31
5852 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5854 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 110;
5857 //Get Rx snr value in DB
5858 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5859 rx_snrX = (char)(tmp_rxsnr);
5861 priv->stats.rxSNRdB[i] = (long)rx_snrX;
5863 /* Translate DBM to percentage. */
5864 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5865 if (priv->brfpath_rxenable[i])
5868 /* Record Signal Strength for next packet */
5869 if(bpacket_match_bssid)
5871 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5872 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5878 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5880 //Fixed by Jacken from Bryant 2008-03-20
5881 //Original value is 106
5882 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5883 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5885 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5886 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5887 pstats->RecvSignalPower = rx_pwr_all;
5889 // (3)EVM of HT rate
5891 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5892 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5893 max_spatial_stream = 2; //both spatial stream make sense
5895 max_spatial_stream = 1; //only spatial stream 1 makes sense
5897 for(i=0; i<max_spatial_stream; i++)
5899 tmp_rxevm = pofdm_buf->rxevm_X[i];
5900 rx_evmX = (char)(tmp_rxevm);
5902 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5903 // fill most significant bit to "zero" when doing shifting operation which may change a negative
5904 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5907 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5909 EVM = SignalScaleMapping(EVM);//make it good looking, from 0~100
5911 if(bpacket_match_bssid)
5913 if(i==0) // Fill value in RFD, Get the first spatial stream only
5914 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5915 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5920 /* record rx statistics for debug */
5921 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5922 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5923 if(pdrvinfo->BW) //40M channel
5924 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5926 priv->stats.received_bwtype[0]++;
5929 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5930 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5933 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5938 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u1Byte)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u1Byte)(total_rssi/=RF90_PATH_MAX);
5939 // We can judge RX path number now.
5941 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5946 rtl8192_record_rxdesc_forlateruse(
5947 struct ieee80211_rx_stats * psrc_stats,
5948 struct ieee80211_rx_stats * ptarget_stats
5951 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5952 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5953 //ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5958 static void TranslateRxSignalStuff819xpci(struct net_device *dev,
5959 struct sk_buff *skb,
5960 struct ieee80211_rx_stats * pstats,
5961 prx_desc_819x_pci pdesc,
5962 prx_fwinfo_819x_pci pdrvinfo)
5964 // TODO: We must only check packet for current MAC address. Not finish
5965 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5966 bool bpacket_match_bssid, bpacket_toself;
5967 bool bPacketBeacon=false, bToSelfBA=false;
5968 static struct ieee80211_rx_stats previous_stats;
5969 struct ieee80211_hdr_3addr *hdr;
5972 // Get Signal Quality for only RX data queue (but not command queue)
5977 /* Get MAC frame start address. */
5978 tmp_buf = skb->data;
5980 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5981 fc = le16_to_cpu(hdr->frame_ctl);
5982 type = WLAN_FC_GET_TYPE(fc);
5983 praddr = hdr->addr1;
5985 /* Check if the received packet is acceptabe. */
5986 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5987 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5988 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5989 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5991 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5993 bPacketBeacon = true;
5994 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5996 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5998 if((eqMacAddr(praddr,dev->dev_addr)))
6000 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
6004 if(bpacket_match_bssid)
6006 priv->stats.numpacket_matchbssid++;
6009 priv->stats.numpacket_toself++;
6012 // Process PHY information for previous packet (RSSI/PWDB/EVM)
6014 // Because phy information is contained in the last packet of AMPDU only, so driver
6015 // should process phy information of previous packet
6016 rtl8192_process_phyinfo(priv, tmp_buf,&previous_stats, pstats);
6017 rtl8192_query_rxphystatus(priv, pstats, pdesc, pdrvinfo, &previous_stats, bpacket_match_bssid,
6018 bpacket_toself ,bPacketBeacon, bToSelfBA);
6019 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
6024 static void rtl8192_tx_resume(struct net_device *dev)
6026 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6027 struct ieee80211_device *ieee = priv->ieee80211;
6028 struct sk_buff *skb;
6031 for(queue_index = BK_QUEUE; queue_index < TXCMD_QUEUE;queue_index++) {
6032 while((!skb_queue_empty(&ieee->skb_waitQ[queue_index]))&&
6033 (priv->ieee80211->check_nic_enough_desc(dev,queue_index) > 0)) {
6034 /* 1. dequeue the packet from the wait queue */
6035 skb = skb_dequeue(&ieee->skb_waitQ[queue_index]);
6036 /* 2. tx the packet directly */
6037 ieee->softmac_data_hard_start_xmit(skb,dev,0/* rate useless now*/);
6039 if(queue_index!=MGNT_QUEUE) {
6040 ieee->stats.tx_packets++;
6041 ieee->stats.tx_bytes += skb->len;
6048 static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv)
6050 rtl8192_tx_resume(priv->ieee80211->dev);
6054 * Function: UpdateReceivedRateHistogramStatistics
6055 * Overview: Recored down the received data rate
6063 * (Adapter->RxStats.ReceivedRateHistogram[] is updated)
6067 static void UpdateReceivedRateHistogramStatistics8190(
6068 struct net_device *dev,
6069 struct ieee80211_rx_stats* pstats
6072 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6073 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
6075 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
6077 /* 2007/03/09 MH We will not update rate of packet from rx cmd queue. */
6079 if (pRfd->queue_id == CMPK_RX_QUEUE_ID)
6084 else if(pstats->bICV)
6087 if(pstats->bShortPreamble)
6088 preamble_guardinterval = 1;// short
6090 preamble_guardinterval = 0;// long
6092 switch(pstats->rate)
6097 case MGN_1M: rateIndex = 0; break;
6098 case MGN_2M: rateIndex = 1; break;
6099 case MGN_5_5M: rateIndex = 2; break;
6100 case MGN_11M: rateIndex = 3; break;
6104 case MGN_6M: rateIndex = 4; break;
6105 case MGN_9M: rateIndex = 5; break;
6106 case MGN_12M: rateIndex = 6; break;
6107 case MGN_18M: rateIndex = 7; break;
6108 case MGN_24M: rateIndex = 8; break;
6109 case MGN_36M: rateIndex = 9; break;
6110 case MGN_48M: rateIndex = 10; break;
6111 case MGN_54M: rateIndex = 11; break;
6113 // 11n High throughput rate
6115 case MGN_MCS0: rateIndex = 12; break;
6116 case MGN_MCS1: rateIndex = 13; break;
6117 case MGN_MCS2: rateIndex = 14; break;
6118 case MGN_MCS3: rateIndex = 15; break;
6119 case MGN_MCS4: rateIndex = 16; break;
6120 case MGN_MCS5: rateIndex = 17; break;
6121 case MGN_MCS6: rateIndex = 18; break;
6122 case MGN_MCS7: rateIndex = 19; break;
6123 case MGN_MCS8: rateIndex = 20; break;
6124 case MGN_MCS9: rateIndex = 21; break;
6125 case MGN_MCS10: rateIndex = 22; break;
6126 case MGN_MCS11: rateIndex = 23; break;
6127 case MGN_MCS12: rateIndex = 24; break;
6128 case MGN_MCS13: rateIndex = 25; break;
6129 case MGN_MCS14: rateIndex = 26; break;
6130 case MGN_MCS15: rateIndex = 27; break;
6131 default: rateIndex = 28; break;
6133 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
6134 priv->stats.received_rate_histogram[0][rateIndex]++; //total
6135 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
6138 static void rtl8192_rx(struct net_device *dev)
6140 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6141 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
6142 bool unicast_packet = false;
6143 struct ieee80211_rx_stats stats = {
6147 .freq = IEEE80211_24GHZ_BAND,
6149 unsigned int count = priv->rxringcount;
6151 stats.nic_type = NIC_8192E;
6154 rx_desc_819x_pci *pdesc = &priv->rx_ring[priv->rx_idx];//rx descriptor
6155 struct sk_buff *skb = priv->rx_buf[priv->rx_idx];//rx pkt
6158 /* wait data to be filled by hardware */
6161 stats.bICV = pdesc->ICV;
6162 stats.bCRC = pdesc->CRC32;
6163 stats.bHwError = pdesc->CRC32 | pdesc->ICV;
6165 stats.Length = pdesc->Length;
6166 if(stats.Length < 24)
6167 stats.bHwError |= 1;
6169 if(stats.bHwError) {
6170 stats.bShift = false;
6173 if (pdesc->Length <500)
6174 priv->stats.rxcrcerrmin++;
6175 else if (pdesc->Length >1000)
6176 priv->stats.rxcrcerrmax++;
6178 priv->stats.rxcrcerrmid++;
6182 prx_fwinfo_819x_pci pDrvInfo = NULL;
6183 struct sk_buff *new_skb = dev_alloc_skb(priv->rxbuffersize);
6185 if (unlikely(!new_skb)) {
6189 stats.RxDrvInfoSize = pdesc->RxDrvInfoSize;
6190 stats.RxBufShift = ((pdesc->Shift)&0x03);
6191 stats.Decrypted = !pdesc->SWDec;
6193 pci_dma_sync_single_for_cpu(priv->pdev,
6194 *((dma_addr_t *)skb->cb),
6196 PCI_DMA_FROMDEVICE);
6197 skb_put(skb, pdesc->Length);
6198 pDrvInfo = (rx_fwinfo_819x_pci *)(skb->data + stats.RxBufShift);
6199 skb_reserve(skb, stats.RxDrvInfoSize + stats.RxBufShift);
6201 stats.rate = HwRateToMRate90((bool)pDrvInfo->RxHT, (u8)pDrvInfo->RxRate);
6202 stats.bShortPreamble = pDrvInfo->SPLCP;
6204 /* it is debug only. It should be disabled in released driver.
6205 * 2007.1.11 by Emily
6207 UpdateReceivedRateHistogramStatistics8190(dev, &stats);
6209 stats.bIsAMPDU = (pDrvInfo->PartAggr==1);
6210 stats.bFirstMPDU = (pDrvInfo->PartAggr==1) && (pDrvInfo->FirstAGGR==1);
6212 stats.TimeStampLow = pDrvInfo->TSFL;
6213 stats.TimeStampHigh = read_nic_dword(dev, TSFR+4);
6215 UpdateRxPktTimeStamp8190(dev, &stats);
6218 // Get Total offset of MPDU Frame Body
6220 if((stats.RxBufShift + stats.RxDrvInfoSize) > 0)
6223 stats.RxIs40MHzPacket = pDrvInfo->BW;
6226 TranslateRxSignalStuff819xpci(dev,skb, &stats, pdesc, pDrvInfo);
6229 if(pDrvInfo->FirstAGGR==1 || pDrvInfo->PartAggr == 1)
6230 RT_TRACE(COMP_RXDESC, "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
6231 pDrvInfo->FirstAGGR, pDrvInfo->PartAggr);
6232 skb_trim(skb, skb->len - 4/*sCrcLng*/);
6233 /* rx packets statistics */
6234 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
6235 unicast_packet = false;
6237 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
6239 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
6242 /* unicast packet */
6243 unicast_packet = true;
6246 stats.packetlength = stats.Length-4;
6247 stats.fraglength = stats.packetlength;
6248 stats.fragoffset = 0;
6249 stats.ntotalfrag = 1;
6251 if(!ieee80211_rtl_rx(priv->ieee80211, skb, &stats)){
6252 dev_kfree_skb_any(skb);
6255 if(unicast_packet) {
6256 priv->stats.rxbytesunicast += skb->len;
6261 priv->rx_buf[priv->rx_idx] = skb;
6262 *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev, skb_tail_pointer(skb), priv->rxbuffersize, PCI_DMA_FROMDEVICE);
6267 pdesc->BufferAddress = cpu_to_le32(*((dma_addr_t *)skb->cb));
6269 pdesc->Length = priv->rxbuffersize;
6270 if (priv->rx_idx == priv->rxringcount-1)
6272 priv->rx_idx = (priv->rx_idx + 1) % priv->rxringcount;
6277 static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
6279 rtl8192_rx(priv->ieee80211->dev);
6281 write_nic_dword(priv->ieee80211->dev, INTA_MASK,read_nic_dword(priv->ieee80211->dev, INTA_MASK) | IMR_RDU);
6284 static const struct net_device_ops rtl8192_netdev_ops = {
6285 .ndo_open = rtl8192_open,
6286 .ndo_stop = rtl8192_close,
6287 /* .ndo_get_stats = rtl8192_stats, */
6288 .ndo_tx_timeout = tx_timeout,
6289 .ndo_do_ioctl = rtl8192_ioctl,
6290 .ndo_set_multicast_list = r8192_set_multicast,
6291 .ndo_set_mac_address = r8192_set_mac_adr,
6292 .ndo_start_xmit = ieee80211_rtl_xmit,
6295 /****************************************************************************
6296 ---------------------------- PCI_STUFF---------------------------
6297 *****************************************************************************/
6299 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
6300 const struct pci_device_id *id)
6302 unsigned long ioaddr = 0;
6303 struct net_device *dev = NULL;
6304 struct r8192_priv *priv= NULL;
6308 #ifdef CONFIG_RTL8192_IO_MAP
6309 unsigned long pio_start, pio_len, pio_flags;
6311 unsigned long pmem_start, pmem_len, pmem_flags;
6312 #endif //end #ifdef RTL_IO_MAP
6314 RT_TRACE(COMP_INIT,"Configuring chip resources");
6316 if( pci_enable_device (pdev) ){
6317 RT_TRACE(COMP_ERR,"Failed to enable PCI device");
6321 pci_set_master(pdev);
6322 //pci_set_wmi(pdev);
6323 pci_set_dma_mask(pdev, 0xffffff00ULL);
6324 pci_set_consistent_dma_mask(pdev,0xffffff00ULL);
6325 dev = alloc_ieee80211(sizeof(struct r8192_priv));
6331 pci_set_drvdata(pdev, dev);
6332 SET_NETDEV_DEV(dev, &pdev->dev);
6333 priv = ieee80211_priv(dev);
6334 priv->ieee80211 = netdev_priv(dev);
6336 if((pdev->subsystem_vendor == PCI_VENDOR_ID_DLINK)&&(pdev->subsystem_device == 0x3304)){
6337 priv->ieee80211->bSupportRemoteWakeUp = 1;
6340 priv->ieee80211->bSupportRemoteWakeUp = 0;
6343 #ifdef CONFIG_RTL8192_IO_MAP
6345 pio_start = (unsigned long)pci_resource_start (pdev, 0);
6346 pio_len = (unsigned long)pci_resource_len (pdev, 0);
6347 pio_flags = (unsigned long)pci_resource_flags (pdev, 0);
6349 if (!(pio_flags & IORESOURCE_IO)) {
6350 RT_TRACE(COMP_ERR,"region #0 not a PIO resource, aborting");
6354 //DMESG("IO space @ 0x%08lx", pio_start );
6355 if( ! request_region( pio_start, pio_len, RTL819xE_MODULE_NAME ) ){
6356 RT_TRACE(COMP_ERR,"request_region failed!");
6361 dev->base_addr = ioaddr; // device I/O address
6365 pmem_start = pci_resource_start(pdev, 1);
6366 pmem_len = pci_resource_len(pdev, 1);
6367 pmem_flags = pci_resource_flags (pdev, 1);
6369 if (!(pmem_flags & IORESOURCE_MEM)) {
6370 RT_TRACE(COMP_ERR,"region #1 not a MMIO resource, aborting");
6374 //DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
6375 if( ! request_mem_region(pmem_start, pmem_len, RTL819xE_MODULE_NAME)) {
6376 RT_TRACE(COMP_ERR,"request_mem_region failed!");
6381 ioaddr = (unsigned long)ioremap_nocache( pmem_start, pmem_len);
6382 if( ioaddr == (unsigned long)NULL ){
6383 RT_TRACE(COMP_ERR,"ioremap failed!");
6384 // release_mem_region( pmem_start, pmem_len );
6388 dev->mem_start = ioaddr; // shared mem start
6389 dev->mem_end = ioaddr + pci_resource_len(pdev, 0); // shared mem end
6391 #endif //end #ifdef RTL_IO_MAP
6393 /* We disable the RETRY_TIMEOUT register (0x41) to keep
6394 * PCI Tx retries from interfering with C3 CPU state */
6395 pci_write_config_byte(pdev, 0x41, 0x00);
6398 pci_read_config_byte(pdev, 0x05, &unit);
6399 pci_write_config_byte(pdev, 0x05, unit & (~0x04));
6401 dev->irq = pdev->irq;
6404 dev->netdev_ops = &rtl8192_netdev_ops;
6406 dev->open = rtl8192_open;
6407 dev->stop = rtl8192_close;
6408 //dev->hard_start_xmit = rtl8192_8023_hard_start_xmit;
6409 dev->tx_timeout = tx_timeout;
6410 //dev->wireless_handlers = &r8192_wx_handlers_def;
6411 dev->do_ioctl = rtl8192_ioctl;
6412 dev->set_multicast_list = r8192_set_multicast;
6413 dev->set_mac_address = r8192_set_mac_adr;
6416 //DMESG("Oops: i'm coming\n");
6417 #if WIRELESS_EXT >= 12
6418 #if WIRELESS_EXT < 17
6419 dev->get_wireless_stats = r8192_get_wireless_stats;
6421 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
6423 //dev->get_wireless_stats = r8192_get_wireless_stats;
6424 dev->type=ARPHRD_ETHER;
6426 dev->watchdog_timeo = HZ*3; //modified by john, 0805
6428 if (dev_alloc_name(dev, ifname) < 0){
6429 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
6430 strcpy(ifname, "wlan%d");
6431 dev_alloc_name(dev, ifname);
6434 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
6435 if(rtl8192_init(dev)!=0){
6436 RT_TRACE(COMP_ERR, "Initialization failed");
6440 netif_carrier_off(dev);
6441 netif_stop_queue(dev);
6443 register_netdev(dev);
6444 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
6445 rtl8192_proc_init_one(dev);
6448 RT_TRACE(COMP_INIT, "Driver probe completed\n");
6453 #ifdef CONFIG_RTL8180_IO_MAP
6455 if( dev->base_addr != 0 ){
6457 release_region(dev->base_addr,
6458 pci_resource_len(pdev, 0) );
6461 if( dev->mem_start != (unsigned long)NULL ){
6462 iounmap( (void *)dev->mem_start );
6463 release_mem_region( pci_resource_start(pdev, 1),
6464 pci_resource_len(pdev, 1) );
6466 #endif //end #ifdef RTL_IO_MAP
6472 free_irq(dev->irq, dev);
6475 free_ieee80211(dev);
6479 pci_disable_device(pdev);
6481 DMESG("wlan driver load failed\n");
6482 pci_set_drvdata(pdev, NULL);
6487 /* detach all the work and timer structure declared or inititialized
6488 * in r8192_init function.
6490 static void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
6492 /* call cancel_work_sync instead of cancel_delayed_work if and only if Linux_version_code
6493 * is or is newer than 2.6.20 and work structure is defined to be struct work_struct.
6494 * Otherwise call cancel_delayed_work is enough.
6495 * FIXME (2.6.20 should 2.6.22, work_struct should not cancel)
6497 cancel_delayed_work(&priv->watch_dog_wq);
6498 cancel_delayed_work(&priv->update_beacon_wq);
6499 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
6500 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
6502 cancel_delayed_work(&priv->gpio_change_rf_wq);
6504 cancel_work_sync(&priv->reset_wq);
6505 cancel_work_sync(&priv->qos_activate);
6506 //cancel_work_sync(&priv->SetBWModeWorkItem);
6507 //cancel_work_sync(&priv->SwChnlWorkItem);
6512 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev)
6514 struct net_device *dev = pci_get_drvdata(pdev);
6515 struct r8192_priv *priv ;
6519 unregister_netdev(dev);
6521 priv=ieee80211_priv(dev);
6523 rtl8192_proc_remove_one(dev);
6526 if (priv->pFirmware)
6528 vfree(priv->pFirmware);
6529 priv->pFirmware = NULL;
6531 // priv->rf_close(dev);
6532 // rtl8192_usb_deleteendpoints(dev);
6533 destroy_workqueue(priv->priv_wq);
6534 /* redundant with rtl8192_down */
6535 // rtl8192_irq_disable(dev);
6536 // rtl8192_reset(dev);
6540 /* free tx/rx rings */
6541 rtl8192_free_rx_ring(dev);
6542 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
6543 rtl8192_free_tx_ring(dev, i);
6548 printk("Freeing irq %d\n",dev->irq);
6549 free_irq(dev->irq, dev);
6556 // free_beacon_desc_ring(dev,priv->txbeaconcount);
6558 #ifdef CONFIG_RTL8180_IO_MAP
6560 if( dev->base_addr != 0 ){
6562 release_region(dev->base_addr,
6563 pci_resource_len(pdev, 0) );
6566 if( dev->mem_start != (unsigned long)NULL ){
6567 iounmap( (void *)dev->mem_start );
6568 release_mem_region( pci_resource_start(pdev, 1),
6569 pci_resource_len(pdev, 1) );
6571 #endif /*end #ifdef RTL_IO_MAP*/
6572 free_ieee80211(dev);
6576 pci_disable_device(pdev);
6577 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
6580 extern int ieee80211_rtl_init(void);
6581 extern void ieee80211_rtl_exit(void);
6583 static int __init rtl8192_pci_module_init(void)
6587 retval = ieee80211_rtl_init();
6591 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
6592 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
6593 RT_TRACE(COMP_INIT, "Initializing module");
6594 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
6595 rtl8192_proc_module_init();
6596 if(0!=pci_register_driver(&rtl8192_pci_driver))
6598 DMESG("No device found");
6599 /*pci_unregister_driver (&rtl8192_pci_driver);*/
6606 static void __exit rtl8192_pci_module_exit(void)
6608 pci_unregister_driver(&rtl8192_pci_driver);
6610 RT_TRACE(COMP_DOWN, "Exiting");
6611 rtl8192_proc_module_remove();
6612 ieee80211_rtl_exit();
6615 //warning message WB
6616 static irqreturn_t rtl8192_interrupt(int irq, void *netdev)
6618 struct net_device *dev = (struct net_device *) netdev;
6619 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6620 unsigned long flags;
6622 /* We should return IRQ_NONE, but for now let me keep this */
6623 if(priv->irq_enabled == 0){
6627 spin_lock_irqsave(&priv->irq_th_lock,flags);
6631 inta = read_nic_dword(dev, ISR);// & priv->IntrMask;
6632 write_nic_dword(dev,ISR,inta); // reset int situation
6634 priv->stats.shints++;
6635 //DMESG("Enter interrupt, ISR value = 0x%08x", inta);
6637 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6640 most probably we can safely return IRQ_NONE,
6641 but for now is better to avoid problems
6647 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6653 DMESG("NIC irq %x",inta);
6655 //priv->irqpending = inta;
6658 if(!netif_running(dev)) {
6659 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6663 if(inta & IMR_TIMEOUT0){
6664 // write_nic_dword(dev, TimerInt, 0);
6665 //DMESG("=================>waking up");
6666 // rtl8180_hw_wakeup(dev);
6669 if(inta & IMR_TBDOK){
6670 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6671 rtl8192_tx_isr(dev, BEACON_QUEUE);
6672 priv->stats.txbeaconokint++;
6675 if(inta & IMR_TBDER){
6676 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6677 rtl8192_tx_isr(dev, BEACON_QUEUE);
6678 priv->stats.txbeaconerr++;
6681 if(inta & IMR_MGNTDOK ) {
6682 RT_TRACE(COMP_INTR, "Manage ok interrupt!\n");
6683 priv->stats.txmanageokint++;
6684 rtl8192_tx_isr(dev,MGNT_QUEUE);
6688 if(inta & IMR_COMDOK)
6690 priv->stats.txcmdpktokint++;
6691 rtl8192_tx_isr(dev,TXCMD_QUEUE);
6696 DMESG("Frame arrived !");
6698 priv->stats.rxint++;
6699 tasklet_schedule(&priv->irq_rx_tasklet);
6702 if(inta & IMR_BcnInt) {
6703 RT_TRACE(COMP_INTR, "prepare beacon for interrupt!\n");
6704 tasklet_schedule(&priv->irq_prepare_beacon_tasklet);
6708 RT_TRACE(COMP_INTR, "rx descriptor unavailable!\n");
6709 priv->stats.rxrdu++;
6710 /* reset int situation */
6711 write_nic_dword(dev,INTA_MASK,read_nic_dword(dev, INTA_MASK) & ~IMR_RDU);
6712 tasklet_schedule(&priv->irq_rx_tasklet);
6715 if(inta & IMR_RXFOVW){
6716 RT_TRACE(COMP_INTR, "rx overflow !\n");
6717 priv->stats.rxoverflow++;
6718 tasklet_schedule(&priv->irq_rx_tasklet);
6721 if(inta & IMR_TXFOVW) priv->stats.txoverflow++;
6723 if(inta & IMR_BKDOK){
6724 RT_TRACE(COMP_INTR, "BK Tx OK interrupt!\n");
6725 priv->stats.txbkokint++;
6726 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6727 rtl8192_tx_isr(dev,BK_QUEUE);
6728 rtl8192_try_wake_queue(dev, BK_QUEUE);
6731 if(inta & IMR_BEDOK){
6732 RT_TRACE(COMP_INTR, "BE TX OK interrupt!\n");
6733 priv->stats.txbeokint++;
6734 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6735 rtl8192_tx_isr(dev,BE_QUEUE);
6736 rtl8192_try_wake_queue(dev, BE_QUEUE);
6739 if(inta & IMR_VIDOK){
6740 RT_TRACE(COMP_INTR, "VI TX OK interrupt!\n");
6741 priv->stats.txviokint++;
6742 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6743 rtl8192_tx_isr(dev,VI_QUEUE);
6744 rtl8192_try_wake_queue(dev, VI_QUEUE);
6747 if(inta & IMR_VODOK){
6748 priv->stats.txvookint++;
6749 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6750 rtl8192_tx_isr(dev,VO_QUEUE);
6751 rtl8192_try_wake_queue(dev, VO_QUEUE);
6754 force_pci_posting(dev);
6755 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6760 static void rtl8192_try_wake_queue(struct net_device *dev, int pri)
6763 unsigned long flags;
6765 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6767 spin_lock_irqsave(&priv->tx_lock,flags);
6768 enough_desc = check_nic_enough_desc(dev,pri);
6769 spin_unlock_irqrestore(&priv->tx_lock,flags);
6772 ieee80211_rtl_wake_queue(priv->ieee80211);
6777 void EnableHWSecurityConfig8192(struct net_device *dev)
6779 u8 SECR_value = 0x0;
6780 // struct ieee80211_device* ieee1 = container_of(&dev, struct ieee80211_device, dev);
6781 //printk("==>ieee1:%p, dev:%p\n", ieee1, dev);
6782 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6783 struct ieee80211_device* ieee = priv->ieee80211;
6784 //printk("==>ieee:%p, dev:%p\n", ieee, dev);
6785 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
6787 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
6789 SECR_value |= SCR_RxUseDK;
6790 SECR_value |= SCR_TxUseDK;
6792 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
6794 SECR_value |= SCR_RxUseDK;
6795 SECR_value |= SCR_TxUseDK;
6800 //add HWSec active enable here.
6801 //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
6802 ieee->hwsec_active = 1;
6804 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
6806 ieee->hwsec_active = 0;
6807 SECR_value &= ~SCR_RxDecEnable;
6810 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__,
6811 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
6813 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
6817 #define TOTAL_CAM_ENTRY 32
6818 //#define CAM_CONTENT_COUNT 8
6819 void setKey( struct net_device *dev,
6827 u32 TargetCommand = 0;
6828 u32 TargetContent = 0;
6832 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6833 RT_RF_POWER_STATE rtState;
6834 rtState = priv->ieee80211->eRFPowerState;
6835 if(priv->ieee80211->PowerSaveControl.bInactivePs){
6836 if(rtState == eRfOff){
6837 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
6839 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
6840 //up(&priv->wx_sem);
6844 down(&priv->ieee80211->ips_sem);
6846 up(&priv->ieee80211->ips_sem);
6850 priv->ieee80211->is_set_key = true;
6852 if (EntryNo >= TOTAL_CAM_ENTRY)
6853 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
6855 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
6858 usConfig |= BIT15 | (KeyType<<2);
6860 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
6861 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
6864 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
6865 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
6866 TargetCommand |= BIT31|BIT16;
6868 if(i==0){//MAC|Config
6869 TargetContent = (u32)(*(MacAddr+0)) << 16|
6870 (u32)(*(MacAddr+1)) << 24|
6873 write_nic_dword(dev, WCAMI, TargetContent);
6874 write_nic_dword(dev, RWCAM, TargetCommand);
6875 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6878 TargetContent = (u32)(*(MacAddr+2)) |
6879 (u32)(*(MacAddr+3)) << 8|
6880 (u32)(*(MacAddr+4)) << 16|
6881 (u32)(*(MacAddr+5)) << 24;
6882 write_nic_dword(dev, WCAMI, TargetContent);
6883 write_nic_dword(dev, RWCAM, TargetCommand);
6885 else { //Key Material
6886 if(KeyContent != NULL)
6888 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6889 write_nic_dword(dev, RWCAM, TargetCommand);
6893 RT_TRACE(COMP_SEC,"=========>after set key, usconfig:%x\n", usConfig);
6896 bool NicIFEnableNIC(struct net_device* dev)
6898 RT_STATUS init_status = RT_STATUS_SUCCESS;
6899 struct r8192_priv* priv = ieee80211_priv(dev);
6900 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
6904 RT_TRACE(COMP_ERR, "ERR!!! %s(): Driver is already down!\n",__FUNCTION__);
6905 priv->bdisable_nic = false; //YJ,add,091111
6908 // <1> Reset memory: descriptor, buffer,..
6909 //NicIFResetMemory(Adapter);
6911 // <2> Enable Adapter
6912 //printk("===========>%s()\n",__FUNCTION__);
6913 //priv->bfirst_init = true;
6914 init_status = rtl8192_adapter_start(dev);
6915 if (init_status != RT_STATUS_SUCCESS) {
6916 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
6917 priv->bdisable_nic = false; //YJ,add,091111
6920 //printk("start adapter finished\n");
6921 RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
6922 //priv->bfirst_init = false;
6924 // <3> Enable Interrupt
6925 rtl8192_irq_enable(dev);
6926 priv->bdisable_nic = false;
6927 //RT_TRACE(COMP_PS,"<===========%s()\n",__FUNCTION__);
6928 return (init_status == RT_STATUS_SUCCESS);
6930 bool NicIFDisableNIC(struct net_device* dev)
6933 struct r8192_priv* priv = ieee80211_priv(dev);
6935 // <1> Disable Interrupt
6936 //RT_TRACE(COMP_PS, "=========>%s()\n",__FUNCTION__);
6937 priv->bdisable_nic = true; //YJ,move,091109
6938 tmp_state = priv->ieee80211->state;
6940 ieee80211_softmac_stop_protocol(priv->ieee80211, false);
6942 priv->ieee80211->state = tmp_state;
6943 rtl8192_cancel_deferred_work(priv);
6944 rtl8192_irq_disable(dev);
6945 // <2> Stop all timer
6947 // <3> Disable Adapter
6948 rtl8192_halt_adapter(dev, false);
6949 // priv->bdisable_nic = true;
6950 //RT_TRACE(COMP_PS, "<=========%s()\n",__FUNCTION__);
6956 /***************************************************************************
6957 ------------------- module init / exit stubs ----------------
6958 ****************************************************************************/
6959 module_init(rtl8192_pci_module_init);
6960 module_exit(rtl8192_pci_module_exit);