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 <asm/uaccess.h>
51 #include "r8192E_hw.h"
53 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
54 #include "r8180_93cx6.h" /* Card EEPROM */
55 #include "r8192E_wx.h"
56 #include "r819xE_phy.h" //added by WB 4.30.2008
57 #include "r819xE_phyreg.h"
58 #include "r819xE_cmdpkt.h"
59 #include "r8192E_dm.h"
60 //#include "r8192xU_phyreg.h"
61 //#include <linux/usb.h>
62 // FIXME: check if 2.6.7 is ok
69 #include "ieee80211/dot11d.h"
72 //set here to open your trace code. //WB
73 u32 rt_global_debug_component = \
91 // COMP_POWER_TRACKING |
93 COMP_ERR ; //always open err flags on
95 #define PCI_DEVICE(vend,dev)\
96 .vendor=(vend),.device=(dev),\
97 .subvendor=PCI_ANY_ID,.subdevice=PCI_ANY_ID
99 static struct pci_device_id rtl8192_pci_id_tbl[] __devinitdata = {
103 { PCI_DEVICE(0x10ec, 0x8190) },
105 { PCI_DEVICE(0x07aa, 0x0045) },
106 { PCI_DEVICE(0x07aa, 0x0046) },
109 { PCI_DEVICE(0x10ec, 0x8192) },
112 { PCI_DEVICE(0x07aa, 0x0044) },
113 { PCI_DEVICE(0x07aa, 0x0047) },
118 static char* ifname = "wlan%d";
119 static int hwwep = 1; //default use hw. set 0 to use software security
120 static int channels = 0x3fff;
122 MODULE_LICENSE("GPL");
123 MODULE_VERSION("V 1.1");
124 MODULE_DEVICE_TABLE(pci, rtl8192_pci_id_tbl);
125 //MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
126 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
129 module_param(ifname, charp, S_IRUGO|S_IWUSR );
130 //module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
131 module_param(hwwep,int, S_IRUGO|S_IWUSR);
132 module_param(channels,int, S_IRUGO|S_IWUSR);
134 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
135 //MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
136 MODULE_PARM_DESC(hwwep," Try to use hardware WEP support. Still broken and not available on all cards");
137 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
139 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
140 const struct pci_device_id *id);
141 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev);
143 static struct pci_driver rtl8192_pci_driver = {
144 .name = RTL819xE_MODULE_NAME, /* Driver name */
145 .id_table = rtl8192_pci_id_tbl, /* PCI_ID table */
146 .probe = rtl8192_pci_probe, /* probe fn */
147 .remove = __devexit_p(rtl8192_pci_disconnect), /* remove fn */
149 .suspend = rtl8192E_suspend, /* PM suspend fn */
150 .resume = rtl8192E_resume, /* PM resume fn */
152 .suspend = NULL, /* PM suspend fn */
153 .resume = NULL, /* PM resume fn */
159 typedef struct _CHANNEL_LIST
163 }CHANNEL_LIST, *PCHANNEL_LIST;
165 static CHANNEL_LIST ChannelPlan[] = {
166 {{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
167 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
168 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
169 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
170 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
171 {{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
172 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
173 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
174 {{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
175 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
176 {{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
179 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
181 int i, max_chan=-1, min_chan=-1;
182 struct ieee80211_device* ieee = priv->ieee80211;
183 switch (channel_plan)
185 case COUNTRY_CODE_FCC:
186 case COUNTRY_CODE_IC:
187 case COUNTRY_CODE_ETSI:
188 case COUNTRY_CODE_SPAIN:
189 case COUNTRY_CODE_FRANCE:
190 case COUNTRY_CODE_MKK:
191 case COUNTRY_CODE_MKK1:
192 case COUNTRY_CODE_ISRAEL:
193 case COUNTRY_CODE_TELEC:
194 case COUNTRY_CODE_MIC:
197 ieee->bGlobalDomain = false;
198 //acturally 8225 & 8256 rf chip only support B,G,24N mode
199 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256))
206 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
208 if (ChannelPlan[channel_plan].Len != 0){
209 // Clear old channel map
210 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
211 // Set new channel map
212 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
214 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
216 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
221 case COUNTRY_CODE_GLOBAL_DOMAIN:
223 GET_DOT11D_INFO(ieee)->bEnabled = 0; //this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain setting
225 ieee->bGlobalDomain = true;
235 #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 )
236 /* 2007/07/25 MH Defien temp tx fw info. */
237 static TX_FWINFO_T Tmp_TxFwInfo;
240 #define rx_hal_is_cck_rate(_pdrvinfo)\
241 (_pdrvinfo->RxRate == DESC90_RATE1M ||\
242 _pdrvinfo->RxRate == DESC90_RATE2M ||\
243 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
244 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
248 void CamResetAllEntry(struct net_device *dev)
254 ulcommand |= BIT31|BIT30;
255 write_nic_dword(dev, RWCAM, ulcommand);
257 for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
258 CAM_mark_invalid(dev, ucIndex);
259 for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
260 CAM_empty_entry(dev, ucIndex);
265 void write_cam(struct net_device *dev, u8 addr, u32 data)
267 write_nic_dword(dev, WCAMI, data);
268 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
270 u32 read_cam(struct net_device *dev, u8 addr)
272 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
273 return read_nic_dword(dev, 0xa8);
276 ////////////////////////////////////////////////////////////
277 #ifdef CONFIG_RTL8180_IO_MAP
279 u8 read_nic_byte(struct net_device *dev, int x)
281 return 0xff&inb(dev->base_addr +x);
284 u32 read_nic_dword(struct net_device *dev, int x)
286 return inl(dev->base_addr +x);
289 u16 read_nic_word(struct net_device *dev, int x)
291 return inw(dev->base_addr +x);
294 void write_nic_byte(struct net_device *dev, int x,u8 y)
296 outb(y&0xff,dev->base_addr +x);
299 void write_nic_word(struct net_device *dev, int x,u16 y)
301 outw(y,dev->base_addr +x);
304 void write_nic_dword(struct net_device *dev, int x,u32 y)
306 outl(y,dev->base_addr +x);
309 #else /* RTL_IO_MAP */
311 u8 read_nic_byte(struct net_device *dev, int x)
313 return 0xff&readb((u8*)dev->mem_start +x);
316 u32 read_nic_dword(struct net_device *dev, int x)
318 return readl((u8*)dev->mem_start +x);
321 u16 read_nic_word(struct net_device *dev, int x)
323 return readw((u8*)dev->mem_start +x);
326 void write_nic_byte(struct net_device *dev, int x,u8 y)
328 writeb(y,(u8*)dev->mem_start +x);
332 void write_nic_dword(struct net_device *dev, int x,u32 y)
334 writel(y,(u8*)dev->mem_start +x);
338 void write_nic_word(struct net_device *dev, int x,u16 y)
340 writew(y,(u8*)dev->mem_start +x);
344 #endif /* RTL_IO_MAP */
346 u8 rtl8192e_ap_sec_type(struct ieee80211_device *ieee)
348 //struct r8192_priv* priv = ieee80211_priv(dev);
349 //struct ieee80211_device *ieee = priv->ieee80211;
351 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
352 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
353 int wpa_ie_len= ieee->wpa_ie_len;
354 struct ieee80211_crypt_data* crypt;
357 crypt = ieee->crypt[ieee->tx_keyidx];
359 encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY) ||\
360 (ieee->host_encrypt && crypt && crypt->ops && \
361 (0 == strcmp(crypt->ops->name,"WEP")));
364 if(encrypt && (wpa_ie_len == 0)) {
365 // wep encryption, no N mode setting */
367 } else if((wpa_ie_len != 0)) {
368 // parse pairwise key type */
369 if (((ieee->wpa_ie[0] == 0xdd) && (!memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) ||
370 ((ieee->wpa_ie[0] == 0x30) && (!memcmp(&ieee->wpa_ie[10],ccmp_rsn_ie, 4))))
380 rtl8192e_SetHwReg(struct net_device *dev,u8 variable,u8* val)
382 struct r8192_priv* priv = ieee80211_priv(dev);
388 write_nic_dword(dev, BSSIDR, ((u32*)(val))[0]);
389 write_nic_word(dev, BSSIDR+2, ((u16*)(val+2))[0]);
392 case HW_VAR_MEDIA_STATUS:
394 RT_OP_MODE OpMode = *((RT_OP_MODE *)(val));
395 //LED_CTL_MODE LedAction = LED_CTL_NO_LINK;
396 u8 btMsr = read_nic_byte(dev, MSR);
402 case RT_OP_MODE_INFRASTRUCTURE:
404 //LedAction = LED_CTL_LINK;
407 case RT_OP_MODE_IBSS:
409 // led link set seperate
414 //LedAction = LED_CTL_LINK;
422 write_nic_byte(dev, MSR, btMsr);
424 //priv->ieee80211->LedControlHandler(dev, LedAction);
428 case HW_VAR_CECHK_BSSID:
432 Type = ((u8*)(val))[0];
433 //priv->ieee80211->GetHwRegHandler(dev, HW_VAR_RCR, (u8*)(&RegRCR));
434 RegRCR = read_nic_dword(dev,RCR);
435 priv->ReceiveConfig = RegRCR;
438 RegRCR |= (RCR_CBSSID);
439 else if (Type == false)
440 RegRCR &= (~RCR_CBSSID);
442 //priv->ieee80211->SetHwRegHandler( dev, HW_VAR_RCR, (u8*)(&RegRCR) );
443 write_nic_dword(dev, RCR,RegRCR);
444 priv->ReceiveConfig = RegRCR;
449 case HW_VAR_SLOT_TIME:
451 //PSTA_QOS pStaQos = Adapter->MgntInfo.pStaQos;
454 priv->slot_time = val[0];
455 write_nic_byte(dev, SLOT_TIME, val[0]);
460 case HW_VAR_ACK_PREAMBLE:
463 priv->short_preamble = (bool)(*(u8*)val );
464 regTmp = priv->basic_rate;
465 if (priv->short_preamble)
466 regTmp |= BRSR_AckShortPmb;
467 write_nic_dword(dev, RRSR, regTmp);
472 write_nic_dword(dev, CPU_GEN, ((u32*)(val))[0]);
482 ///////////////////////////////////////////////////////////
484 //u8 read_phy_cck(struct net_device *dev, u8 adr);
485 //u8 read_phy_ofdm(struct net_device *dev, u8 adr);
486 /* this might still called in what was the PHY rtl8185/rtl8192 common code
487 * plans are to possibilty turn it again in one common code...
489 inline void force_pci_posting(struct net_device *dev)
495 irqreturn_t rtl8192_interrupt(int irq, void *netdev);
496 //static struct net_device_stats *rtl8192_stats(struct net_device *dev);
497 void rtl8192_commit(struct net_device *dev);
498 //void rtl8192_restart(struct net_device *dev);
499 void rtl8192_restart(struct work_struct *work);
500 //void rtl8192_rq_tx_ack(struct work_struct *work);
502 void watch_dog_timer_callback(unsigned long data);
503 /****************************************************************************
504 -----------------------------PROCFS STUFF-------------------------
505 *****************************************************************************/
507 static struct proc_dir_entry *rtl8192_proc = NULL;
511 static int proc_get_stats_ap(char *page, char **start,
512 off_t offset, int count,
513 int *eof, void *data)
515 struct net_device *dev = data;
516 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
517 struct ieee80211_device *ieee = priv->ieee80211;
518 struct ieee80211_network *target;
522 list_for_each_entry(target, &ieee->network_list, list) {
524 len += snprintf(page + len, count - len,
525 "%s ", target->ssid);
527 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
528 len += snprintf(page + len, count - len,
532 len += snprintf(page + len, count - len,
542 static int proc_get_registers(char *page, char **start,
543 off_t offset, int count,
544 int *eof, void *data)
546 struct net_device *dev = data;
547 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
554 /* This dump the current register page */
555 len += snprintf(page + len, count - len,
556 "\n####################page 0##################\n ");
560 //printk( "\nD: %2x> ", n);
561 len += snprintf(page + len, count - len,
564 for(i=0;i<16 && n<=max;i++,n++)
565 len += snprintf(page + len, count - len,
566 "%2x ",read_nic_byte(dev,n));
568 // printk("%2x ",read_nic_byte(dev,n));
570 len += snprintf(page + len, count - len,"\n");
571 len += snprintf(page + len, count - len,
572 "\n####################page 1##################\n ");
575 //printk( "\nD: %2x> ", n);
576 len += snprintf(page + len, count - len,
579 for(i=0;i<16 && n<=max;i++,n++)
580 len += snprintf(page + len, count - len,
581 "%2x ",read_nic_byte(dev,0x100|n));
583 // printk("%2x ",read_nic_byte(dev,n));
586 len += snprintf(page + len, count - len,
587 "\n####################page 3##################\n ");
590 //printk( "\nD: %2x> ", n);
591 len += snprintf(page + len, count - len,
594 for(i=0;i<16 && n<=max;i++,n++)
595 len += snprintf(page + len, count - len,
596 "%2x ",read_nic_byte(dev,0x300|n));
598 // printk("%2x ",read_nic_byte(dev,n));
609 static int proc_get_stats_tx(char *page, char **start,
610 off_t offset, int count,
611 int *eof, void *data)
613 struct net_device *dev = data;
614 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
618 len += snprintf(page + len, count - len,
619 "TX VI priority ok int: %lu\n"
620 // "TX VI priority error int: %lu\n"
621 "TX VO priority ok int: %lu\n"
622 // "TX VO priority error int: %lu\n"
623 "TX BE priority ok int: %lu\n"
624 // "TX BE priority error int: %lu\n"
625 "TX BK priority ok int: %lu\n"
626 // "TX BK priority error int: %lu\n"
627 "TX MANAGE priority ok int: %lu\n"
628 // "TX MANAGE priority error int: %lu\n"
629 "TX BEACON priority ok int: %lu\n"
630 "TX BEACON priority error int: %lu\n"
631 "TX CMDPKT priority ok int: %lu\n"
632 // "TX high priority ok int: %lu\n"
633 // "TX high priority failed error int: %lu\n"
634 // "TX queue resume: %lu\n"
635 "TX queue stopped?: %d\n"
636 "TX fifo overflow: %lu\n"
637 // "TX beacon: %lu\n"
638 // "TX VI queue: %d\n"
639 // "TX VO queue: %d\n"
640 // "TX BE queue: %d\n"
641 // "TX BK queue: %d\n"
642 // "TX HW queue: %d\n"
643 // "TX VI dropped: %lu\n"
644 // "TX VO dropped: %lu\n"
645 // "TX BE dropped: %lu\n"
646 // "TX BK dropped: %lu\n"
647 "TX total data packets %lu\n"
648 "TX total data bytes :%lu\n",
649 // "TX beacon aborted: %lu\n",
650 priv->stats.txviokint,
651 // priv->stats.txvierr,
652 priv->stats.txvookint,
653 // priv->stats.txvoerr,
654 priv->stats.txbeokint,
655 // priv->stats.txbeerr,
656 priv->stats.txbkokint,
657 // priv->stats.txbkerr,
658 priv->stats.txmanageokint,
659 // priv->stats.txmanageerr,
660 priv->stats.txbeaconokint,
661 priv->stats.txbeaconerr,
662 priv->stats.txcmdpktokint,
663 // priv->stats.txhpokint,
664 // priv->stats.txhperr,
665 // priv->stats.txresumed,
666 netif_queue_stopped(dev),
667 priv->stats.txoverflow,
668 // priv->stats.txbeacon,
669 // atomic_read(&(priv->tx_pending[VI_QUEUE])),
670 // atomic_read(&(priv->tx_pending[VO_QUEUE])),
671 // atomic_read(&(priv->tx_pending[BE_QUEUE])),
672 // atomic_read(&(priv->tx_pending[BK_QUEUE])),
673 // read_nic_byte(dev, TXFIFOCOUNT),
674 // priv->stats.txvidrop,
675 // priv->stats.txvodrop,
676 priv->ieee80211->stats.tx_packets,
677 priv->ieee80211->stats.tx_bytes
680 // priv->stats.txbedrop,
681 // priv->stats.txbkdrop
682 // priv->stats.txdatapkt
683 // priv->stats.txbeaconerr
692 static int proc_get_stats_rx(char *page, char **start,
693 off_t offset, int count,
694 int *eof, void *data)
696 struct net_device *dev = data;
697 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
701 len += snprintf(page + len, count - len,
704 "RX rx overflow error: %lu\n"
705 "RX invalid urb error: %lu\n",
708 priv->stats.rxoverflow,
709 priv->stats.rxurberr);
715 static void rtl8192_proc_module_init(void)
717 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
718 rtl8192_proc=create_proc_entry(RTL819xE_MODULE_NAME, S_IFDIR, init_net.proc_net);
722 static void rtl8192_proc_module_remove(void)
724 remove_proc_entry(RTL819xE_MODULE_NAME, init_net.proc_net);
728 static void rtl8192_proc_remove_one(struct net_device *dev)
730 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
732 printk("dev name=======> %s\n",dev->name);
735 // remove_proc_entry("stats-hw", priv->dir_dev);
736 remove_proc_entry("stats-tx", priv->dir_dev);
737 remove_proc_entry("stats-rx", priv->dir_dev);
738 // remove_proc_entry("stats-ieee", priv->dir_dev);
739 remove_proc_entry("stats-ap", priv->dir_dev);
740 remove_proc_entry("registers", priv->dir_dev);
741 // remove_proc_entry("cck-registers",priv->dir_dev);
742 // remove_proc_entry("ofdm-registers",priv->dir_dev);
743 //remove_proc_entry(dev->name, rtl8192_proc);
744 remove_proc_entry("wlan0", rtl8192_proc);
745 priv->dir_dev = NULL;
750 static void rtl8192_proc_init_one(struct net_device *dev)
752 struct proc_dir_entry *e;
753 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
754 priv->dir_dev = create_proc_entry(dev->name,
755 S_IFDIR | S_IRUGO | S_IXUGO,
757 if (!priv->dir_dev) {
758 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
762 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
763 priv->dir_dev, proc_get_stats_rx, dev);
766 RT_TRACE(COMP_ERR,"Unable to initialize "
767 "/proc/net/rtl8192/%s/stats-rx\n",
772 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
773 priv->dir_dev, proc_get_stats_tx, dev);
776 RT_TRACE(COMP_ERR, "Unable to initialize "
777 "/proc/net/rtl8192/%s/stats-tx\n",
781 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
782 priv->dir_dev, proc_get_stats_ap, dev);
785 RT_TRACE(COMP_ERR, "Unable to initialize "
786 "/proc/net/rtl8192/%s/stats-ap\n",
790 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
791 priv->dir_dev, proc_get_registers, dev);
793 RT_TRACE(COMP_ERR, "Unable to initialize "
794 "/proc/net/rtl8192/%s/registers\n",
798 /****************************************************************************
799 -----------------------------MISC STUFF-------------------------
800 *****************************************************************************/
802 short check_nic_enough_desc(struct net_device *dev, int prio)
804 struct r8192_priv *priv = ieee80211_priv(dev);
805 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
807 /* for now we reserve two free descriptor as a safety boundary
808 * between the tail and the head
810 if (ring->entries - skb_queue_len(&ring->queue) >= 2) {
817 static void tx_timeout(struct net_device *dev)
819 struct r8192_priv *priv = ieee80211_priv(dev);
820 //rtl8192_commit(dev);
822 schedule_work(&priv->reset_wq);
827 /****************************************************************************
828 ------------------------------HW STUFF---------------------------
829 *****************************************************************************/
832 static void rtl8192_irq_enable(struct net_device *dev)
834 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
835 priv->irq_enabled = 1;
836 write_nic_dword(dev,INTA_MASK, priv->irq_mask);
840 void rtl8192_irq_disable(struct net_device *dev)
842 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
844 write_nic_dword(dev,INTA_MASK,0);
845 force_pci_posting(dev);
846 priv->irq_enabled = 0;
851 static void rtl8192_set_mode(struct net_device *dev,int mode)
854 ecmd=read_nic_byte(dev, EPROM_CMD);
855 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
856 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
857 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
858 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
859 write_nic_byte(dev, EPROM_CMD, ecmd);
863 void rtl8192_update_msr(struct net_device *dev)
865 struct r8192_priv *priv = ieee80211_priv(dev);
868 msr = read_nic_byte(dev, MSR);
869 msr &= ~ MSR_LINK_MASK;
871 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
872 * msr must be updated if the state is ASSOCIATING.
873 * this is intentional and make sense for ad-hoc and
874 * master (see the create BSS/IBSS func)
876 if (priv->ieee80211->state == IEEE80211_LINKED){
878 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
879 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
880 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
881 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
882 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
883 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
886 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
888 write_nic_byte(dev, MSR, msr);
891 void rtl8192_set_chan(struct net_device *dev,short ch)
893 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
894 RT_TRACE(COMP_RF, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
897 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC ||
898 priv->ieee80211->iw_mode == IW_MODE_MASTER){
900 priv->ieee80211->link_state = WLAN_LINK_ASSOCIATED;
901 priv->ieee80211->master_chan = ch;
902 rtl8192_update_beacon_ch(dev);
906 /* this hack should avoid frame TX during channel setting*/
909 // tx = read_nic_dword(dev,TX_CONF);
910 // tx &= ~TX_LOOPBACK_MASK;
914 // write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
916 //need to implement rf set channel here WB
918 if (priv->rf_set_chan)
919 priv->rf_set_chan(dev,priv->chan);
921 // write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
925 void rtl8192_rx_enable(struct net_device *dev)
927 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
928 write_nic_dword(dev, RDQDA,priv->rx_ring_dma);
931 /* the TX_DESC_BASE setting is according to the following queue index
940 * BEACON_QUEUE ===> 8
942 static u32 TX_DESC_BASE[] = {BKQDA, BEQDA, VIQDA, VOQDA, HCCAQDA, CQDA, MQDA, HQDA, BQDA};
943 void rtl8192_tx_enable(struct net_device *dev)
945 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
947 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
948 write_nic_dword(dev, TX_DESC_BASE[i], priv->tx_ring[i].dma);
950 ieee80211_reset_queue(priv->ieee80211);
954 static void rtl8192_free_rx_ring(struct net_device *dev)
956 struct r8192_priv *priv = ieee80211_priv(dev);
959 for (i = 0; i < priv->rxringcount; i++) {
960 struct sk_buff *skb = priv->rx_buf[i];
964 pci_unmap_single(priv->pdev,
965 *((dma_addr_t *)skb->cb),
966 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
970 pci_free_consistent(priv->pdev, sizeof(*priv->rx_ring) * priv->rxringcount,
971 priv->rx_ring, priv->rx_ring_dma);
972 priv->rx_ring = NULL;
975 static void rtl8192_free_tx_ring(struct net_device *dev, unsigned int prio)
977 struct r8192_priv *priv = ieee80211_priv(dev);
978 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
980 while (skb_queue_len(&ring->queue)) {
981 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
982 struct sk_buff *skb = __skb_dequeue(&ring->queue);
984 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
985 skb->len, PCI_DMA_TODEVICE);
987 ring->idx = (ring->idx + 1) % ring->entries;
990 pci_free_consistent(priv->pdev, sizeof(*ring->desc)*ring->entries,
991 ring->desc, ring->dma);
996 static void rtl8192_beacon_disable(struct net_device *dev)
998 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1001 reg = read_nic_dword(priv->ieee80211->dev,INTA_MASK);
1003 /* disable Beacon realted interrupt signal */
1004 reg &= ~(IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
1005 write_nic_dword(priv->ieee80211->dev, INTA_MASK, reg);
1009 void PHY_SetRtl8192eRfOff(struct net_device* dev )
1011 //struct r8192_priv *priv = ieee80211_priv(dev);
1013 //disable RF-Chip A/B
1014 rtl8192_setBBreg(dev, rFPGA0_XA_RFInterfaceOE, BIT4, 0x0);
1015 //analog to digital off, for power save
1016 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0x300, 0x0);
1017 //digital to analog off, for power save
1018 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x18, 0x0);
1020 rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, 0xf, 0x0);
1022 rtl8192_setBBreg(dev, rOFDM1_TRxPathEnable, 0xf, 0x0);
1023 //analog to digital part2 off, for power save
1024 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x60, 0x0);
1025 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x4, 0x0);
1026 // Analog parameter!!Change bias and Lbus control.
1027 write_nic_byte(dev, ANAPAR_FOR_8192PciE, 0x07);
1031 void rtl8192_halt_adapter(struct net_device *dev, bool reset)
1034 struct r8192_priv *priv = ieee80211_priv(dev);
1040 OpMode = RT_OP_MODE_NO_LINK;
1041 priv->ieee80211->SetHwRegHandler(dev, HW_VAR_MEDIA_STATUS, &OpMode);
1044 if(!priv->ieee80211->bSupportRemoteWakeUp)
1046 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
1047 //priv->ieee80211->SetHwRegHandler(dev, HW_VAR_COMMAND, &u1bTmp ); // Using HW_VAR_COMMAND instead of writing CMDR directly. Rewrited by Annie, 2006-04-07.
1048 write_nic_byte(dev, CMDR, u1bTmp);
1051 cmd=read_nic_byte(dev,CMDR);
1052 write_nic_byte(dev, CMDR, cmd &~ (CR_TE|CR_RE));
1059 //PlatformStallExecution(150000);
1063 priv->bHwRfOffAction = 2;
1067 // Call MgntActSet_RF_State instead to prevent RF config race condition.
1068 // By Bruce, 2008-01-17.
1070 if(!priv->ieee80211->bSupportRemoteWakeUp)
1072 //MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_INIT);
1073 //MgntActSet_RF_State(Adapter, eRfOff, Adapter->MgntInfo.RfOffReason);
1074 //if(Adapter->HardwareType == HARDWARE_TYPE_RTL8190P)
1076 PHY_SetRtl8192eRfOff(dev);
1078 // 2006.11.30. System reset bit
1079 //priv->ieee80211->GetHwRegHandler(dev, HW_VAR_CPU_RST, (u32*)(&ulRegRead) );
1080 ulRegRead = read_nic_dword(dev,CPU_GEN);
1081 ulRegRead|=CPU_GEN_SYSTEM_RESET;
1082 //priv->ieee80211->SetHwRegHandler(dev, HW_VAR_CPU_RST, &ulRegRead);
1083 write_nic_dword(dev,CPU_GEN, ulRegRead);
1087 //2008.06.03 for WOL
1088 write_nic_dword(dev, WFCRC0, 0xffffffff);
1089 write_nic_dword(dev, WFCRC1, 0xffffffff);
1090 write_nic_dword(dev, WFCRC2, 0xffffffff);
1092 //Write PMR register
1093 write_nic_byte(dev, PMR, 0x5);
1094 //Disable tx, enanble rx
1095 write_nic_byte(dev, MacBlkCtrl, 0xa);
1099 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
1100 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
1102 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
1103 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
1106 skb_queue_purge(&priv->skb_queue);
1111 static void rtl8192_reset(struct net_device *dev)
1113 rtl8192_irq_disable(dev);
1114 printk("This is RTL819xP Reset procedure\n");
1118 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
1119 inline u16 rtl8192_rate2rate(short rate)
1121 if (rate >11) return 0;
1122 return rtl_rate[rate];
1128 static void rtl8192_data_hard_stop(struct net_device *dev)
1132 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1133 priv->dma_poll_mask |= (1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
1134 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
1135 write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
1136 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
1141 static void rtl8192_data_hard_resume(struct net_device *dev)
1145 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1146 priv->dma_poll_mask &= ~(1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
1147 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
1148 write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
1149 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
1153 /* this function TX data frames when the ieee80211 stack requires this.
1154 * It checks also if we need to stop the ieee tx queue, eventually do it
1156 static void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
1158 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1160 //unsigned long flags;
1161 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1162 u8 queue_index = tcb_desc->queue_index;
1163 /* shall not be referred by command packet */
1164 assert(queue_index != TXCMD_QUEUE);
1166 if((priv->bHwRadioOff == true)||(!priv->up))
1172 //spin_lock_irqsave(&priv->tx_lock,flags);
1174 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1176 tcb_desc->RATRIndex = 7;
1177 tcb_desc->bTxDisableRateFallBack = 1;
1178 tcb_desc->bTxUseDriverAssingedRate = 1;
1179 tcb_desc->bTxEnableFwCalcDur = 1;
1181 skb_push(skb, priv->ieee80211->tx_headroom);
1182 ret = rtl8192_tx(dev, skb);
1188 if(queue_index!=MGNT_QUEUE) {
1189 priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1190 priv->ieee80211->stats.tx_packets++;
1193 //spin_unlock_irqrestore(&priv->tx_lock,flags);
1199 /* This is a rough attempt to TX a frame
1200 * This is called by the ieee 80211 stack to TX management frames.
1201 * If the ring is full packet are dropped (for data frame the queue
1202 * is stopped before this can happen).
1204 static int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1206 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1210 //unsigned long flags;
1211 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1212 u8 queue_index = tcb_desc->queue_index;
1214 if(queue_index != TXCMD_QUEUE){
1215 if((priv->bHwRadioOff == true)||(!priv->up))
1222 //spin_lock_irqsave(&priv->tx_lock,flags);
1224 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1225 if(queue_index == TXCMD_QUEUE) {
1226 // skb_push(skb, USB_HWDESC_HEADER_LEN);
1227 rtl819xE_tx_cmd(dev, skb);
1229 //spin_unlock_irqrestore(&priv->tx_lock,flags);
1232 // RT_TRACE(COMP_SEND, "To send management packet\n");
1233 tcb_desc->RATRIndex = 7;
1234 tcb_desc->bTxDisableRateFallBack = 1;
1235 tcb_desc->bTxUseDriverAssingedRate = 1;
1236 tcb_desc->bTxEnableFwCalcDur = 1;
1237 skb_push(skb, priv->ieee80211->tx_headroom);
1238 ret = rtl8192_tx(dev, skb);
1244 // priv->ieee80211->stats.tx_bytes+=skb->len;
1245 // priv->ieee80211->stats.tx_packets++;
1247 //spin_unlock_irqrestore(&priv->tx_lock,flags);
1254 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1256 static void rtl8192_tx_isr(struct net_device *dev, int prio)
1258 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1260 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
1262 while (skb_queue_len(&ring->queue)) {
1263 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1264 struct sk_buff *skb;
1266 /* beacon packet will only use the first descriptor defaultly,
1267 * and the OWN may not be cleared by the hardware
1269 if(prio != BEACON_QUEUE) {
1272 ring->idx = (ring->idx + 1) % ring->entries;
1275 skb = __skb_dequeue(&ring->queue);
1276 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1277 skb->len, PCI_DMA_TODEVICE);
1281 if (prio == MGNT_QUEUE){
1282 if (priv->ieee80211->ack_tx_to_ieee){
1283 if (rtl8192_is_tx_queue_empty(dev)){
1284 priv->ieee80211->ack_tx_to_ieee = 0;
1285 ieee80211_ps_tx_ack(priv->ieee80211, 1);
1290 if(prio != BEACON_QUEUE) {
1291 /* try to deal with the pending packets */
1292 tasklet_schedule(&priv->irq_tx_tasklet);
1297 static void rtl8192_stop_beacon(struct net_device *dev)
1299 //rtl8192_beacon_disable(dev);
1302 static void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1304 struct r8192_priv *priv = ieee80211_priv(dev);
1305 struct ieee80211_network *net;
1306 u8 i=0, basic_rate = 0;
1307 net = & priv->ieee80211->current_network;
1309 for (i=0; i<net->rates_len; i++)
1311 basic_rate = net->rates[i]&0x7f;
1314 case MGN_1M: *rate_config |= RRSR_1M; break;
1315 case MGN_2M: *rate_config |= RRSR_2M; break;
1316 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1317 case MGN_11M: *rate_config |= RRSR_11M; break;
1318 case MGN_6M: *rate_config |= RRSR_6M; break;
1319 case MGN_9M: *rate_config |= RRSR_9M; break;
1320 case MGN_12M: *rate_config |= RRSR_12M; break;
1321 case MGN_18M: *rate_config |= RRSR_18M; break;
1322 case MGN_24M: *rate_config |= RRSR_24M; break;
1323 case MGN_36M: *rate_config |= RRSR_36M; break;
1324 case MGN_48M: *rate_config |= RRSR_48M; break;
1325 case MGN_54M: *rate_config |= RRSR_54M; break;
1328 for (i=0; i<net->rates_ex_len; i++)
1330 basic_rate = net->rates_ex[i]&0x7f;
1333 case MGN_1M: *rate_config |= RRSR_1M; break;
1334 case MGN_2M: *rate_config |= RRSR_2M; break;
1335 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1336 case MGN_11M: *rate_config |= RRSR_11M; break;
1337 case MGN_6M: *rate_config |= RRSR_6M; break;
1338 case MGN_9M: *rate_config |= RRSR_9M; break;
1339 case MGN_12M: *rate_config |= RRSR_12M; break;
1340 case MGN_18M: *rate_config |= RRSR_18M; break;
1341 case MGN_24M: *rate_config |= RRSR_24M; break;
1342 case MGN_36M: *rate_config |= RRSR_36M; break;
1343 case MGN_48M: *rate_config |= RRSR_48M; break;
1344 case MGN_54M: *rate_config |= RRSR_54M; break;
1350 #define SHORT_SLOT_TIME 9
1351 #define NON_SHORT_SLOT_TIME 20
1353 static void rtl8192_update_cap(struct net_device* dev, u16 cap)
1356 struct r8192_priv *priv = ieee80211_priv(dev);
1357 struct ieee80211_network *net = &priv->ieee80211->current_network;
1358 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1359 tmp = priv->basic_rate;
1360 if (priv->short_preamble)
1361 tmp |= BRSR_AckShortPmb;
1362 write_nic_dword(dev, RRSR, tmp);
1364 if (net->mode & (IEEE_G|IEEE_N_24G))
1367 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1369 slot_time = SHORT_SLOT_TIME;
1371 else //long slot time
1372 slot_time = NON_SHORT_SLOT_TIME;
1373 priv->slot_time = slot_time;
1374 write_nic_byte(dev, SLOT_TIME, slot_time);
1379 static void rtl8192_net_update(struct net_device *dev)
1382 struct r8192_priv *priv = ieee80211_priv(dev);
1383 struct ieee80211_network *net;
1384 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1385 u16 rate_config = 0;
1386 net = &priv->ieee80211->current_network;
1387 //update Basic rate: RR, BRSR
1388 rtl8192_config_rate(dev, &rate_config);
1389 // 2007.01.16, by Emily
1390 // Select RRSR (in Legacy-OFDM and CCK)
1391 // For 8190, we select only 24M, 12M, 6M, 11M, 5.5M, 2M, and 1M from the Basic rate.
1392 // We do not use other rates.
1393 priv->basic_rate = rate_config &= 0x15f;
1395 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1396 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1399 rtl8192_update_msr(dev);
1403 // rtl8192_update_cap(dev, net->capability);
1404 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1406 write_nic_word(dev, ATIMWND, 2);
1407 write_nic_word(dev, BCN_DMATIME, 256);
1408 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1409 // write_nic_word(dev, BcnIntTime, 100);
1410 //BIT15 of BCN_DRV_EARLY_INT will indicate whether software beacon or hw beacon is applied.
1411 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
1412 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1414 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1415 // TODO: BcnIFS may required to be changed on ASIC
1416 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1418 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1424 void rtl819xE_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1426 struct r8192_priv *priv = ieee80211_priv(dev);
1427 struct rtl8192_tx_ring *ring;
1428 tx_desc_819x_pci *entry;
1432 unsigned long flags;
1434 ring = &priv->tx_ring[TXCMD_QUEUE];
1435 mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1437 spin_lock_irqsave(&priv->irq_th_lock,flags);
1438 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1439 entry = &ring->desc[idx];
1441 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1443 entry->LINIP = tcb_desc->bLastIniPkt;
1444 entry->FirstSeg = 1;//first segment
1445 entry->LastSeg = 1; //last segment
1446 if(tcb_desc->bCmdOrInit == DESC_PACKET_TYPE_INIT) {
1447 entry->CmdInit = DESC_PACKET_TYPE_INIT;
1449 entry->CmdInit = DESC_PACKET_TYPE_NORMAL;
1450 entry->Offset = sizeof(TX_FWINFO_8190PCI) + 8;
1451 entry->PktSize = (u16)(tcb_desc->pkt_size + entry->Offset);
1452 entry->QueueSelect = QSLT_CMD;
1453 entry->TxFWInfoSize = 0x08;
1454 entry->RATid = (u8)DESC_PACKET_TYPE_INIT;
1456 entry->TxBufferSize = skb->len;
1457 entry->TxBuffAddr = cpu_to_le32(mapping);
1460 #ifdef JOHN_DUMP_TXDESC
1462 tx_desc_819x_pci *entry1 = &ring->desc[0];
1463 unsigned int *ptr= (unsigned int *)entry1;
1464 printk("<Tx descriptor>:\n");
1465 for (i = 0; i < 8; i++)
1466 printk("%8x ", ptr[i]);
1470 __skb_queue_tail(&ring->queue, skb);
1471 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1473 write_nic_byte(dev, TPPoll, TPPoll_CQ);
1479 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1480 * in TxFwInfo data structure
1481 * 2006.10.30 by Emily
1483 * \param QUEUEID Software Queue
1485 static u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1487 u8 QueueSelect = 0x0; //defualt set to
1491 QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
1495 QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
1499 QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
1503 QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
1506 QueueSelect = QSLT_MGNT;
1510 QueueSelect = QSLT_BEACON;
1513 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
1514 // TODO: Remove Assertions
1515 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
1517 QueueSelect = QSLT_CMD;
1521 //QueueSelect = QSLT_HIGH;
1525 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
1531 static u8 MRateToHwRate8190Pci(u8 rate)
1533 u8 ret = DESC90_RATE1M;
1536 case MGN_1M: ret = DESC90_RATE1M; break;
1537 case MGN_2M: ret = DESC90_RATE2M; break;
1538 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
1539 case MGN_11M: ret = DESC90_RATE11M; break;
1540 case MGN_6M: ret = DESC90_RATE6M; break;
1541 case MGN_9M: ret = DESC90_RATE9M; break;
1542 case MGN_12M: ret = DESC90_RATE12M; break;
1543 case MGN_18M: ret = DESC90_RATE18M; break;
1544 case MGN_24M: ret = DESC90_RATE24M; break;
1545 case MGN_36M: ret = DESC90_RATE36M; break;
1546 case MGN_48M: ret = DESC90_RATE48M; break;
1547 case MGN_54M: ret = DESC90_RATE54M; break;
1549 // HT rate since here
1550 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
1551 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
1552 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
1553 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
1554 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
1555 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
1556 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
1557 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
1558 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
1559 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
1560 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1561 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1562 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1563 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1564 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1565 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1566 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1574 static u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1578 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1580 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1587 * The tx procedure is just as following,
1588 * skb->cb will contain all the following information,
1589 * priority, morefrag, rate, &dev.
1591 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
1593 struct r8192_priv *priv = ieee80211_priv(dev);
1594 struct rtl8192_tx_ring *ring;
1595 unsigned long flags;
1596 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1597 tx_desc_819x_pci *pdesc = NULL;
1598 TX_FWINFO_8190PCI *pTxFwInfo = NULL;
1600 bool multi_addr=false,broad_addr=false,uni_addr=false;
1601 u8* pda_addr = NULL;
1604 if(priv->bdisable_nic){
1605 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);
1610 priv->ieee80211->bAwakePktSent = true;
1613 mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1614 /* collect the tx packets statitcs */
1615 pda_addr = ((u8*)skb->data) + sizeof(TX_FWINFO_8190PCI);
1616 if(is_multicast_ether_addr(pda_addr))
1618 else if(is_broadcast_ether_addr(pda_addr))
1624 priv->stats.txbytesunicast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1626 priv->stats.txbytesmulticast +=(u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1628 priv->stats.txbytesbroadcast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1630 /* fill tx firmware */
1631 pTxFwInfo = (PTX_FWINFO_8190PCI)skb->data;
1632 memset(pTxFwInfo,0,sizeof(TX_FWINFO_8190PCI));
1633 pTxFwInfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
1634 pTxFwInfo->TxRate = MRateToHwRate8190Pci((u8)tcb_desc->data_rate);
1635 pTxFwInfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1636 pTxFwInfo->Short = QueryIsShort(pTxFwInfo->TxHT, pTxFwInfo->TxRate, tcb_desc);
1638 /* Aggregation related */
1639 if(tcb_desc->bAMPDUEnable) {
1640 pTxFwInfo->AllowAggregation = 1;
1641 pTxFwInfo->RxMF = tcb_desc->ampdu_factor;
1642 pTxFwInfo->RxAMD = tcb_desc->ampdu_density;
1644 pTxFwInfo->AllowAggregation = 0;
1645 pTxFwInfo->RxMF = 0;
1646 pTxFwInfo->RxAMD = 0;
1650 // Protection mode related
1652 pTxFwInfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
1653 pTxFwInfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
1654 pTxFwInfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
1655 pTxFwInfo->RtsHT= (tcb_desc->rts_rate&0x80)?1:0;
1656 pTxFwInfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1657 pTxFwInfo->RtsBandwidth = 0;
1658 pTxFwInfo->RtsSubcarrier = tcb_desc->RTSSC;
1659 pTxFwInfo->RtsShort = (pTxFwInfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):(tcb_desc->bRTSUseShortGI?1:0);
1661 // Set Bandwidth and sub-channel settings.
1663 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
1665 if(tcb_desc->bPacketBW)
1667 pTxFwInfo->TxBandwidth = 1;
1669 pTxFwInfo->TxSubCarrier = 3;
1671 pTxFwInfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode, cosa 04012008
1676 pTxFwInfo->TxBandwidth = 0;
1677 pTxFwInfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1680 pTxFwInfo->TxBandwidth = 0;
1681 pTxFwInfo->TxSubCarrier = 0;
1686 /* 2007/07/25 MH Copy current TX FW info.*/
1687 memcpy((void*)(&Tmp_TxFwInfo), (void*)(pTxFwInfo), sizeof(TX_FWINFO_8190PCI));
1688 printk("&&&&&&&&&&&&&&&&&&&&&&====>print out fwinf\n");
1689 printk("===>enable fwcacl:%d\n", Tmp_TxFwInfo.EnableCPUDur);
1690 printk("===>RTS STBC:%d\n", Tmp_TxFwInfo.RtsSTBC);
1691 printk("===>RTS Subcarrier:%d\n", Tmp_TxFwInfo.RtsSubcarrier);
1692 printk("===>Allow Aggregation:%d\n", Tmp_TxFwInfo.AllowAggregation);
1693 printk("===>TX HT bit:%d\n", Tmp_TxFwInfo.TxHT);
1694 printk("===>Tx rate:%d\n", Tmp_TxFwInfo.TxRate);
1695 printk("===>Received AMPDU Density:%d\n", Tmp_TxFwInfo.RxAMD);
1696 printk("===>Received MPDU Factor:%d\n", Tmp_TxFwInfo.RxMF);
1697 printk("===>TxBandwidth:%d\n", Tmp_TxFwInfo.TxBandwidth);
1698 printk("===>TxSubCarrier:%d\n", Tmp_TxFwInfo.TxSubCarrier);
1700 printk("<=====**********************out of print\n");
1703 spin_lock_irqsave(&priv->irq_th_lock,flags);
1704 ring = &priv->tx_ring[tcb_desc->queue_index];
1705 if (tcb_desc->queue_index != BEACON_QUEUE) {
1706 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1711 pdesc = &ring->desc[idx];
1712 if((pdesc->OWN == 1) && (tcb_desc->queue_index != BEACON_QUEUE)) {
1713 RT_TRACE(COMP_ERR,"No more TX desc@%d, ring->idx = %d,idx = %d,%x", \
1714 tcb_desc->queue_index,ring->idx, idx,skb->len);
1715 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1719 /* fill tx descriptor */
1720 memset((u8*)pdesc,0,12);
1724 pdesc->Offset = sizeof(TX_FWINFO_8190PCI) + 8; //We must add 8!! Emily
1725 pdesc->PktSize = (u16)skb->len-sizeof(TX_FWINFO_8190PCI);
1729 pdesc->RATid = tcb_desc->RATRIndex;
1733 pdesc->SecType = 0x0;
1734 if (tcb_desc->bHwSec) {
1737 printk("==>================hw sec\n");
1740 switch (priv->ieee80211->pairwise_key_type) {
1741 case KEY_TYPE_WEP40:
1742 case KEY_TYPE_WEP104:
1743 pdesc->SecType = 0x1;
1747 pdesc->SecType = 0x2;
1751 pdesc->SecType = 0x3;
1755 pdesc->SecType = 0x0;
1766 pdesc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1767 pdesc->TxFWInfoSize = sizeof(TX_FWINFO_8190PCI);
1769 pdesc->DISFB = tcb_desc->bTxDisableRateFallBack;
1770 pdesc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1774 pdesc->TxBufferSize = skb->len;
1776 pdesc->TxBuffAddr = cpu_to_le32(mapping);
1777 __skb_queue_tail(&ring->queue, skb);
1779 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1780 dev->trans_start = jiffies;
1781 write_nic_word(dev,TPPoll,0x01<<tcb_desc->queue_index);
1785 static short rtl8192_alloc_rx_desc_ring(struct net_device *dev)
1787 struct r8192_priv *priv = ieee80211_priv(dev);
1788 rx_desc_819x_pci *entry = NULL;
1791 priv->rx_ring = pci_alloc_consistent(priv->pdev,
1792 sizeof(*priv->rx_ring) * priv->rxringcount, &priv->rx_ring_dma);
1794 if (!priv->rx_ring || (unsigned long)priv->rx_ring & 0xFF) {
1795 RT_TRACE(COMP_ERR,"Cannot allocate RX ring\n");
1799 memset(priv->rx_ring, 0, sizeof(*priv->rx_ring) * priv->rxringcount);
1802 for (i = 0; i < priv->rxringcount; i++) {
1803 struct sk_buff *skb = dev_alloc_skb(priv->rxbuffersize);
1804 dma_addr_t *mapping;
1805 entry = &priv->rx_ring[i];
1808 priv->rx_buf[i] = skb;
1809 mapping = (dma_addr_t *)skb->cb;
1810 *mapping = pci_map_single(priv->pdev, skb_tail_pointer(skb),
1811 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
1813 entry->BufferAddress = cpu_to_le32(*mapping);
1815 entry->Length = priv->rxbuffersize;
1823 static int rtl8192_alloc_tx_desc_ring(struct net_device *dev,
1824 unsigned int prio, unsigned int entries)
1826 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1827 tx_desc_819x_pci *ring;
1831 ring = pci_alloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma);
1832 if (!ring || (unsigned long)ring & 0xFF) {
1833 RT_TRACE(COMP_ERR, "Cannot allocate TX ring (prio = %d)\n", prio);
1837 memset(ring, 0, sizeof(*ring)*entries);
1838 priv->tx_ring[prio].desc = ring;
1839 priv->tx_ring[prio].dma = dma;
1840 priv->tx_ring[prio].idx = 0;
1841 priv->tx_ring[prio].entries = entries;
1842 skb_queue_head_init(&priv->tx_ring[prio].queue);
1844 for (i = 0; i < entries; i++)
1845 ring[i].NextDescAddress =
1846 cpu_to_le32((u32)dma + ((i + 1) % entries) * sizeof(*ring));
1852 static short rtl8192_pci_initdescring(struct net_device *dev)
1856 struct r8192_priv *priv = ieee80211_priv(dev);
1858 ret = rtl8192_alloc_rx_desc_ring(dev);
1864 /* general process for other queue */
1865 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1866 if ((ret = rtl8192_alloc_tx_desc_ring(dev, i, priv->txringcount)))
1867 goto err_free_rings;
1871 /* specific process for hardware beacon process */
1872 if ((ret = rtl8192_alloc_tx_desc_ring(dev, MAX_TX_QUEUE_COUNT - 1, 2)))
1873 goto err_free_rings;
1879 rtl8192_free_rx_ring(dev);
1880 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
1881 if (priv->tx_ring[i].desc)
1882 rtl8192_free_tx_ring(dev, i);
1886 static void rtl8192_pci_resetdescring(struct net_device *dev)
1888 struct r8192_priv *priv = ieee80211_priv(dev);
1891 /* force the rx_idx to the first one */
1893 rx_desc_819x_pci *entry = NULL;
1894 for (i = 0; i < priv->rxringcount; i++) {
1895 entry = &priv->rx_ring[i];
1901 /* after reset, release previous pending packet, and force the
1902 * tx idx to the first one */
1903 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1904 if (priv->tx_ring[i].desc) {
1905 struct rtl8192_tx_ring *ring = &priv->tx_ring[i];
1907 while (skb_queue_len(&ring->queue)) {
1908 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1909 struct sk_buff *skb = __skb_dequeue(&ring->queue);
1911 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1912 skb->len, PCI_DMA_TODEVICE);
1914 ring->idx = (ring->idx + 1) % ring->entries;
1922 extern void rtl8192_update_ratr_table(struct net_device* dev);
1923 static void rtl8192_link_change(struct net_device *dev)
1927 struct r8192_priv *priv = ieee80211_priv(dev);
1928 struct ieee80211_device* ieee = priv->ieee80211;
1929 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
1930 if (ieee->state == IEEE80211_LINKED)
1932 rtl8192_net_update(dev);
1933 rtl8192_update_ratr_table(dev);
1935 //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
1936 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
1937 EnableHWSecurityConfig8192(dev);
1942 write_nic_byte(dev, 0x173, 0);
1944 /*update timing params*/
1945 //rtl8192_set_chan(dev, priv->chan);
1947 rtl8192_update_msr(dev);
1949 // 2007/10/16 MH MAC Will update TSF according to all received beacon, so we have
1950 // // To set CBSSID bit when link with any AP or STA.
1951 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
1954 reg = read_nic_dword(dev, RCR);
1955 if (priv->ieee80211->state == IEEE80211_LINKED)
1956 priv->ReceiveConfig = reg |= RCR_CBSSID;
1958 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
1959 write_nic_dword(dev, RCR, reg);
1965 static struct ieee80211_qos_parameters def_qos_parameters = {
1966 {3,3,3,3},/* cw_min */
1967 {7,7,7,7},/* cw_max */
1968 {2,2,2,2},/* aifs */
1969 {0,0,0,0},/* flags */
1970 {0,0,0,0} /* tx_op_limit */
1973 static void rtl8192_update_beacon(struct work_struct * work)
1975 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
1976 struct net_device *dev = priv->ieee80211->dev;
1977 struct ieee80211_device* ieee = priv->ieee80211;
1978 struct ieee80211_network* net = &ieee->current_network;
1980 if (ieee->pHTInfo->bCurrentHTSupport)
1981 HTUpdateSelfAndPeerSetting(ieee, net);
1982 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
1983 rtl8192_update_cap(dev, net->capability);
1986 * background support to run QoS activate functionality
1988 static int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
1989 static void rtl8192_qos_activate(struct work_struct * work)
1991 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
1992 struct net_device *dev = priv->ieee80211->dev;
1993 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
1994 u8 mode = priv->ieee80211->current_network.mode;
1995 // u32 size = sizeof(struct ieee80211_qos_parameters);
2000 mutex_lock(&priv->mutex);
2001 if(priv->ieee80211->state != IEEE80211_LINKED)
2003 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
2004 /* It better set slot time at first */
2005 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
2006 /* update the ac parameter to related registers */
2007 for(i = 0; i < QOS_QUEUE_NUM; i++) {
2008 //Mode G/A: slotTimeTimer = 9; Mode B: 20
2009 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
2010 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
2011 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
2012 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
2013 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
2014 //printk("===>u4bAcParam:%x, ", u4bAcParam);
2015 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
2016 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
2020 mutex_unlock(&priv->mutex);
2023 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
2025 struct ieee80211_network *network)
2028 u32 size = sizeof(struct ieee80211_qos_parameters);
2030 if(priv->ieee80211->state !=IEEE80211_LINKED)
2033 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2036 if (network->flags & NETWORK_HAS_QOS_MASK) {
2037 if (active_network &&
2038 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
2039 network->qos_data.active = network->qos_data.supported;
2041 if ((network->qos_data.active == 1) && (active_network == 1) &&
2042 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
2043 (network->qos_data.old_param_count !=
2044 network->qos_data.param_count)) {
2045 network->qos_data.old_param_count =
2046 network->qos_data.param_count;
2047 queue_work(priv->priv_wq, &priv->qos_activate);
2048 RT_TRACE (COMP_QOS, "QoS parameters change call "
2052 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2053 &def_qos_parameters, size);
2055 if ((network->qos_data.active == 1) && (active_network == 1)) {
2056 queue_work(priv->priv_wq, &priv->qos_activate);
2057 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
2059 network->qos_data.active = 0;
2060 network->qos_data.supported = 0;
2066 /* handle manage frame frame beacon and probe response */
2067 static int rtl8192_handle_beacon(struct net_device * dev,
2068 struct ieee80211_beacon * beacon,
2069 struct ieee80211_network * network)
2071 struct r8192_priv *priv = ieee80211_priv(dev);
2073 rtl8192_qos_handle_probe_response(priv,1,network);
2075 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
2081 * handling the beaconing responses. if we get different QoS setting
2082 * off the network from the associated setting, adjust the QoS
2085 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
2086 struct ieee80211_network *network)
2089 unsigned long flags;
2090 u32 size = sizeof(struct ieee80211_qos_parameters);
2091 int set_qos_param = 0;
2093 if ((priv == NULL) || (network == NULL))
2096 if(priv->ieee80211->state !=IEEE80211_LINKED)
2099 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2102 spin_lock_irqsave(&priv->ieee80211->lock, flags);
2103 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
2104 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2105 &network->qos_data.parameters,\
2106 sizeof(struct ieee80211_qos_parameters));
2107 priv->ieee80211->current_network.qos_data.active = 1;
2109 if((priv->ieee80211->current_network.qos_data.param_count != \
2110 network->qos_data.param_count))
2114 /* update qos parameter for current network */
2115 priv->ieee80211->current_network.qos_data.old_param_count = \
2116 priv->ieee80211->current_network.qos_data.param_count;
2117 priv->ieee80211->current_network.qos_data.param_count = \
2118 network->qos_data.param_count;
2121 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2122 &def_qos_parameters, size);
2123 priv->ieee80211->current_network.qos_data.active = 0;
2124 priv->ieee80211->current_network.qos_data.supported = 0;
2128 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
2130 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
2131 if (set_qos_param == 1)
2132 queue_work(priv->priv_wq, &priv->qos_activate);
2138 static int rtl8192_handle_assoc_response(struct net_device *dev,
2139 struct ieee80211_assoc_response_frame *resp,
2140 struct ieee80211_network *network)
2142 struct r8192_priv *priv = ieee80211_priv(dev);
2143 rtl8192_qos_association_resp(priv, network);
2148 //updateRATRTabel for MCS only. Basic rate is not implement.
2149 void rtl8192_update_ratr_table(struct net_device* dev)
2150 // POCTET_STRING posLegacyRate,
2152 // PRT_WLAN_STA pEntry)
2154 struct r8192_priv* priv = ieee80211_priv(dev);
2155 struct ieee80211_device* ieee = priv->ieee80211;
2156 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2157 //struct ieee80211_network *net = &ieee->current_network;
2161 rtl8192_config_rate(dev, (u16*)(&ratr_value));
2162 ratr_value |= (*(u16*)(pMcsRate)) << 12;
2163 // switch (net->mode)
2167 ratr_value &= 0x00000FF0;
2170 ratr_value &= 0x0000000F;
2173 ratr_value &= 0x00000FF7;
2177 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
2178 ratr_value &= 0x0007F007;
2180 if (priv->rf_type == RF_1T2R)
2181 ratr_value &= 0x000FF007;
2183 ratr_value &= 0x0F81F007;
2189 ratr_value &= 0x0FFFFFFF;
2190 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
2191 ratr_value |= 0x80000000;
2192 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
2193 ratr_value |= 0x80000000;
2195 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2196 write_nic_byte(dev, UFWP, 1);
2200 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
2201 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2204 static bool GetNmodeSupportBySecCfg8190Pci(struct net_device*dev)
2208 struct r8192_priv *priv = ieee80211_priv(dev);
2209 struct ieee80211_device *ieee = priv->ieee80211;
2210 if (ieee->rtllib_ap_sec_type &&
2211 (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP))) {
2217 struct r8192_priv* priv = ieee80211_priv(dev);
2218 struct ieee80211_device* ieee = priv->ieee80211;
2219 int wpa_ie_len= ieee->wpa_ie_len;
2220 struct ieee80211_crypt_data* crypt;
2223 crypt = ieee->crypt[ieee->tx_keyidx];
2224 encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2227 if(encrypt && (wpa_ie_len == 0)) {
2228 /* wep encryption, no N mode setting */
2230 // } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
2231 } else if((wpa_ie_len != 0)) {
2232 /* parse pairwise key type */
2233 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
2234 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))))
2239 //RT_TRACE(COMP_ERR,"In %s The GroupEncAlgorithm is [4]\n",__FUNCTION__ );
2247 static void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2249 struct ieee80211_device* ieee = priv->ieee80211;
2250 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
2251 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2253 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2254 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
2255 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
2258 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2262 static u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2264 struct r8192_priv *priv = ieee80211_priv(dev);
2266 switch(priv->rf_chip)
2271 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2274 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2277 ret = WIRELESS_MODE_B;
2283 static void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2285 struct r8192_priv *priv = ieee80211_priv(dev);
2286 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2289 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2291 if(bSupportMode & WIRELESS_MODE_N_24G)
2293 wireless_mode = WIRELESS_MODE_N_24G;
2295 else if(bSupportMode & WIRELESS_MODE_N_5G)
2297 wireless_mode = WIRELESS_MODE_N_5G;
2299 else if((bSupportMode & WIRELESS_MODE_A))
2301 wireless_mode = WIRELESS_MODE_A;
2303 else if((bSupportMode & WIRELESS_MODE_G))
2305 wireless_mode = WIRELESS_MODE_G;
2307 else if((bSupportMode & WIRELESS_MODE_B))
2309 wireless_mode = WIRELESS_MODE_B;
2312 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2313 wireless_mode = WIRELESS_MODE_B;
2316 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2317 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2319 priv->ieee80211->mode = wireless_mode;
2321 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2322 priv->ieee80211->pHTInfo->bEnableHT = 1;
2324 priv->ieee80211->pHTInfo->bEnableHT = 0;
2325 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2326 rtl8192_refresh_supportrate(priv);
2330 //init priv variables here
2332 static bool GetHalfNmodeSupportByAPs819xPci(struct net_device* dev)
2335 struct r8192_priv* priv = ieee80211_priv(dev);
2336 struct ieee80211_device* ieee = priv->ieee80211;
2338 if(ieee->bHalfWirelessN24GMode == true)
2346 short rtl8192_is_tx_queue_empty(struct net_device *dev)
2349 struct r8192_priv *priv = ieee80211_priv(dev);
2350 for (i=0; i<=MGNT_QUEUE; i++)
2352 if ((i== TXCMD_QUEUE) || (i == HCCA_QUEUE) )
2354 if (skb_queue_len(&(&priv->tx_ring[i])->queue) > 0){
2355 printk("===>tx queue is not empty:%d, %d\n", i, skb_queue_len(&(&priv->tx_ring[i])->queue));
2361 static void rtl8192_hw_sleep_down(struct net_device *dev)
2363 struct r8192_priv *priv = ieee80211_priv(dev);
2364 unsigned long flags = 0;
2366 spin_lock_irqsave(&priv->rf_ps_lock,flags);
2367 if (priv->RFChangeInProgress) {
2368 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2369 RT_TRACE(COMP_RF, "rtl8192_hw_sleep_down(): RF Change in progress! \n");
2370 printk("rtl8192_hw_sleep_down(): RF Change in progress!\n");
2373 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2374 //RT_TRACE(COMP_PS, "%s()============>come to sleep down\n", __FUNCTION__);
2376 MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
2378 static void rtl8192_hw_sleep_wq (struct work_struct *work)
2380 // struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
2381 // struct ieee80211_device * ieee = (struct ieee80211_device*)
2382 // container_of(work, struct ieee80211_device, watch_dog_wq);
2383 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2384 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
2385 struct net_device *dev = ieee->dev;
2387 rtl8192_hw_sleep_down(dev);
2390 static void rtl8192_hw_wakeup(struct net_device* dev)
2392 struct r8192_priv *priv = ieee80211_priv(dev);
2393 unsigned long flags = 0;
2395 spin_lock_irqsave(&priv->rf_ps_lock,flags);
2396 if (priv->RFChangeInProgress) {
2397 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2398 RT_TRACE(COMP_RF, "rtl8192_hw_wakeup(): RF Change in progress! \n");
2399 printk("rtl8192_hw_wakeup(): RF Change in progress! schedule wake up task again\n");
2400 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
2403 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2405 //RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __FUNCTION__);
2406 MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS);
2409 void rtl8192_hw_wakeup_wq (struct work_struct *work)
2411 // struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
2412 // struct ieee80211_device * ieee = (struct ieee80211_device*)
2413 // container_of(work, struct ieee80211_device, watch_dog_wq);
2414 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2415 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
2416 struct net_device *dev = ieee->dev;
2417 rtl8192_hw_wakeup(dev);
2421 #define MIN_SLEEP_TIME 50
2422 #define MAX_SLEEP_TIME 10000
2423 static void rtl8192_hw_to_sleep(struct net_device *dev, u32 th, u32 tl)
2425 struct r8192_priv *priv = ieee80211_priv(dev);
2428 unsigned long flags;
2430 spin_lock_irqsave(&priv->ps_lock,flags);
2432 // Writing HW register with 0 equals to disable
2433 // the timer, that is not really what we want
2435 tl -= MSECS(8+16+7);
2437 // If the interval in witch we are requested to sleep is too
2438 // short then give up and remain awake
2439 // when we sleep after send null frame, the timer will be too short to sleep.
2441 if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
2442 ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
2443 spin_unlock_irqrestore(&priv->ps_lock,flags);
2444 printk("too short to sleep::%x, %x, %lx\n",tl, rb, MSECS(MIN_SLEEP_TIME));
2448 if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
2449 ((tl < rb) && (tl>MSECS(69)) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))||
2450 ((tl<rb)&&(tl<MSECS(69))&&((tl+0xffffffff-rb)>MSECS(MAX_SLEEP_TIME)))) {
2451 printk("========>too long to sleep:%x, %x, %lx\n", tl, rb, MSECS(MAX_SLEEP_TIME));
2452 spin_unlock_irqrestore(&priv->ps_lock,flags);
2456 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
2457 queue_delayed_work(priv->ieee80211->wq,
2458 &priv->ieee80211->hw_wakeup_wq,tmp);
2459 //PowerSave not supported when kernel version less 2.6.20
2461 queue_delayed_work(priv->ieee80211->wq,
2462 (void *)&priv->ieee80211->hw_sleep_wq,0);
2463 spin_unlock_irqrestore(&priv->ps_lock,flags);
2466 static void rtl8192_init_priv_variable(struct net_device* dev)
2468 struct r8192_priv *priv = ieee80211_priv(dev);
2470 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
2472 // Default Halt the NIC if RF is OFF.
2473 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_HALT_NIC;
2474 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_CLK_REQ;
2475 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_ASPM;
2476 pPSC->RegRfPsLevel |= RT_RF_LPS_LEVEL_ASPM;
2477 pPSC->bLeisurePs = true;
2478 pPSC->RegMaxLPSAwakeIntvl = 5;
2479 priv->bHwRadioOff = false;
2481 priv->being_init_adapter = false;
2482 priv->txbuffsize = 1600;//1024;
2483 priv->txfwbuffersize = 4096;
2484 priv->txringcount = 64;//32;
2485 //priv->txbeaconcount = priv->txringcount;
2486 priv->txbeaconcount = 2;
2487 priv->rxbuffersize = 9100;//2048;//1024;
2488 priv->rxringcount = MAX_RX_COUNT;//64;
2489 priv->irq_enabled=0;
2490 priv->card_8192 = NIC_8192E;
2491 priv->rx_skb_complete = 1;
2492 priv->chan = 1; //set to channel 1
2493 priv->RegWirelessMode = WIRELESS_MODE_AUTO;
2494 priv->RegChannelPlan = 0xf;
2495 priv->nrxAMPDU_size = 0;
2496 priv->nrxAMPDU_aggr_num = 0;
2497 priv->last_rxdesc_tsf_high = 0;
2498 priv->last_rxdesc_tsf_low = 0;
2499 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2500 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2501 priv->ieee80211->ieee_up=0;
2502 priv->retry_rts = DEFAULT_RETRY_RTS;
2503 priv->retry_data = DEFAULT_RETRY_DATA;
2504 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2505 priv->ieee80211->rate = 110; //11 mbps
2506 priv->ieee80211->short_slot = 1;
2507 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2508 priv->bcck_in_ch14 = false;
2509 priv->bfsync_processing = false;
2510 priv->CCKPresentAttentuation = 0;
2511 priv->rfa_txpowertrackingindex = 0;
2512 priv->rfc_txpowertrackingindex = 0;
2514 priv->ScanDelay = 50;//for Scan TODO
2515 //added by amy for silent reset
2516 priv->ResetProgress = RESET_TYPE_NORESET;
2517 priv->bForcedSilentReset = 0;
2518 priv->bDisableNormalResetCheck = false;
2519 priv->force_reset = false;
2520 //added by amy for power save
2522 priv->ieee80211->RfOffReason = 0;
2523 priv->RFChangeInProgress = false;
2524 priv->bHwRfOffAction = 0;
2525 priv->SetRFPowerStateInProgress = false;
2526 priv->ieee80211->PowerSaveControl.bInactivePs = true;
2527 priv->ieee80211->PowerSaveControl.bIPSModeBackup = false;
2529 priv->txpower_checkcnt = 0;
2530 priv->thermal_readback_index =0;
2531 priv->txpower_tracking_callback_cnt = 0;
2532 priv->ccktxpower_adjustcnt_ch14 = 0;
2533 priv->ccktxpower_adjustcnt_not_ch14 = 0;
2535 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2536 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2537 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2538 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2539 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;/* |
2540 IEEE_SOFTMAC_BEACONS;*///added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2542 priv->ieee80211->active_scan = 1;
2543 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2544 priv->ieee80211->host_encrypt = 1;
2545 priv->ieee80211->host_decrypt = 1;
2546 //priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2547 //priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2548 priv->ieee80211->start_send_beacons = rtl8192_start_beacon;//+by david 081107
2549 priv->ieee80211->stop_send_beacons = rtl8192_stop_beacon;//+by david 081107
2550 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2551 priv->ieee80211->set_chan = rtl8192_set_chan;
2552 priv->ieee80211->link_change = rtl8192_link_change;
2553 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2554 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2555 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2556 priv->ieee80211->init_wmmparam_flag = 0;
2557 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2558 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2559 priv->ieee80211->tx_headroom = sizeof(TX_FWINFO_8190PCI);
2560 priv->ieee80211->qos_support = 1;
2561 priv->ieee80211->dot11PowerSaveMode = 0;
2563 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2564 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2565 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2566 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2568 priv->ieee80211->sta_wake_up = rtl8192_hw_wakeup;
2569 // priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
2570 priv->ieee80211->enter_sleep_state = rtl8192_hw_to_sleep;
2571 priv->ieee80211->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
2573 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8190Pci;
2574 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2575 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xPci;
2578 priv->ieee80211->InitialGainHandler = InitialGain819xPci;
2581 priv->ieee80211->ieee80211_ips_leave_wq = ieee80211_ips_leave_wq;
2582 priv->ieee80211->ieee80211_ips_leave = ieee80211_ips_leave;
2585 priv->ieee80211->LeisurePSLeave = LeisurePSLeave;
2588 priv->ieee80211->SetHwRegHandler = rtl8192e_SetHwReg;
2589 priv->ieee80211->rtllib_ap_sec_type = rtl8192e_ap_sec_type;
2591 priv->card_type = USB;
2593 priv->ShortRetryLimit = 0x30;
2594 priv->LongRetryLimit = 0x30;
2596 priv->EarlyRxThreshold = 7;
2597 priv->enable_gpio0 = 0;
2599 priv->TransmitConfig = 0;
2601 priv->ReceiveConfig = RCR_ADD3 |
2602 RCR_AMF | RCR_ADF | //accept management/data
2603 RCR_AICV | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2604 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2605 RCR_AAP | ((u32)7<<RCR_MXDMA_OFFSET) |
2606 ((u32)7 << RCR_FIFO_OFFSET) | RCR_ONLYERLPKT;
2608 priv->irq_mask = (u32)(IMR_ROK | IMR_VODOK | IMR_VIDOK | IMR_BEDOK | IMR_BKDOK |\
2609 IMR_HCCADOK | IMR_MGNTDOK | IMR_COMDOK | IMR_HIGHDOK |\
2610 IMR_BDOK | IMR_RXCMDOK | IMR_TIMEOUT0 | IMR_RDU | IMR_RXFOVW |\
2611 IMR_TXFOVW | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
2613 priv->AcmControl = 0;
2614 priv->pFirmware = (rt_firmware*)vmalloc(sizeof(rt_firmware));
2615 if (priv->pFirmware)
2616 memset(priv->pFirmware, 0, sizeof(rt_firmware));
2618 /* rx related queue */
2619 skb_queue_head_init(&priv->rx_queue);
2620 skb_queue_head_init(&priv->skb_queue);
2622 /* Tx related queue */
2623 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2624 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2626 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2627 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2629 priv->rf_set_chan = rtl8192_phy_SwChnl;
2633 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2635 spin_lock_init(&priv->tx_lock);
2636 spin_lock_init(&priv->irq_lock);//added by thomas
2637 spin_lock_init(&priv->irq_th_lock);
2638 spin_lock_init(&priv->rf_ps_lock);
2639 spin_lock_init(&priv->ps_lock);
2640 //spin_lock_init(&priv->rf_lock);
2641 sema_init(&priv->wx_sem,1);
2642 sema_init(&priv->rf_sem,1);
2643 mutex_init(&priv->mutex);
2646 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
2648 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2649 void rtl8192_irq_tx_tasklet(struct r8192_priv *priv);
2650 void rtl8192_prepare_beacon(struct r8192_priv *priv);
2651 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2652 #define DRV_NAME "wlan0"
2653 static void rtl8192_init_priv_task(struct net_device* dev)
2655 struct r8192_priv *priv = ieee80211_priv(dev);
2657 #ifdef PF_SYNCTHREAD
2658 priv->priv_wq = create_workqueue(DRV_NAME,0);
2660 priv->priv_wq = create_workqueue(DRV_NAME);
2664 INIT_WORK(&priv->ieee80211->ips_leave_wq, (void*)IPSLeave_wq);
2667 // INIT_WORK(&priv->reset_wq, (void(*)(void*)) rtl8192_restart);
2668 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2669 // INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2670 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2671 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2672 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2673 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2674 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2675 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2676 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2677 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq);
2678 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq);
2680 tasklet_init(&priv->irq_rx_tasklet,
2681 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2682 (unsigned long)priv);
2683 tasklet_init(&priv->irq_tx_tasklet,
2684 (void(*)(unsigned long))rtl8192_irq_tx_tasklet,
2685 (unsigned long)priv);
2686 tasklet_init(&priv->irq_prepare_beacon_tasklet,
2687 (void(*)(unsigned long))rtl8192_prepare_beacon,
2688 (unsigned long)priv);
2691 static void rtl8192_get_eeprom_size(struct net_device* dev)
2694 struct r8192_priv *priv = ieee80211_priv(dev);
2695 RT_TRACE(COMP_INIT, "===========>%s()\n", __FUNCTION__);
2696 curCR = read_nic_dword(dev, EPROM_CMD);
2697 RT_TRACE(COMP_INIT, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD, curCR);
2698 //whether need I consider BIT5?
2699 priv->epromtype = (curCR & EPROM_CMD_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2700 RT_TRACE(COMP_INIT, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2703 //used to swap endian. as ntohl & htonl are not neccessary to swap endian, so use this instead.
2704 static inline u16 endian_swap(u16* data)
2707 *data = (tmp >> 8) | (tmp << 8);
2712 * Note: Adapter->EEPROMAddressSize should be set before this function call.
2713 * EEPROM address size can be got through GetEEPROMSize8185()
2715 static void rtl8192_read_eeprom_info(struct net_device* dev)
2717 struct r8192_priv *priv = ieee80211_priv(dev);
2721 u8 ICVer8192, ICVer8256;
2723 u16 i,usValue, IC_Version;
2726 u8 offset;//, tmpAFR;
2727 u8 EepromTxPower[100];
2729 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01};
2730 RT_TRACE(COMP_INIT, "====> rtl8192_read_eeprom_info\n");
2733 // TODO: I don't know if we need to apply EF function to EEPROM read function
2735 //2 Read EEPROM ID to make sure autoload is success
2736 EEPROMId = eprom_read(dev, 0);
2737 if( EEPROMId != RTL8190_EEPROM_ID )
2739 RT_TRACE(COMP_ERR, "EEPROM ID is invalid:%x, %x\n", EEPROMId, RTL8190_EEPROM_ID);
2740 priv->AutoloadFailFlag=true;
2744 priv->AutoloadFailFlag=false;
2748 // Assign Chip Version ID
2750 // Read IC Version && Channel Plan
2751 if(!priv->AutoloadFailFlag)
2754 priv->eeprom_vid = eprom_read(dev, (EEPROM_VID >> 1));
2755 priv->eeprom_did = eprom_read(dev, (EEPROM_DID >> 1));
2757 usValue = eprom_read(dev, (u16)(EEPROM_Customer_ID>>1)) >> 8 ;
2758 priv->eeprom_CustomerID = (u8)( usValue & 0xff);
2759 usValue = eprom_read(dev, (EEPROM_ICVersion_ChannelPlan>>1));
2760 priv->eeprom_ChannelPlan = usValue&0xff;
2761 IC_Version = ((usValue&0xff00)>>8);
2764 priv->card_8192_version = (VERSION_8190)(IC_Version);
2767 ICVer8192 = (IC_Version&0xf); //bit0~3; 1:A cut, 2:B cut, 3:C cut...
2768 ICVer8256 = ((IC_Version&0xf0)>>4);//bit4~6, bit7 reserved for other RF chip; 1:A cut, 2:B cut, 3:C cut...
2769 RT_TRACE(COMP_INIT, "\nICVer8192 = 0x%x\n", ICVer8192);
2770 RT_TRACE(COMP_INIT, "\nICVer8256 = 0x%x\n", ICVer8256);
2771 if(ICVer8192 == 0x2) //B-cut
2773 if(ICVer8256 == 0x5) //E-cut
2774 priv->card_8192_version= VERSION_8190_BE;
2778 switch(priv->card_8192_version)
2780 case VERSION_8190_BD:
2781 case VERSION_8190_BE:
2784 priv->card_8192_version = VERSION_8190_BD;
2787 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", priv->card_8192_version);
2791 priv->card_8192_version = VERSION_8190_BD;
2792 priv->eeprom_vid = 0;
2793 priv->eeprom_did = 0;
2794 priv->eeprom_CustomerID = 0;
2795 priv->eeprom_ChannelPlan = 0;
2796 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", 0xff);
2799 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
2800 RT_TRACE(COMP_INIT, "EEPROM DID = 0x%4x\n", priv->eeprom_did);
2801 RT_TRACE(COMP_INIT,"EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
2803 //2 Read Permanent MAC address
2804 if(!priv->AutoloadFailFlag)
2806 for(i = 0; i < 6; i += 2)
2808 usValue = eprom_read(dev, (u16) ((EEPROM_NODE_ADDRESS_BYTE_0+i)>>1));
2809 *(u16*)(&dev->dev_addr[i]) = usValue;
2812 // when auto load failed, the last address byte set to be a random one.
2813 // added by david woo.2007/11/7
2814 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2817 RT_TRACE(COMP_INIT, "Permanent Address = %pM\n", dev->dev_addr);
2819 //2 TX Power Check EEPROM Fail or not
2820 if(priv->card_8192_version > VERSION_8190_BD) {
2821 priv->bTXPowerDataReadFromEEPORM = true;
2823 priv->bTXPowerDataReadFromEEPORM = false;
2826 // 2007/11/15 MH 8190PCI Default=2T4R, 8192PCIE default=1T2R
2827 priv->rf_type = RTL819X_DEFAULT_RF_TYPE;
2829 if(priv->card_8192_version > VERSION_8190_BD)
2831 // Read RF-indication and Tx Power gain index diff of legacy to HT OFDM rate.
2832 if(!priv->AutoloadFailFlag)
2834 tempval = (eprom_read(dev, (EEPROM_RFInd_PowerDiff>>1))) & 0xff;
2835 priv->EEPROMLegacyHTTxPowerDiff = tempval & 0xf; // bit[3:0]
2837 if (tempval&0x80) //RF-indication, bit[7]
2838 priv->rf_type = RF_1T2R;
2840 priv->rf_type = RF_2T4R;
2844 priv->EEPROMLegacyHTTxPowerDiff = EEPROM_Default_LegacyHTTxPowerDiff;
2846 RT_TRACE(COMP_INIT, "EEPROMLegacyHTTxPowerDiff = %d\n",
2847 priv->EEPROMLegacyHTTxPowerDiff);
2849 // Read ThermalMeter from EEPROM
2850 if(!priv->AutoloadFailFlag)
2852 priv->EEPROMThermalMeter = (u8)(((eprom_read(dev, (EEPROM_ThermalMeter>>1))) & 0xff00)>>8);
2856 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2858 RT_TRACE(COMP_INIT, "ThermalMeter = %d\n", priv->EEPROMThermalMeter);
2859 //vivi, for tx power track
2860 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2862 if(priv->epromtype == EPROM_93c46)
2864 // Read antenna tx power offset of B/C/D to A and CrystalCap from EEPROM
2865 if(!priv->AutoloadFailFlag)
2867 usValue = eprom_read(dev, (EEPROM_TxPwDiff_CrystalCap>>1));
2868 priv->EEPROMAntPwDiff = (usValue&0x0fff);
2869 priv->EEPROMCrystalCap = (u8)((usValue&0xf000)>>12);
2873 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2874 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2876 RT_TRACE(COMP_INIT, "EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2877 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2880 // Get per-channel Tx Power Level
2882 for(i=0; i<14; i+=2)
2884 if(!priv->AutoloadFailFlag)
2886 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_CCK+i)>>1) );
2890 usValue = EEPROM_Default_TxPower;
2892 *((u16*)(&priv->EEPROMTxPowerLevelCCK[i])) = usValue;
2893 RT_TRACE(COMP_INIT,"CCK Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK[i]);
2894 RT_TRACE(COMP_INIT, "CCK Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelCCK[i+1]);
2896 for(i=0; i<14; i+=2)
2898 if(!priv->AutoloadFailFlag)
2900 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_OFDM_24G+i)>>1) );
2904 usValue = EEPROM_Default_TxPower;
2906 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[i])) = usValue;
2907 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelOFDM24G[i]);
2908 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelOFDM24G[i+1]);
2911 else if(priv->epromtype== EPROM_93c56)
2914 // Read CrystalCap from EEPROM
2915 if(!priv->AutoloadFailFlag)
2917 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2918 priv->EEPROMCrystalCap = (u8)(((eprom_read(dev, (EEPROM_C56_CrystalCap>>1))) & 0xf000)>>12);
2922 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2923 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2925 RT_TRACE(COMP_INIT,"EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2926 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2928 // Get Tx Power Level by Channel
2929 if(!priv->AutoloadFailFlag)
2931 // Read Tx power of Channel 1 ~ 14 from EEPROM.
2932 for(i = 0; i < 12; i+=2)
2935 offset = EEPROM_C56_RfA_CCK_Chnl1_TxPwIndex + i;
2937 offset = EEPROM_C56_RfC_CCK_Chnl1_TxPwIndex + i - 6;
2938 usValue = eprom_read(dev, (offset>>1));
2939 *((u16*)(&EepromTxPower[i])) = usValue;
2942 for(i = 0; i < 12; i++)
2945 priv->EEPROMRfACCKChnl1TxPwLevel[i] = EepromTxPower[i];
2946 else if ((i >=3 )&&(i <= 5))
2947 priv->EEPROMRfAOfdmChnlTxPwLevel[i-3] = EepromTxPower[i];
2948 else if ((i >=6 )&&(i <= 8))
2949 priv->EEPROMRfCCCKChnl1TxPwLevel[i-6] = EepromTxPower[i];
2951 priv->EEPROMRfCOfdmChnlTxPwLevel[i-9] = EepromTxPower[i];
2956 priv->EEPROMRfACCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2957 priv->EEPROMRfACCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2958 priv->EEPROMRfACCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2960 priv->EEPROMRfAOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2961 priv->EEPROMRfAOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2962 priv->EEPROMRfAOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2964 priv->EEPROMRfCCCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2965 priv->EEPROMRfCCCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2966 priv->EEPROMRfCCCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2968 priv->EEPROMRfCOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2969 priv->EEPROMRfCOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2970 priv->EEPROMRfCOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2972 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[0]);
2973 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[1]);
2974 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[2]);
2975 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[0]);
2976 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[1]);
2977 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[2]);
2978 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[0]);
2979 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[1]);
2980 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[2]);
2981 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[0]);
2982 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[1]);
2983 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[2]);
2988 // Update HAL variables.
2990 if(priv->epromtype == EPROM_93c46)
2994 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK[i];
2995 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[i];
2997 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2998 // Antenna B gain offset to antenna A, bit0~3
2999 priv->AntennaTxPwDiff[0] = (priv->EEPROMAntPwDiff & 0xf);
3000 // Antenna C gain offset to antenna A, bit4~7
3001 priv->AntennaTxPwDiff[1] = ((priv->EEPROMAntPwDiff & 0xf0)>>4);
3002 // Antenna D gain offset to antenna A, bit8~11
3003 priv->AntennaTxPwDiff[2] = ((priv->EEPROMAntPwDiff & 0xf00)>>8);
3004 // CrystalCap, bit12~15
3005 priv->CrystalCap = priv->EEPROMCrystalCap;
3006 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
3007 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
3008 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
3010 else if(priv->epromtype == EPROM_93c56)
3012 //char cck_pwr_diff_a=0, cck_pwr_diff_c=0;
3014 //cck_pwr_diff_a = pHalData->EEPROMRfACCKChnl7TxPwLevel - pHalData->EEPROMRfAOfdmChnlTxPwLevel[1];
3015 //cck_pwr_diff_c = pHalData->EEPROMRfCCCKChnl7TxPwLevel - pHalData->EEPROMRfCOfdmChnlTxPwLevel[1];
3016 for(i=0; i<3; i++) // channel 1~3 use the same Tx Power Level.
3018 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[0];
3019 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[0];
3020 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[0];
3021 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[0];
3023 for(i=3; i<9; i++) // channel 4~9 use the same Tx Power Level
3025 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[1];
3026 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[1];
3027 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[1];
3028 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[1];
3030 for(i=9; i<14; i++) // channel 10~14 use the same Tx Power Level
3032 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[2];
3033 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[2];
3034 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[2];
3035 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[2];
3038 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_A[i]);
3040 RT_TRACE(COMP_INIT,"priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_A[i]);
3042 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_C[i]);
3044 RT_TRACE(COMP_INIT, "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_C[i]);
3045 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
3046 priv->AntennaTxPwDiff[0] = 0;
3047 priv->AntennaTxPwDiff[1] = 0;
3048 priv->AntennaTxPwDiff[2] = 0;
3049 priv->CrystalCap = priv->EEPROMCrystalCap;
3050 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
3051 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
3052 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
3056 if(priv->rf_type == RF_1T2R)
3058 RT_TRACE(COMP_INIT, "\n1T2R config\n");
3060 else if (priv->rf_type == RF_2T4R)
3062 RT_TRACE(COMP_INIT, "\n2T4R config\n");
3065 // 2008/01/16 MH We can only know RF type in the function. So we have to init
3066 // DIG RATR table again.
3067 init_rate_adaptive(dev);
3069 //1 Make a copy for following variables and we can change them if we want
3071 priv->rf_chip= RF_8256;
3073 if(priv->RegChannelPlan == 0xf)
3075 priv->ChannelPlan = priv->eeprom_ChannelPlan;
3079 priv->ChannelPlan = priv->RegChannelPlan;
3083 // Used PID and DID to Set CustomerID
3085 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304 )
3087 priv->CustomerID = RT_CID_DLINK;
3090 switch(priv->eeprom_CustomerID)
3092 case EEPROM_CID_DEFAULT:
3093 priv->CustomerID = RT_CID_DEFAULT;
3095 case EEPROM_CID_CAMEO:
3096 priv->CustomerID = RT_CID_819x_CAMEO;
3098 case EEPROM_CID_RUNTOP:
3099 priv->CustomerID = RT_CID_819x_RUNTOP;
3101 case EEPROM_CID_NetCore:
3102 priv->CustomerID = RT_CID_819x_Netcore;
3104 case EEPROM_CID_TOSHIBA: // Merge by Jacken, 2008/01/31
3105 priv->CustomerID = RT_CID_TOSHIBA;
3106 if(priv->eeprom_ChannelPlan&0x80)
3107 priv->ChannelPlan = priv->eeprom_ChannelPlan&0x7f;
3109 priv->ChannelPlan = 0x0;
3110 RT_TRACE(COMP_INIT, "Toshiba ChannelPlan = 0x%x\n",
3113 case EEPROM_CID_Nettronix:
3114 priv->ScanDelay = 100; //cosa add for scan
3115 priv->CustomerID = RT_CID_Nettronix;
3117 case EEPROM_CID_Pronet:
3118 priv->CustomerID = RT_CID_PRONET;
3120 case EEPROM_CID_DLINK:
3121 priv->CustomerID = RT_CID_DLINK;
3124 case EEPROM_CID_WHQL:
3125 //Adapter->bInHctTest = TRUE;//do not supported
3127 //priv->bSupportTurboMode = FALSE;
3128 //priv->bAutoTurboBy8186 = FALSE;
3130 //pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
3131 //pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
3132 //pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
3136 // value from RegCustomerID
3140 //Avoid the channel plan array overflow, by Bruce, 2007-08-27.
3141 if(priv->ChannelPlan > CHANNEL_PLAN_LEN - 1)
3142 priv->ChannelPlan = 0; //FCC
3144 switch(priv->CustomerID)
3146 case RT_CID_DEFAULT:
3148 priv->LedStrategy = HW_LED;
3151 priv->LedStrategy = SW_LED_MODE1;
3156 case RT_CID_819x_CAMEO:
3157 priv->LedStrategy = SW_LED_MODE2;
3160 case RT_CID_819x_RUNTOP:
3161 priv->LedStrategy = SW_LED_MODE3;
3164 case RT_CID_819x_Netcore:
3165 priv->LedStrategy = SW_LED_MODE4;
3168 case RT_CID_Nettronix:
3169 priv->LedStrategy = SW_LED_MODE5;
3173 priv->LedStrategy = SW_LED_MODE6;
3176 case RT_CID_TOSHIBA: //Modify by Jacken 2008/01/31
3182 priv->LedStrategy = HW_LED;
3185 priv->LedStrategy = SW_LED_MODE1;
3192 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304)
3193 priv->ieee80211->bSupportRemoteWakeUp = true;
3195 priv->ieee80211->bSupportRemoteWakeUp = false;
3198 RT_TRACE(COMP_INIT, "RegChannelPlan(%d)\n", priv->RegChannelPlan);
3199 RT_TRACE(COMP_INIT, "ChannelPlan = %d \n", priv->ChannelPlan);
3200 RT_TRACE(COMP_INIT, "LedStrategy = %d \n", priv->LedStrategy);
3201 RT_TRACE(COMP_TRACE, "<==== ReadAdapterInfo\n");
3207 static short rtl8192_get_channel_map(struct net_device * dev)
3209 struct r8192_priv *priv = ieee80211_priv(dev);
3210 #ifdef ENABLE_DOT11D
3211 if(priv->ChannelPlan> COUNTRY_CODE_GLOBAL_DOMAIN){
3212 printk("rtl8180_init:Error channel plan! Set to default.\n");
3213 priv->ChannelPlan= 0;
3215 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
3217 rtl819x_set_channel_map(priv->ChannelPlan, priv);
3220 //Set Default Channel Plan
3222 DMESG("No channels, aborting");
3226 priv->ChannelPlan= 0;//hikaru
3227 // set channels 1..14 allowed in given locale
3228 for (i=1; i<=14; i++) {
3229 (priv->ieee80211->channel_map)[i] = (u8)(ch & 0x01);
3236 static short rtl8192_init(struct net_device *dev)
3238 struct r8192_priv *priv = ieee80211_priv(dev);
3239 memset(&(priv->stats),0,sizeof(struct Stats));
3240 rtl8192_init_priv_variable(dev);
3241 rtl8192_init_priv_lock(priv);
3242 rtl8192_init_priv_task(dev);
3243 rtl8192_get_eeprom_size(dev);
3244 rtl8192_read_eeprom_info(dev);
3245 rtl8192_get_channel_map(dev);
3247 init_timer(&priv->watch_dog_timer);
3248 priv->watch_dog_timer.data = (unsigned long)dev;
3249 priv->watch_dog_timer.function = watch_dog_timer_callback;
3250 #if defined(IRQF_SHARED)
3251 if(request_irq(dev->irq, (void*)rtl8192_interrupt, IRQF_SHARED, dev->name, dev)){
3253 if(request_irq(dev->irq, (void *)rtl8192_interrupt, SA_SHIRQ, dev->name, dev)){
3255 printk("Error allocating IRQ %d",dev->irq);
3259 printk("IRQ %d",dev->irq);
3261 if(rtl8192_pci_initdescring(dev)!=0){
3262 printk("Endopoints initialization failed");
3266 //rtl8192_rx_enable(dev);
3267 //rtl8192_adapter_start(dev);
3271 /******************************************************************************
3272 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
3273 * not to do all the hw config as its name says
3274 * input: net_device dev
3277 * notice: This part need to modified according to the rate set we filtered
3278 * ****************************************************************************/
3279 static void rtl8192_hwconfig(struct net_device* dev)
3281 u32 regRATR = 0, regRRSR = 0;
3282 u8 regBwOpMode = 0, regTmp = 0;
3283 struct r8192_priv *priv = ieee80211_priv(dev);
3285 // Set RRSR, RATR, and BW_OPMODE registers
3287 switch(priv->ieee80211->mode)
3289 case WIRELESS_MODE_B:
3290 regBwOpMode = BW_OPMODE_20MHZ;
3291 regRATR = RATE_ALL_CCK;
3292 regRRSR = RATE_ALL_CCK;
3294 case WIRELESS_MODE_A:
3295 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
3296 regRATR = RATE_ALL_OFDM_AG;
3297 regRRSR = RATE_ALL_OFDM_AG;
3299 case WIRELESS_MODE_G:
3300 regBwOpMode = BW_OPMODE_20MHZ;
3301 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3302 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3304 case WIRELESS_MODE_AUTO:
3305 case WIRELESS_MODE_N_24G:
3306 // It support CCK rate by default.
3307 // CCK rate will be filtered out only when associated AP does not support it.
3308 regBwOpMode = BW_OPMODE_20MHZ;
3309 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3310 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3312 case WIRELESS_MODE_N_5G:
3313 regBwOpMode = BW_OPMODE_5G;
3314 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3315 regRRSR = RATE_ALL_OFDM_AG;
3319 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
3322 ratr_value = regRATR;
3323 if (priv->rf_type == RF_1T2R)
3325 ratr_value &= ~(RATE_ALL_OFDM_2SS);
3327 write_nic_dword(dev, RATR0, ratr_value);
3328 write_nic_byte(dev, UFWP, 1);
3330 regTmp = read_nic_byte(dev, 0x313);
3331 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
3332 write_nic_dword(dev, RRSR, regRRSR);
3335 // Set Retry Limit here
3337 write_nic_word(dev, RETRY_LIMIT,
3338 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | \
3339 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3340 // Set Contention Window here
3344 // Set Tx Antenna including Feedback control
3346 // Set Auto Rate fallback control
3352 static RT_STATUS rtl8192_adapter_start(struct net_device *dev)
3354 struct r8192_priv *priv = ieee80211_priv(dev);
3355 // struct ieee80211_device *ieee = priv->ieee80211;
3357 RT_STATUS rtStatus = RT_STATUS_SUCCESS;
3358 // static char szMACPHYRegFile[] = RTL819X_PHY_MACPHY_REG;
3359 // static char szMACPHYRegPGFile[] = RTL819X_PHY_MACPHY_REG_PG;
3363 u8 ICVersion,SwitchingRegulatorOutput;
3365 bool bfirmwareok = true;
3369 u32 tmpRegA, tmpRegC, TempCCk;
3371 // u32 dwRegRead = 0;
3373 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3374 priv->being_init_adapter = true;
3375 rtl8192_pci_resetdescring(dev);
3376 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
3377 priv->Rf_Mode = RF_OP_By_SW_3wire;
3380 if(priv->ResetProgress == RESET_TYPE_NORESET)
3382 write_nic_byte(dev, ANAPAR, 0x37);
3383 // Accordign to designer's explain, LBUS active will never > 10ms. We delay 10ms
3384 // Joseph increae the time to prevent firmware download fail
3388 //PlatformSleepUs(10000);
3389 // For any kind of InitializeAdapter process, we shall use system now!!
3390 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3392 // Set to eRfoff in order not to count receive count.
3393 if(priv->RegRfOff == TRUE)
3394 priv->ieee80211->eRFPowerState = eRfOff;
3397 //3 //Config CPUReset Register
3399 //3 Firmware Reset Or Not
3400 ulRegRead = read_nic_dword(dev, CPU_GEN);
3401 if(priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3402 { //called from MPInitialized. do nothing
3403 ulRegRead |= CPU_GEN_SYSTEM_RESET;
3404 }else if(priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3405 ulRegRead |= CPU_GEN_FIRMWARE_RESET; // Called from MPReset
3407 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3410 //2008.06.03, for WOL 90 hw bug
3411 ulRegRead &= (~(CPU_GEN_GPIO_UART));
3414 write_nic_dword(dev, CPU_GEN, ulRegRead);
3420 //3 //Fix the issue of E-cut high temperature issue
3423 ICVersion = read_nic_byte(dev, IC_VERRSION);
3424 if(ICVersion >= 0x4) //E-cut only
3426 // HW SD suggest that we should not wirte this register too often, so driver
3427 // should readback this register. This register will be modified only when
3429 SwitchingRegulatorOutput = read_nic_byte(dev, SWREGULATOR);
3430 if(SwitchingRegulatorOutput != 0xb8)
3432 write_nic_byte(dev, SWREGULATOR, 0xa8);
3434 write_nic_byte(dev, SWREGULATOR, 0xb8);
3441 //3// Initialize BB before MAC
3443 RT_TRACE(COMP_INIT, "BB Config Start!\n");
3444 rtStatus = rtl8192_BBConfig(dev);
3445 if(rtStatus != RT_STATUS_SUCCESS)
3447 RT_TRACE(COMP_ERR, "BB Config failed\n");
3450 RT_TRACE(COMP_INIT,"BB Config Finished!\n");
3452 //3//Set Loopback mode or Normal mode
3454 //2006.12.13 by emily. Note!We should not merge these two CPU_GEN register writings
3455 // because setting of System_Reset bit reset MAC to default transmission mode.
3456 //Loopback mode or not
3457 priv->LoopbackMode = RTL819X_NO_LOOPBACK;
3458 //priv->LoopbackMode = RTL819X_MAC_LOOPBACK;
3459 if(priv->ResetProgress == RESET_TYPE_NORESET)
3461 ulRegRead = read_nic_dword(dev, CPU_GEN);
3462 if(priv->LoopbackMode == RTL819X_NO_LOOPBACK)
3464 ulRegRead = ((ulRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3466 else if (priv->LoopbackMode == RTL819X_MAC_LOOPBACK )
3468 ulRegRead |= CPU_CCK_LOOPBACK;
3472 RT_TRACE(COMP_ERR,"Serious error: wrong loopback mode setting\n");
3475 //2008.06.03, for WOL
3476 //ulRegRead &= (~(CPU_GEN_GPIO_UART));
3477 write_nic_dword(dev, CPU_GEN, ulRegRead);
3479 // 2006.11.29. After reset cpu, we sholud wait for a second, otherwise, it may fail to write registers. Emily
3482 //3Set Hardware(Do nothing now)
3483 rtl8192_hwconfig(dev);
3484 //2=======================================================
3485 // Common Setting for all of the FPGA platform. (part 1)
3486 //2=======================================================
3487 // If there is changes, please make sure it applies to all of the FPGA version
3489 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3493 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) | \
3494 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) | \
3498 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |\
3499 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) ));
3503 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3504 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3506 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3508 //3 Initialize Number of Reserved Pages in Firmware Queue
3510 if(priv->bInHctTest)
3512 PlatformEFIOWrite4Byte(Adapter, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK_DTM << RSVD_FW_QUEUE_PAGE_BK_SHIFT |\
3513 NUM_OF_PAGE_IN_FW_QUEUE_BE_DTM << RSVD_FW_QUEUE_PAGE_BE_SHIFT | \
3514 NUM_OF_PAGE_IN_FW_QUEUE_VI_DTM << RSVD_FW_QUEUE_PAGE_VI_SHIFT | \
3515 NUM_OF_PAGE_IN_FW_QUEUE_VO_DTM <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3516 PlatformEFIOWrite4Byte(Adapter, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3517 PlatformEFIOWrite4Byte(Adapter, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW| \
3518 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|\
3519 NUM_OF_PAGE_IN_FW_QUEUE_PUB_DTM<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3524 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |\
3525 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT | \
3526 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT | \
3527 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3528 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3529 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW| \
3530 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|\
3531 NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3534 rtl8192_tx_enable(dev);
3535 rtl8192_rx_enable(dev);
3536 //3Set Response Rate Setting Register
3537 // CCK rate is supported by default.
3538 // CCK rate will be filtered out only when associated AP does not support it.
3539 ulRegRead = (0xFFF00000 & read_nic_dword(dev, RRSR)) | RATE_ALL_OFDM_AG | RATE_ALL_CCK;
3540 write_nic_dword(dev, RRSR, ulRegRead);
3541 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3544 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3545 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3547 //rtl8192_actset_wirelessmode(dev,priv->RegWirelessMode);
3548 if(priv->ResetProgress == RESET_TYPE_NORESET)
3549 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3550 //-----------------------------------------------------------------------------
3551 // Set up security related. 070106, by rcnjko:
3552 // 1. Clear all H/W keys.
3553 // 2. Enable H/W encryption/decryption.
3554 //-----------------------------------------------------------------------------
3555 CamResetAllEntry(dev);
3557 u8 SECR_value = 0x0;
3558 SECR_value |= SCR_TxEncEnable;
3559 SECR_value |= SCR_RxDecEnable;
3560 SECR_value |= SCR_NoSKMC;
3561 write_nic_byte(dev, SECR, SECR_value);
3564 write_nic_word(dev, ATIMWND, 2);
3565 write_nic_word(dev, BCN_INTERVAL, 100);
3566 for (i=0; i<QOS_QUEUE_NUM; i++)
3567 write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
3569 // Switching regulator controller: This is set temporarily.
3570 // It's not sure if this can be removed in the future.
3571 // PJ advised to leave it by default.
3573 write_nic_byte(dev, 0xbe, 0xc0);
3575 //2=======================================================
3576 // Set PHY related configuration defined in MAC register bank
3577 //2=======================================================
3578 rtl8192_phy_configmac(dev);
3580 if (priv->card_8192_version > (u8) VERSION_8190_BD) {
3581 rtl8192_phy_getTxPower(dev);
3582 rtl8192_phy_setTxPower(dev, priv->chan);
3586 tmpvalue = read_nic_byte(dev, IC_VERRSION);
3587 priv->IC_Cut = tmpvalue;
3588 RT_TRACE(COMP_INIT, "priv->IC_Cut = 0x%x\n", priv->IC_Cut);
3589 if(priv->IC_Cut >= IC_VersionCut_D)
3591 //pHalData->bDcut = TRUE;
3592 if(priv->IC_Cut == IC_VersionCut_D)
3593 RT_TRACE(COMP_INIT, "D-cut\n");
3594 if(priv->IC_Cut == IC_VersionCut_E)
3596 RT_TRACE(COMP_INIT, "E-cut\n");
3597 // HW SD suggest that we should not wirte this register too often, so driver
3598 // should readback this register. This register will be modified only when
3604 //pHalData->bDcut = FALSE;
3605 RT_TRACE(COMP_INIT, "Before C-cut\n");
3610 RT_TRACE(COMP_INIT, "Load Firmware!\n");
3611 bfirmwareok = init_firmware(dev);
3612 if(bfirmwareok != true) {
3613 rtStatus = RT_STATUS_FAILURE;
3616 RT_TRACE(COMP_INIT, "Load Firmware finished!\n");
3619 if(priv->ResetProgress == RESET_TYPE_NORESET)
3621 RT_TRACE(COMP_INIT, "RF Config Started!\n");
3622 rtStatus = rtl8192_phy_RFConfig(dev);
3623 if(rtStatus != RT_STATUS_SUCCESS)
3625 RT_TRACE(COMP_ERR, "RF Config failed\n");
3628 RT_TRACE(COMP_INIT, "RF Config Finished!\n");
3630 rtl8192_phy_updateInitGain(dev);
3632 /*---- Set CCK and OFDM Block "ON"----*/
3633 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3634 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3638 write_nic_byte(dev, 0x87, 0x0);
3641 //2008.06.03, for WOL
3642 ucRegRead = read_nic_byte(dev, GPE);
3644 write_nic_byte(dev, GPE, ucRegRead);
3646 ucRegRead = read_nic_byte(dev, GPO);
3648 write_nic_byte(dev, GPO, ucRegRead);
3651 //2=======================================================
3653 //2=======================================================
3657 if(priv->RegRfOff == TRUE)
3658 { // User disable RF via registry.
3659 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RegRfOff ----------\n",__FUNCTION__);
3660 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW);
3661 #if 0//cosa, ask SD3 willis and he doesn't know what is this for
3662 // Those action will be discard in MgntActSet_RF_State because off the same state
3663 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3664 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3667 else if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS)
3668 { // H/W or S/W RF OFF before sleep.
3669 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3670 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3672 else if(priv->ieee80211->RfOffReason >= RF_CHANGE_BY_IPS)
3673 { // H/W or S/W RF OFF before sleep.
3674 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3675 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3679 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): RF-ON \n",__FUNCTION__);
3680 priv->ieee80211->eRFPowerState = eRfOn;
3681 priv->ieee80211->RfOffReason = 0;
3682 //DrvIFIndicateCurrentPhyStatus(Adapter);
3684 //Adapter->HalFunc.LedControlHandler(Adapter, LED_CTL_POWER_ON);
3687 // If inactive power mode is enabled, disable rf while in disconnected state.
3688 // But we should still tell upper layer we are in rf on state.
3689 // 2007.07.16, by shien chang.
3691 //if(!Adapter->bInHctTest)
3692 //IPSEnter(Adapter);
3699 // We can force firmware to do RF-R/W
3700 if(priv->ieee80211->FwRWRF)
3701 priv->Rf_Mode = RF_OP_By_FW;
3703 priv->Rf_Mode = RF_OP_By_SW_3wire;
3705 priv->Rf_Mode = RF_OP_By_SW_3wire;
3709 if(priv->ResetProgress == RESET_TYPE_NORESET)
3711 dm_initialize_txpower_tracking(dev);
3713 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3714 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3716 if(priv->rf_type == RF_2T4R){
3717 for(i = 0; i<TxBBGainTableLength; i++)
3719 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3721 priv->rfa_txpowertrackingindex= (u8)i;
3722 priv->rfa_txpowertrackingindex_real= (u8)i;
3723 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3728 for(i = 0; i<TxBBGainTableLength; i++)
3730 if(tmpRegC == priv->txbbgain_table[i].txbbgain_value)
3732 priv->rfc_txpowertrackingindex= (u8)i;
3733 priv->rfc_txpowertrackingindex_real= (u8)i;
3734 priv->rfc_txpowertracking_default = priv->rfc_txpowertrackingindex;
3738 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3740 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3742 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3744 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3748 priv->CCKPresentAttentuation_40Mdefault = 0;
3749 priv->CCKPresentAttentuation_difference = 0;
3750 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3751 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3752 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3753 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_initial = %d\n", priv->rfc_txpowertrackingindex);
3754 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_real_initial = %d\n", priv->rfc_txpowertrackingindex_real);
3755 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3756 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3760 if(priv->ResetProgress == RESET_TYPE_NORESET)
3762 dm_initialize_txpower_tracking(dev);
3764 if(priv->IC_Cut >= IC_VersionCut_D)
3766 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3767 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3768 for(i = 0; i<TxBBGainTableLength; i++)
3770 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3772 priv->rfa_txpowertrackingindex= (u8)i;
3773 priv->rfa_txpowertrackingindex_real= (u8)i;
3774 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3779 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3781 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3783 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3785 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3789 priv->CCKPresentAttentuation_40Mdefault = 0;
3790 priv->CCKPresentAttentuation_difference = 0;
3791 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3792 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3793 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3794 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3795 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3796 priv->btxpower_tracking = FALSE;//TEMPLY DISABLE
3801 rtl8192_irq_enable(dev);
3802 priv->being_init_adapter = false;
3807 void rtl8192_prepare_beacon(struct r8192_priv *priv)
3809 struct sk_buff *skb;
3810 //unsigned long flags;
3813 skb = ieee80211_get_beacon(priv->ieee80211);
3814 tcb_desc = (cb_desc *)(skb->cb + 8);
3815 //printk("===========> %s\n", __FUNCTION__);
3816 //spin_lock_irqsave(&priv->tx_lock,flags);
3817 /* prepare misc info for the beacon xmit */
3818 tcb_desc->queue_index = BEACON_QUEUE;
3819 /* IBSS does not support HT yet, use 1M defaultly */
3820 tcb_desc->data_rate = 2;
3821 tcb_desc->RATRIndex = 7;
3822 tcb_desc->bTxDisableRateFallBack = 1;
3823 tcb_desc->bTxUseDriverAssingedRate = 1;
3825 skb_push(skb, priv->ieee80211->tx_headroom);
3827 rtl8192_tx(priv->ieee80211->dev,skb);
3829 //spin_unlock_irqrestore (&priv->tx_lock, flags);
3833 /* this configures registers for beacon tx and enables it via
3834 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3835 * be used to stop beacon transmission
3837 void rtl8192_start_beacon(struct net_device *dev)
3839 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3840 struct ieee80211_network *net = &priv->ieee80211->current_network;
3845 DMESG("Enabling beacon TX");
3846 //rtl8192_prepare_beacon(dev);
3847 rtl8192_irq_disable(dev);
3848 //rtl8192_beacon_tx_enable(dev);
3851 write_nic_word(dev, ATIMWND, 2);
3853 /* Beacon interval (in unit of TU) */
3854 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
3857 * DrvErlyInt (in unit of TU).
3858 * (Time to send interrupt to notify driver to c
3859 * hange beacon content)
3861 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
3864 * BcnDMATIM(in unit of us).
3865 * Indicates the time before TBTT to perform beacon queue DMA
3867 write_nic_word(dev, BCN_DMATIME, 256);
3870 * Force beacon frame transmission even after receiving
3871 * beacon frame from other ad hoc STA
3873 write_nic_byte(dev, BCN_ERR_THRESH, 100);
3875 /* Set CW and IFS */
3876 BcnTimeCfg |= BcnCW<<BCN_TCFG_CW_SHIFT;
3877 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
3878 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
3881 /* enable the interrupt for ad-hoc process */
3882 rtl8192_irq_enable(dev);
3884 /***************************************************************************
3885 -------------------------------NET STUFF---------------------------
3886 ***************************************************************************/
3890 static bool HalTxCheckStuck8190Pci(struct net_device *dev)
3892 u16 RegTxCounter = read_nic_word(dev, 0x128);
3893 struct r8192_priv *priv = ieee80211_priv(dev);
3894 bool bStuck = FALSE;
3895 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3896 if(priv->TxCounter==RegTxCounter)
3899 priv->TxCounter = RegTxCounter;
3905 * <Assumption: RT_TX_SPINLOCK is acquired.>
3906 * First added: 2006.11.19 by emily
3909 TxCheckStuck(struct net_device *dev)
3911 struct r8192_priv *priv = ieee80211_priv(dev);
3913 ptx_ring head=NULL,tail=NULL,txring = NULL;
3914 u8 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3915 bool bCheckFwTxCnt = false;
3916 //unsigned long flags;
3919 // Decide Stuch threshold according to current power save mode
3921 //printk("++++++++++++>%s()\n",__FUNCTION__);
3922 switch (priv->ieee80211->dot11PowerSaveMode)
3924 // The threshold value may required to be adjusted .
3925 case eActive: // Active/Continuous access.
3926 ResetThreshold = NIC_SEND_HANG_THRESHOLD_NORMAL;
3928 case eMaxPs: // Max power save mode.
3929 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3931 case eFastPs: // Fast power save mode.
3932 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3937 // Check whether specific tcb has been queued for a specific time
3939 for(QueueID = 0; QueueID < MAX_TX_QUEUE; QueueID++)
3943 if(QueueID == TXCMD_QUEUE)
3948 tail=priv->txmapringtail;
3949 head=priv->txmapringhead;
3953 tail=priv->txbkpringtail;
3954 head=priv->txbkpringhead;
3958 tail=priv->txbepringtail;
3959 head=priv->txbepringhead;
3963 tail=priv->txvipringtail;
3964 head=priv->txvipringhead;
3968 tail=priv->txvopringtail;
3969 head=priv->txvopringhead;
3984 RT_TRACE(COMP_ERR,"%s():txring is NULL , BUG!\n",__FUNCTION__);
3987 txring->nStuckCount++;
3988 bCheckFwTxCnt = TRUE;
3994 if(HalTxCheckStuck8190Pci(dev))
3996 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3997 return RESET_TYPE_SILENT;
4001 return RESET_TYPE_NORESET;
4005 static bool HalRxCheckStuck8190Pci(struct net_device *dev)
4007 struct r8192_priv *priv = ieee80211_priv(dev);
4008 u16 RegRxCounter = read_nic_word(dev, 0x130);
4009 bool bStuck = FALSE;
4010 static u8 rx_chk_cnt = 0;
4011 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
4012 // If rssi is small, we should check rx for long time because of bad rx.
4013 // or maybe it will continuous silent reset every 2 seconds.
4015 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
4017 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
4019 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
4020 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
4021 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
4033 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
4034 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
4035 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
4039 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
4045 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
4052 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
4058 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
4061 if(priv->RxCounter==RegRxCounter)
4064 priv->RxCounter = RegRxCounter;
4069 static RESET_TYPE RxCheckStuck(struct net_device *dev)
4072 if(HalRxCheckStuck8190Pci(dev))
4074 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
4075 return RESET_TYPE_SILENT;
4078 return RESET_TYPE_NORESET;
4082 rtl819x_ifcheck_resetornot(struct net_device *dev)
4084 struct r8192_priv *priv = ieee80211_priv(dev);
4085 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
4086 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
4087 RT_RF_POWER_STATE rfState;
4089 rfState = priv->ieee80211->eRFPowerState;
4091 TxResetType = TxCheckStuck(dev);
4093 if( rfState != eRfOff &&
4094 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
4095 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
4097 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
4098 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
4099 // if driver is in firmware download failure status, driver should initialize RF in the following
4100 // silent reset procedure Emily, 2008.01.21
4102 // Driver should not check RX stuck in IBSS mode because it is required to
4103 // set Check BSSID in order to send beacon, however, if check BSSID is
4104 // set, STA cannot hear any packet a all. Emily, 2008.04.12
4105 RxResetType = RxCheckStuck(dev);
4109 RT_TRACE(COMP_RESET,"%s(): TxResetType is %d, RxResetType is %d\n",__FUNCTION__,TxResetType,RxResetType);
4110 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
4111 return RESET_TYPE_NORMAL;
4112 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT)
4113 return RESET_TYPE_SILENT;
4115 return RESET_TYPE_NORESET;
4120 static void CamRestoreAllEntry(struct net_device *dev)
4123 struct r8192_priv *priv = ieee80211_priv(dev);
4124 u8* MacAddr = priv->ieee80211->current_network.bssid;
4126 static u8 CAM_CONST_ADDR[4][6] = {
4127 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
4128 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
4129 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
4130 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
4131 static u8 CAM_CONST_BROAD[] =
4132 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
4134 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
4137 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
4138 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
4141 for(EntryId=0; EntryId<4; EntryId++)
4144 MacAddr = CAM_CONST_ADDR[EntryId];
4148 priv->ieee80211->pairwise_key_type,
4156 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
4160 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4164 priv->ieee80211->pairwise_key_type,
4172 priv->ieee80211->pairwise_key_type,
4178 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
4182 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4186 priv->ieee80211->pairwise_key_type,
4194 priv->ieee80211->pairwise_key_type,
4203 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
4205 MacAddr = CAM_CONST_BROAD;
4206 for(EntryId=1 ; EntryId<4 ; EntryId++)
4212 priv->ieee80211->group_key_type,
4218 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4222 priv->ieee80211->group_key_type,
4227 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
4229 MacAddr = CAM_CONST_BROAD;
4230 for(EntryId=1; EntryId<4 ; EntryId++)
4236 priv->ieee80211->group_key_type,
4243 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4247 priv->ieee80211->group_key_type,
4254 void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
4255 int _rtl8192_up(struct net_device *dev);
4258 * This function is used to fix Tx/Rx stop bug temporarily.
4259 * This function will do "system reset" to NIC when Tx or Rx is stuck.
4260 * The method checking Tx/Rx stuck of this function is supported by FW,
4261 * which reports Tx and Rx counter to register 0x128 and 0x130.
4263 static void rtl819x_ifsilentreset(struct net_device *dev)
4265 struct r8192_priv *priv = ieee80211_priv(dev);
4267 int reset_status = 0;
4268 struct ieee80211_device *ieee = priv->ieee80211;
4273 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
4274 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
4276 if(priv->ResetProgress==RESET_TYPE_NORESET)
4280 //LZM for PS-Poll AID issue. 090429
4281 if(priv->ieee80211->state == IEEE80211_LINKED)
4282 LeisurePSLeave(dev);
4285 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
4287 // Set the variable for reset.
4288 priv->ResetProgress = RESET_TYPE_SILENT;
4289 // rtl8192_close(dev);
4291 down(&priv->wx_sem);
4294 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
4299 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
4300 if(!netif_queue_stopped(dev))
4301 netif_stop_queue(dev);
4303 dm_backup_dynamic_mechanism_state(dev);
4305 rtl8192_irq_disable(dev);
4306 rtl8192_cancel_deferred_work(priv);
4308 del_timer_sync(&priv->watch_dog_timer);
4309 ieee->sync_scan_hurryup = 1;
4310 if(ieee->state == IEEE80211_LINKED)
4312 down(&ieee->wx_sem);
4313 printk("ieee->state is IEEE80211_LINKED\n");
4314 ieee80211_stop_send_beacons(priv->ieee80211);
4315 del_timer_sync(&ieee->associate_timer);
4316 cancel_delayed_work(&ieee->associate_retry_wq);
4317 ieee80211_stop_scan(ieee);
4318 netif_carrier_off(dev);
4322 printk("ieee->state is NOT LINKED\n");
4323 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4325 rtl8192_halt_adapter(dev, true);
4327 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
4328 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
4329 reset_status = _rtl8192_up(dev);
4331 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
4332 if(reset_status == -1)
4341 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n",__FUNCTION__);
4345 ieee->is_silent_reset = 1;
4347 EnableHWSecurityConfig8192(dev);
4349 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4351 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4354 queue_work(ieee->wq, &ieee->associate_complete_wq);
4358 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
4360 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4361 ieee->link_change(ieee->dev);
4363 // notify_wx_assoc_event(ieee);
4365 ieee80211_start_send_beacons(ieee);
4367 if (ieee->data_hard_resume)
4368 ieee->data_hard_resume(ieee->dev);
4369 netif_carrier_on(ieee->dev);
4373 CamRestoreAllEntry(dev);
4375 // Restore the previous setting for all dynamic mechanism
4376 dm_restore_dynamic_mechanism_state(dev);
4378 priv->ResetProgress = RESET_TYPE_NORESET;
4379 priv->reset_count++;
4381 priv->bForcedSilentReset =false;
4382 priv->bResetInProgress = false;
4384 // For test --> force write UFWP.
4385 write_nic_byte(dev, UFWP, 1);
4386 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4392 void InactivePsWorkItemCallback(struct net_device *dev)
4394 struct r8192_priv *priv = ieee80211_priv(dev);
4395 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4398 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() ---------> \n");
4400 // This flag "bSwRfProcessing", indicates the status of IPS procedure, should be set if the IPS workitem
4401 // is really scheduled.
4402 // The old code, sets this flag before scheduling the IPS workitem and however, at the same time the
4403 // previous IPS workitem did not end yet, fails to schedule the current workitem. Thus, bSwRfProcessing
4404 // blocks the IPS procedure of switching RF.
4405 // By Bruce, 2007-12-25.
4407 pPSC->bSwRfProcessing = TRUE;
4409 RT_TRACE(COMP_RF, "InactivePsWorkItemCallback(): Set RF to %s.\n", \
4410 pPSC->eInactivePowerState == eRfOff?"OFF":"ON");
4413 MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
4416 // To solve CAM values miss in RF OFF, rewrite CAM values after RF ON. By Bruce, 2007-09-20.
4418 pPSC->bSwRfProcessing = FALSE;
4419 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() <--------- \n");
4424 // Change current and default preamble mode.
4425 // 2005.01.06, by rcnjko.
4427 bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev, u8 rtPsMode)
4429 struct r8192_priv *priv = ieee80211_priv(dev);
4430 //PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4431 //u8 RpwmVal, FwPwrMode;
4433 // Currently, we do not change power save mode on IBSS mode.
4434 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4440 // <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
4441 // some AP will not response to our mgnt frames with PwrMgt bit set,
4442 // e.g. cannot associate the AP.
4443 // So I commented out it. 2005.02.16, by rcnjko.
4445 // // Change device's power save mode.
4446 // Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
4448 // Update power save mode configured.
4449 //RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__FUNCTION__,rtPsMode);
4450 if(!priv->ps_force) {
4451 priv->ieee80211->ps = rtPsMode;
4454 // Awake immediately
4455 if(priv->ieee80211->sta_sleep != 0 && rtPsMode == IEEE80211_PS_DISABLED)
4457 unsigned long flags;
4459 //PlatformSetTimer(Adapter, &(pMgntInfo->AwakeTimer), 0);
4460 // Notify the AP we awke.
4461 rtl8192_hw_wakeup(dev);
4462 priv->ieee80211->sta_sleep = 0;
4464 spin_lock_irqsave(&(priv->ieee80211->mgmt_tx_lock), flags);
4465 printk("LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
4466 ieee80211_sta_ps_send_null_frame(priv->ieee80211, 0);
4467 spin_unlock_irqrestore(&(priv->ieee80211->mgmt_tx_lock), flags);
4473 //================================================================================
4474 // Leisure Power Save in linked state.
4475 //================================================================================
4479 // Enter the leisure power save mode.
4481 void LeisurePSEnter(struct net_device *dev)
4483 struct r8192_priv *priv = ieee80211_priv(dev);
4484 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4486 //RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
4487 //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
4488 // pPSC->bLeisurePs, priv->ieee80211->ps,pPSC->LpsIdleCount,RT_CHECK_FOR_HANG_PERIOD);
4490 if(!((priv->ieee80211->iw_mode == IW_MODE_INFRA) &&
4491 (priv->ieee80211->state == IEEE80211_LINKED)) ||
4492 (priv->ieee80211->iw_mode == IW_MODE_ADHOC) ||
4493 (priv->ieee80211->iw_mode == IW_MODE_MASTER))
4496 if (pPSC->bLeisurePs)
4498 // Idle for a while if we connect to AP a while ago.
4499 if(pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) // 4 Sec
4502 if(priv->ieee80211->ps == IEEE80211_PS_DISABLED)
4505 //RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter 802.11 power save mode...\n");
4506 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST);
4511 pPSC->LpsIdleCount++;
4518 // Leave the leisure power save mode.
4520 void LeisurePSLeave(struct net_device *dev)
4522 struct r8192_priv *priv = ieee80211_priv(dev);
4523 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4526 //RT_TRACE(COMP_PS, "LeisurePSLeave()...\n");
4527 //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d\n",
4528 // pPSC->bLeisurePs, priv->ieee80211->ps);
4530 if (pPSC->bLeisurePs)
4532 if(priv->ieee80211->ps != IEEE80211_PS_DISABLED)
4534 // move to lps_wakecomplete()
4535 //RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n");
4536 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_DISABLED);
4546 // Enter the inactive power save mode. RF will be off
4547 // 2007.08.17, by shien chang.
4550 IPSEnter(struct net_device *dev)
4552 struct r8192_priv *priv = ieee80211_priv(dev);
4553 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4554 RT_RF_POWER_STATE rtState;
4556 if (pPSC->bInactivePs)
4558 rtState = priv->ieee80211->eRFPowerState;
4560 // Added by Bruce, 2007-12-25.
4561 // Do not enter IPS in the following conditions:
4562 // (1) RF is already OFF or Sleep
4563 // (2) bSwRfProcessing (indicates the IPS is still under going)
4564 // (3) Connectted (only disconnected can trigger IPS)
4565 // (4) IBSS (send Beacon)
4566 // (5) AP mode (send Beacon)
4568 if (rtState == eRfOn && !pPSC->bSwRfProcessing
4569 && (priv->ieee80211->state != IEEE80211_LINKED) )
4571 RT_TRACE(COMP_RF,"IPSEnter(): Turn off RF.\n");
4572 //printk("IPSEnter(): Turn off RF.\n");
4573 pPSC->eInactivePowerState = eRfOff;
4574 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4575 InactivePsWorkItemCallback(dev);
4582 // Leave the inactive power save mode, RF will be on.
4583 // 2007.08.17, by shien chang.
4586 IPSLeave(struct net_device *dev)
4588 struct r8192_priv *priv = ieee80211_priv(dev);
4589 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4590 RT_RF_POWER_STATE rtState;
4592 if (pPSC->bInactivePs)
4594 rtState = priv->ieee80211->eRFPowerState;
4595 if (rtState != eRfOn && !pPSC->bSwRfProcessing && priv->ieee80211->RfOffReason <= RF_CHANGE_BY_IPS)
4597 RT_TRACE(COMP_POWER, "IPSLeave(): Turn on RF.\n");
4598 //printk("IPSLeave(): Turn on RF.\n");
4599 pPSC->eInactivePowerState = eRfOn;
4600 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4601 InactivePsWorkItemCallback(dev);
4606 void IPSLeave_wq(void *data)
4608 struct ieee80211_device *ieee = container_of(data,struct ieee80211_device,ips_leave_wq);
4609 struct net_device *dev = ieee->dev;
4611 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4612 down(&priv->ieee80211->ips_sem);
4614 up(&priv->ieee80211->ips_sem);
4617 void ieee80211_ips_leave_wq(struct net_device *dev)
4619 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4620 RT_RF_POWER_STATE rtState;
4621 rtState = priv->ieee80211->eRFPowerState;
4623 if(priv->ieee80211->PowerSaveControl.bInactivePs){
4624 if(rtState == eRfOff){
4625 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
4627 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
4631 printk("=========>%s(): IPSLeave\n",__FUNCTION__);
4632 queue_work(priv->ieee80211->wq,&priv->ieee80211->ips_leave_wq);
4637 //added by amy 090331 end
4638 void ieee80211_ips_leave(struct net_device *dev)
4640 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4641 down(&priv->ieee80211->ips_sem);
4643 up(&priv->ieee80211->ips_sem);
4647 static void rtl819x_update_rxcounts(
4648 struct r8192_priv *priv,
4657 *TotalRxDataNum = 0;
4659 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4660 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4661 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4662 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4663 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4664 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4669 void rtl819x_watchdog_wqcallback(struct work_struct *work)
4671 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4672 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4673 struct net_device *dev = priv->ieee80211->dev;
4674 struct ieee80211_device* ieee = priv->ieee80211;
4675 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4676 static u8 check_reset_cnt=0;
4677 unsigned long flags;
4678 bool bBusyTraffic = false;
4679 static u8 last_time = 0;
4680 bool bEnterPS = false;
4682 if((!priv->up) || (priv->bHwRadioOff == true))
4687 hal_dm_watchdog(dev);
4689 // printk("watch_dog ENABLE_IPS\n");
4690 if(ieee->actscanning == false){
4691 //printk("%d,%d,%d,%d\n", ieee->eRFPowerState, ieee->is_set_key, ieee->proto_stoppping, ieee->wx_set_enc);
4692 if((ieee->iw_mode == IW_MODE_INFRA) && (ieee->state == IEEE80211_NOLINK) &&\
4693 (ieee->eRFPowerState == eRfOn)&&!ieee->is_set_key &&\
4694 (!ieee->proto_stoppping) && !ieee->wx_set_enc){
4695 if(ieee->PowerSaveControl.ReturnPoint == IPS_CALLBACK_NONE){
4696 //printk("====================>haha:IPSEnter()\n");
4698 //ieee80211_stop_scan(priv->ieee80211);
4703 {//to get busy traffic condition
4704 if(ieee->state == IEEE80211_LINKED)
4706 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 100 ||
4707 ieee->LinkDetectInfo.NumTxOkInPeriod> 100 ) {
4708 bBusyTraffic = true;
4712 //added by amy for Leisure PS
4713 if( ((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod + ieee->LinkDetectInfo.NumTxOkInPeriod) > 8 ) ||
4714 (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2) )
4716 //printk("ieee->LinkDetectInfo.NumRxUnicastOkInPeriod is %d,ieee->LinkDetectInfo.NumTxOkInPeriod is %d\n",
4717 // ieee->LinkDetectInfo.NumRxUnicastOkInPeriod,ieee->LinkDetectInfo.NumTxOkInPeriod);
4725 //printk("***bEnterPS = %d\n", bEnterPS);
4726 // LeisurePS only work in infra mode.
4729 LeisurePSEnter(dev);
4733 LeisurePSLeave(dev);
4741 //RT_TRACE(COMP_LPS,"====>no link LPS leave\n");
4742 LeisurePSLeave(dev);
4746 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4747 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4748 ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
4749 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4753 //added by amy for AP roaming
4756 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4758 u32 TotalRxBcnNum = 0;
4759 u32 TotalRxDataNum = 0;
4761 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4762 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4764 if( ieee->eRFPowerState == eRfOff)
4765 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4766 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4767 // Dot11d_Reset(dev);
4768 ieee->state = IEEE80211_ASSOCIATING;
4769 notify_wx_assoc_event(priv->ieee80211);
4770 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4771 ieee->is_roaming = true;
4772 ieee->is_set_key = false;
4773 ieee->link_change(dev);
4774 queue_work(ieee->wq, &ieee->associate_procedure_wq);
4777 ieee->LinkDetectInfo.NumRecvBcnInPeriod=0;
4778 ieee->LinkDetectInfo.NumRecvDataInPeriod=0;
4781 //check if reset the driver
4782 spin_lock_irqsave(&priv->tx_lock,flags);
4783 if(check_reset_cnt++ >= 3 && !ieee->is_roaming && (last_time != 1))
4785 ResetType = rtl819x_ifcheck_resetornot(dev);
4786 check_reset_cnt = 3;
4787 //DbgPrint("Start to check silent reset\n");
4789 spin_unlock_irqrestore(&priv->tx_lock,flags);
4790 if(!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_NORMAL)
4792 priv->ResetProgress = RESET_TYPE_NORMAL;
4793 RT_TRACE(COMP_RESET,"%s(): NOMAL RESET\n",__FUNCTION__);
4796 /* disable silent reset temply 2008.9.11*/
4798 if( ((priv->force_reset) || (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT))) // This is control by OID set in Pomelo
4801 rtl819x_ifsilentreset(dev);
4806 priv->force_reset = false;
4807 priv->bForcedSilentReset = false;
4808 priv->bResetInProgress = false;
4809 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4813 void watch_dog_timer_callback(unsigned long data)
4815 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4816 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq,0);
4817 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4820 int _rtl8192_up(struct net_device *dev)
4822 struct r8192_priv *priv = ieee80211_priv(dev);
4824 RT_STATUS init_status = RT_STATUS_SUCCESS;
4826 priv->ieee80211->ieee_up=1;
4827 priv->bdisable_nic = false; //YJ,add,091111
4828 RT_TRACE(COMP_INIT, "Bringing up iface");
4830 init_status = rtl8192_adapter_start(dev);
4831 if(init_status != RT_STATUS_SUCCESS)
4833 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
4836 RT_TRACE(COMP_INIT, "start adapter finished\n");
4838 if(priv->ieee80211->eRFPowerState!=eRfOn)
4839 MgntActSet_RF_State(dev, eRfOn, priv->ieee80211->RfOffReason);
4841 if(priv->ieee80211->state != IEEE80211_LINKED)
4842 ieee80211_softmac_start_protocol(priv->ieee80211);
4843 ieee80211_reset_queue(priv->ieee80211);
4844 watch_dog_timer_callback((unsigned long) dev);
4845 if(!netif_queue_stopped(dev))
4846 netif_start_queue(dev);
4848 netif_wake_queue(dev);
4854 static int rtl8192_open(struct net_device *dev)
4856 struct r8192_priv *priv = ieee80211_priv(dev);
4859 down(&priv->wx_sem);
4860 ret = rtl8192_up(dev);
4867 int rtl8192_up(struct net_device *dev)
4869 struct r8192_priv *priv = ieee80211_priv(dev);
4871 if (priv->up == 1) return -1;
4873 return _rtl8192_up(dev);
4877 static int rtl8192_close(struct net_device *dev)
4879 struct r8192_priv *priv = ieee80211_priv(dev);
4882 down(&priv->wx_sem);
4884 ret = rtl8192_down(dev);
4892 int rtl8192_down(struct net_device *dev)
4894 struct r8192_priv *priv = ieee80211_priv(dev);
4900 if (priv->up == 0) return -1;
4903 //LZM for PS-Poll AID issue. 090429
4904 if(priv->ieee80211->state == IEEE80211_LINKED)
4905 LeisurePSLeave(dev);
4909 priv->ieee80211->ieee_up = 0;
4910 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4912 if (!netif_queue_stopped(dev))
4913 netif_stop_queue(dev);
4915 rtl8192_irq_disable(dev);
4917 if(!priv->ieee80211->bSupportRemoteWakeUp) {
4918 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_INIT);
4919 // 2006.11.30. System reset bit
4920 ulRegRead = read_nic_dword(dev, CPU_GEN);
4921 ulRegRead|=CPU_GEN_SYSTEM_RESET;
4922 write_nic_dword(dev, CPU_GEN, ulRegRead);
4924 //2008.06.03 for WOL
4925 write_nic_dword(dev, WFCRC0, 0xffffffff);
4926 write_nic_dword(dev, WFCRC1, 0xffffffff);
4927 write_nic_dword(dev, WFCRC2, 0xffffffff);
4930 ucRegRead = read_nic_byte(dev, GPO);
4932 write_nic_byte(dev, GPO, ucRegRead);
4934 //Write PMR register
4935 write_nic_byte(dev, PMR, 0x5);
4936 //Disable tx, enanble rx
4937 write_nic_byte(dev, MacBlkCtrl, 0xa);
4940 // flush_scheduled_work();
4941 rtl8192_cancel_deferred_work(priv);
4943 del_timer_sync(&priv->watch_dog_timer);
4945 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4947 rtl8192_halt_adapter(dev,false);
4948 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4950 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4956 void rtl8192_commit(struct net_device *dev)
4958 struct r8192_priv *priv = ieee80211_priv(dev);
4960 if (priv->up == 0) return ;
4963 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4965 rtl8192_irq_disable(dev);
4966 rtl8192_halt_adapter(dev,true);
4970 void rtl8192_restart(struct work_struct *work)
4972 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4973 struct net_device *dev = priv->ieee80211->dev;
4975 down(&priv->wx_sem);
4977 rtl8192_commit(dev);
4982 static void r8192_set_multicast(struct net_device *dev)
4984 struct r8192_priv *priv = ieee80211_priv(dev);
4987 //down(&priv->wx_sem);
4991 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4993 if (promisc != priv->promisc) {
4995 // rtl8192_commit(dev);
4998 priv->promisc = promisc;
5000 //schedule_work(&priv->reset_wq);
5001 //up(&priv->wx_sem);
5005 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
5007 struct r8192_priv *priv = ieee80211_priv(dev);
5008 struct sockaddr *addr = mac;
5010 down(&priv->wx_sem);
5012 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
5014 schedule_work(&priv->reset_wq);
5020 /* based on ipw2200 driver */
5021 static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
5023 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5024 struct iwreq *wrq = (struct iwreq *)rq;
5026 struct ieee80211_device *ieee = priv->ieee80211;
5028 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
5029 struct iw_point *p = &wrq->u.data;
5030 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
5032 down(&priv->wx_sem);
5035 if (p->length < sizeof(struct ieee_param) || !p->pointer){
5040 ipw = (struct ieee_param *)kmalloc(p->length, GFP_KERNEL);
5045 if (copy_from_user(ipw, p->pointer, p->length)) {
5052 case RTL_IOCTL_WPA_SUPPLICANT:
5053 //parse here for HW security
5054 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
5056 if (ipw->u.crypt.set_tx)
5058 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
5059 ieee->pairwise_key_type = KEY_TYPE_CCMP;
5060 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
5061 ieee->pairwise_key_type = KEY_TYPE_TKIP;
5062 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
5064 if (ipw->u.crypt.key_len == 13)
5065 ieee->pairwise_key_type = KEY_TYPE_WEP104;
5066 else if (ipw->u.crypt.key_len == 5)
5067 ieee->pairwise_key_type = KEY_TYPE_WEP40;
5070 ieee->pairwise_key_type = KEY_TYPE_NA;
5072 if (ieee->pairwise_key_type)
5074 memcpy((u8*)key, ipw->u.crypt.key, 16);
5075 EnableHWSecurityConfig8192(dev);
5076 //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!
5078 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
5079 if (ieee->auth_mode != 2) //LEAP WEP will never set this.
5080 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
5082 if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) && ieee->pHTInfo->bCurrentHTSupport){
5083 write_nic_byte(dev, 0x173, 1); //fix aes bug
5087 else //if (ipw->u.crypt.idx) //group key use idx > 0
5089 memcpy((u8*)key, ipw->u.crypt.key, 16);
5090 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
5091 ieee->group_key_type= KEY_TYPE_CCMP;
5092 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
5093 ieee->group_key_type = KEY_TYPE_TKIP;
5094 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
5096 if (ipw->u.crypt.key_len == 13)
5097 ieee->group_key_type = KEY_TYPE_WEP104;
5098 else if (ipw->u.crypt.key_len == 5)
5099 ieee->group_key_type = KEY_TYPE_WEP40;
5102 ieee->group_key_type = KEY_TYPE_NA;
5104 if (ieee->group_key_type)
5108 ipw->u.crypt.idx, //KeyIndex
5109 ieee->group_key_type, //KeyType
5110 broadcast_addr, //MacAddr
5120 printk("@@ wrq->u pointer = ");
5121 for(i=0;i<wrq->u.data.length;i++){
5122 if(i%10==0) printk("\n");
5123 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
5127 #endif /*JOHN_DEBUG*/
5128 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
5143 static u8 HwRateToMRate90(bool bIsHT, u8 rate)
5149 case DESC90_RATE1M: ret_rate = MGN_1M; break;
5150 case DESC90_RATE2M: ret_rate = MGN_2M; break;
5151 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
5152 case DESC90_RATE11M: ret_rate = MGN_11M; break;
5153 case DESC90_RATE6M: ret_rate = MGN_6M; break;
5154 case DESC90_RATE9M: ret_rate = MGN_9M; break;
5155 case DESC90_RATE12M: ret_rate = MGN_12M; break;
5156 case DESC90_RATE18M: ret_rate = MGN_18M; break;
5157 case DESC90_RATE24M: ret_rate = MGN_24M; break;
5158 case DESC90_RATE36M: ret_rate = MGN_36M; break;
5159 case DESC90_RATE48M: ret_rate = MGN_48M; break;
5160 case DESC90_RATE54M: ret_rate = MGN_54M; break;
5163 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
5169 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
5170 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
5171 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
5172 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
5173 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
5174 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
5175 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
5176 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
5177 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
5178 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
5179 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
5180 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
5181 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
5182 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
5183 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
5184 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
5185 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
5188 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
5197 * Function: UpdateRxPktTimeStamp
5198 * Overview: Recored down the TSF time stamp when receiving a packet
5206 * (pRfd->Status.TimeStampHigh is updated)
5207 * (pRfd->Status.TimeStampLow is updated)
5211 static void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
5213 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5215 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
5216 stats->mac_time[0] = priv->LastRxDescTSFLow;
5217 stats->mac_time[1] = priv->LastRxDescTSFHigh;
5219 priv->LastRxDescTSFLow = stats->mac_time[0];
5220 priv->LastRxDescTSFHigh = stats->mac_time[1];
5224 static long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
5226 long signal_power; // in dBm.
5228 // Translate to dBm (x=0.5y-95).
5229 signal_power = (long)((signal_strength_index + 1) >> 1);
5232 return signal_power;
5237 // Update Rx signal related information in the packet reeived
5238 // to RxStats. User application can query RxStats to realize
5239 // current Rx signal status.
5242 // In normal operation, user only care about the information of the BSS
5243 // and we shall invoke this function if the packet received is from the BSS.
5246 rtl819x_update_rxsignalstatistics8190pci(
5247 struct r8192_priv * priv,
5248 struct ieee80211_rx_stats * pprevious_stats
5253 //2 <ToDo> Update Rx Statistics (such as signal strength and signal quality).
5256 if(priv->stats.recv_signal_power == 0)
5257 priv->stats.recv_signal_power = pprevious_stats->RecvSignalPower;
5259 // To avoid the past result restricting the statistics sensitivity, weight the current power (5/6) to speed up the
5260 // reaction of smoothed Signal Power.
5261 if(pprevious_stats->RecvSignalPower > priv->stats.recv_signal_power)
5263 else if(pprevious_stats->RecvSignalPower < priv->stats.recv_signal_power)
5266 // We need more correct power of received packets and the "SignalStrength" of RxStats have been beautified or translated,
5267 // so we record the correct power in Dbm here. By Bruce, 2008-03-07.
5269 priv->stats.recv_signal_power = (priv->stats.recv_signal_power * 5 + pprevious_stats->RecvSignalPower + weighting) / 6;
5273 rtl8190_process_cck_rxpathsel(
5274 struct r8192_priv * priv,
5275 struct ieee80211_rx_stats * pprevious_stats
5278 #ifdef RTL8190P //Only 90P 2T4R need to check
5279 char last_cck_adc_pwdb[4]={0,0,0,0};
5281 //cosa add for Rx path selection
5282 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable)
5284 if(pprevious_stats->bIsCCK &&
5285 (pprevious_stats->bPacketToSelf ||pprevious_stats->bPacketBeacon))
5287 /* record the cck adc_pwdb to the sliding window. */
5288 if(priv->stats.cck_adc_pwdb.TotalNum++ >= PHY_RSSI_SLID_WIN_MAX)
5290 priv->stats.cck_adc_pwdb.TotalNum = PHY_RSSI_SLID_WIN_MAX;
5291 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5293 last_cck_adc_pwdb[i] = priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index];
5294 priv->stats.cck_adc_pwdb.TotalVal[i] -= last_cck_adc_pwdb[i];
5297 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5299 priv->stats.cck_adc_pwdb.TotalVal[i] += pprevious_stats->cck_adc_pwdb[i];
5300 priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index] = pprevious_stats->cck_adc_pwdb[i];
5302 priv->stats.cck_adc_pwdb.index++;
5303 if(priv->stats.cck_adc_pwdb.index >= PHY_RSSI_SLID_WIN_MAX)
5304 priv->stats.cck_adc_pwdb.index = 0;
5306 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5308 DM_RxPathSelTable.cck_pwdb_sta[i] = priv->stats.cck_adc_pwdb.TotalVal[i]/priv->stats.cck_adc_pwdb.TotalNum;
5311 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5313 if(pprevious_stats->cck_adc_pwdb[i] > (char)priv->undecorated_smoothed_cck_adc_pwdb[i])
5315 priv->undecorated_smoothed_cck_adc_pwdb[i] =
5316 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
5317 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
5318 priv->undecorated_smoothed_cck_adc_pwdb[i] = priv->undecorated_smoothed_cck_adc_pwdb[i] + 1;
5322 priv->undecorated_smoothed_cck_adc_pwdb[i] =
5323 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
5324 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
5333 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
5334 be a local static. Otherwise, it may increase when we return from S3/S4. The
5335 value will be kept in memory or disk. We must delcare the value in adapter
5336 and it will be reinitialized when return from S3/S4. */
5337 static void rtl8192_process_phyinfo(struct r8192_priv * priv, u8* buffer,struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
5339 bool bcheck = false;
5341 u32 nspatial_stream, tmp_val;
5343 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
5344 static u32 slide_evm_index=0, slide_evm_statistics=0;
5345 static u32 last_rssi=0, last_evm=0;
5346 //cosa add for rx path selection
5347 // static long slide_cck_adc_pwdb_index=0, slide_cck_adc_pwdb_statistics=0;
5348 // static char last_cck_adc_pwdb[4]={0,0,0,0};
5349 //cosa add for beacon rssi smoothing
5350 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
5351 static u32 last_beacon_adc_pwdb=0;
5353 struct ieee80211_hdr_3addr *hdr;
5355 unsigned int frag,seq;
5356 hdr = (struct ieee80211_hdr_3addr *)buffer;
5357 sc = le16_to_cpu(hdr->seq_ctl);
5358 frag = WLAN_GET_SEQ_FRAG(sc);
5359 seq = WLAN_GET_SEQ_SEQ(sc);
5360 //cosa add 04292008 to record the sequence number
5361 pcurrent_stats->Seq_Num = seq;
5363 // Check whether we should take the previous packet into accounting
5365 if(!pprevious_stats->bIsAMPDU)
5367 // if previous packet is not aggregated packet
5371 //remve for that we don't use AMPDU to calculate PWDB,because the reported PWDB of some AP is fault.
5373 // if previous packet is aggregated packet, and current packet
5375 // (2) is the first packet of one AMPDU
5376 // that means the previous packet is the last one aggregated packet
5377 if( !pcurrent_stats->bIsAMPDU || pcurrent_stats->bFirstMPDU)
5382 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
5384 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
5385 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
5386 priv->stats.slide_rssi_total -= last_rssi;
5388 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
5390 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
5391 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
5392 slide_rssi_index = 0;
5394 // <1> Showed on UI for user, in dbm
5395 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
5396 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
5397 pcurrent_stats->rssi = priv->stats.signal_strength;
5399 // If the previous packet does not match the criteria, neglect it
5401 if(!pprevious_stats->bPacketMatchBSSID)
5403 if(!pprevious_stats->bToSelfBA)
5410 rtl8190_process_cck_rxpathsel(priv,pprevious_stats);
5415 priv->stats.num_process_phyinfo++;
5417 /* record the general signal strength to the sliding window. */
5418 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
5420 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
5421 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
5422 priv->stats.slide_rssi_total -= last_rssi;
5424 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
5426 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
5427 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
5428 slide_rssi_index = 0;
5430 // <1> Showed on UI for user, in dbm
5431 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
5432 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
5435 // <2> Showed on UI for engineering
5436 // hardware does not provide rssi information for each rf path in CCK
5437 if(!pprevious_stats->bIsCCK && pprevious_stats->bPacketToSelf)
5439 for (rfpath = RF90_PATH_A; rfpath < RF90_PATH_C; rfpath++)
5441 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
5443 RT_TRACE(COMP_DBG,"Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d \n" ,pprevious_stats->RxMIMOSignalStrength[rfpath] );
5444 //Fixed by Jacken 2008-03-20
5445 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
5447 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
5448 //DbgPrint("MIMO RSSI initialize \n");
5450 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
5452 priv->stats.rx_rssi_percentage[rfpath] =
5453 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5454 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5455 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
5459 priv->stats.rx_rssi_percentage[rfpath] =
5460 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5461 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5463 RT_TRACE(COMP_DBG,"Jacken -> priv->RxStats.RxRSSIPercentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
5471 //cosa add for beacon rssi smoothing by average.
5472 if(pprevious_stats->bPacketBeacon)
5474 /* record the beacon pwdb to the sliding window. */
5475 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5477 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
5478 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
5479 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
5480 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
5481 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
5483 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
5484 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
5485 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
5486 slide_beacon_adc_pwdb_index++;
5487 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5488 slide_beacon_adc_pwdb_index = 0;
5489 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
5490 if(pprevious_stats->RxPWDBAll >= 3)
5491 pprevious_stats->RxPWDBAll -= 3;
5494 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
5495 pprevious_stats->bIsCCK? "CCK": "OFDM",
5496 pprevious_stats->RxPWDBAll);
5498 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5500 if(priv->undecorated_smoothed_pwdb < 0) // initialize
5502 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
5503 //DbgPrint("First pwdb initialize \n");
5506 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
5508 priv->undecorated_smoothed_pwdb =
5509 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5510 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5511 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
5515 priv->undecorated_smoothed_pwdb =
5516 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5517 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5520 //Fixed by Jacken 2008-03-20
5521 if(pPreviousRfd->Status.RxPWDBAll > (u32)pHalData->UndecoratedSmoothedPWDB)
5523 pHalData->UndecoratedSmoothedPWDB =
5524 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5525 pHalData->UndecoratedSmoothedPWDB = pHalData->UndecoratedSmoothedPWDB + 1;
5529 pHalData->UndecoratedSmoothedPWDB =
5530 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5533 rtl819x_update_rxsignalstatistics8190pci(priv,pprevious_stats);
5539 /* record the general EVM to the sliding window. */
5540 if(pprevious_stats->SignalQuality == 0)
5545 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
5546 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
5547 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
5548 last_evm = priv->stats.slide_evm[slide_evm_index];
5549 priv->stats.slide_evm_total -= last_evm;
5552 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
5554 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
5555 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
5556 slide_evm_index = 0;
5558 // <1> Showed on UI for user, in percentage.
5559 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
5560 priv->stats.signal_quality = tmp_val;
5561 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
5562 priv->stats.last_signal_strength_inpercent = tmp_val;
5565 // <2> Showed on UI for engineering
5566 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5568 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
5570 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
5572 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
5574 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
5576 priv->stats.rx_evm_percentage[nspatial_stream] =
5577 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
5578 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
5586 /*-----------------------------------------------------------------------------
5587 * Function: rtl819x_query_rxpwrpercentage()
5591 * Input: char antpower
5595 * Return: 0-100 percentage
5599 * 05/26/2008 amy Create Version 0 porting from windows code.
5601 *---------------------------------------------------------------------------*/
5602 static u8 rtl819x_query_rxpwrpercentage(
5606 if ((antpower <= -100) || (antpower >= 20))
5610 else if (antpower >= 0)
5616 return (100+antpower);
5619 } /* QueryRxPwrPercentage */
5622 rtl819x_evm_dbtopercentage(
5634 ret_val = 0 - ret_val;
5643 // We want good-looking for signal strength/quality
5644 // 2007/7/19 01:09, by cosa.
5646 static long rtl819x_signal_scale_mapping(long currsig)
5650 // Step 1. Scale mapping.
5651 if(currsig >= 61 && currsig <= 100)
5653 retsig = 90 + ((currsig - 60) / 4);
5655 else if(currsig >= 41 && currsig <= 60)
5657 retsig = 78 + ((currsig - 40) / 2);
5659 else if(currsig >= 31 && currsig <= 40)
5661 retsig = 66 + (currsig - 30);
5663 else if(currsig >= 21 && currsig <= 30)
5665 retsig = 54 + (currsig - 20);
5667 else if(currsig >= 5 && currsig <= 20)
5669 retsig = 42 + (((currsig - 5) * 2) / 3);
5671 else if(currsig == 4)
5675 else if(currsig == 3)
5679 else if(currsig == 2)
5683 else if(currsig == 1)
5695 static void rtl8192_query_rxphystatus(
5696 struct r8192_priv * priv,
5697 struct ieee80211_rx_stats * pstats,
5698 prx_desc_819x_pci pdesc,
5699 prx_fwinfo_819x_pci pdrvinfo,
5700 struct ieee80211_rx_stats * precord_stats,
5701 bool bpacket_match_bssid,
5702 bool bpacket_toself,
5707 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
5708 phy_sts_ofdm_819xpci_t* pofdm_buf;
5709 phy_sts_cck_819xpci_t * pcck_buf;
5710 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
5712 u8 i,max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
5713 char rx_pwr[4], rx_pwr_all=0;
5714 //long rx_avg_pwr = 0;
5715 char rx_snrX, rx_evmX;
5717 u32 RSSI, total_rssi=0;//, total_evm=0;
5718 // long signal_strength_index = 0;
5722 /* 2007/07/04 MH For OFDM RSSI. For high power or not. */
5723 static u8 check_reg824 = 0;
5724 static u32 reg824_bit9 = 0;
5726 priv->stats.numqry_phystatus++;
5728 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
5730 // Record it for next packet processing
5731 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
5732 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
5733 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
5734 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
5735 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
5736 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
5737 /*2007.08.30 requested by SD3 Jerry */
5738 if(check_reg824 == 0)
5740 reg824_bit9 = rtl8192_QueryBBReg(priv->ieee80211->dev, rFPGA0_XA_HSSIParameter2, 0x200);
5745 prxpkt = (u8*)pdrvinfo;
5747 /* Move pointer to the 16th bytes. Phy status start address. */
5748 prxpkt += sizeof(rx_fwinfo_819x_pci);
5750 /* Initial the cck and ofdm buffer pointer */
5751 pcck_buf = (phy_sts_cck_819xpci_t *)prxpkt;
5752 pofdm_buf = (phy_sts_ofdm_819xpci_t *)prxpkt;
5754 pstats->RxMIMOSignalQuality[0] = -1;
5755 pstats->RxMIMOSignalQuality[1] = -1;
5756 precord_stats->RxMIMOSignalQuality[0] = -1;
5757 precord_stats->RxMIMOSignalQuality[1] = -1;
5762 // (1)Hardware does not provide RSSI for CCK
5766 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5768 u8 report;//, cck_agc_rpt;
5771 char cck_adc_pwdb[4];
5773 priv->stats.numqry_phystatusCCK++;
5775 #ifdef RTL8190P //Only 90P 2T4R need to check
5776 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable && bpacket_match_bssid)
5778 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5780 tmp_pwdb = pcck_buf->adc_pwdb_X[i];
5781 cck_adc_pwdb[i] = (char)tmp_pwdb;
5782 cck_adc_pwdb[i] /= 2;
5783 pstats->cck_adc_pwdb[i] = precord_stats->cck_adc_pwdb[i] = cck_adc_pwdb[i];
5784 //DbgPrint("RF-%d tmp_pwdb = 0x%x, cck_adc_pwdb = %d", i, tmp_pwdb, cck_adc_pwdb[i]);
5791 report = pcck_buf->cck_agc_rpt & 0xc0;
5795 //Fixed by Jacken from Bryant 2008-03-20
5796 //Original value is -38 , -26 , -14 , -2
5797 //Fixed value is -35 , -23 , -11 , 6
5799 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
5802 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
5805 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
5808 rx_pwr_all = 8 - (pcck_buf->cck_agc_rpt & 0x3e);
5814 report = pcck_buf->cck_agc_rpt & 0x60;
5819 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5822 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
5825 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5828 rx_pwr_all = -8 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5833 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5834 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5835 pstats->RecvSignalPower = rx_pwr_all;
5838 // (3) Get Signal Quality (EVM)
5840 if(bpacket_match_bssid)
5844 if(pstats->RxPWDBAll > 40)
5849 sq = pcck_buf->sq_rpt;
5851 if(pcck_buf->sq_rpt > 64)
5853 else if (pcck_buf->sq_rpt < 20)
5856 sq = ((64-sq) * 100) / 44;
5858 pstats->SignalQuality = precord_stats->SignalQuality = sq;
5859 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5860 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5865 priv->stats.numqry_phystatusHT++;
5867 // (1)Get RSSI for HT rate
5869 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5871 // 2008/01/30 MH we will judge RF RX path now.
5872 if (priv->brfpath_rxenable[i])
5877 //Fixed by Jacken from Bryant 2008-03-20
5878 //Original value is 106
5879 #ifdef RTL8190P //Modify by Jacken 2008/03/31
5880 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5882 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 110;
5885 //Get Rx snr value in DB
5886 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5887 rx_snrX = (char)(tmp_rxsnr);
5889 priv->stats.rxSNRdB[i] = (long)rx_snrX;
5891 /* Translate DBM to percentage. */
5892 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5893 if (priv->brfpath_rxenable[i])
5896 /* Record Signal Strength for next packet */
5897 if(bpacket_match_bssid)
5899 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5900 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5906 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5908 //Fixed by Jacken from Bryant 2008-03-20
5909 //Original value is 106
5910 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5911 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5913 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5914 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5915 pstats->RecvSignalPower = rx_pwr_all;
5917 // (3)EVM of HT rate
5919 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5920 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5921 max_spatial_stream = 2; //both spatial stream make sense
5923 max_spatial_stream = 1; //only spatial stream 1 makes sense
5925 for(i=0; i<max_spatial_stream; i++)
5927 tmp_rxevm = pofdm_buf->rxevm_X[i];
5928 rx_evmX = (char)(tmp_rxevm);
5930 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5931 // fill most significant bit to "zero" when doing shifting operation which may change a negative
5932 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5935 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5937 EVM = SignalScaleMapping(EVM);//make it good looking, from 0~100
5939 if(bpacket_match_bssid)
5941 if(i==0) // Fill value in RFD, Get the first spatial stream only
5942 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5943 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5948 /* record rx statistics for debug */
5949 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5950 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5951 if(pdrvinfo->BW) //40M channel
5952 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5954 priv->stats.received_bwtype[0]++;
5957 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5958 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5961 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5966 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u1Byte)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u1Byte)(total_rssi/=RF90_PATH_MAX);
5967 // We can judge RX path number now.
5969 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5971 } /* QueryRxPhyStatus8190Pci */
5974 rtl8192_record_rxdesc_forlateruse(
5975 struct ieee80211_rx_stats * psrc_stats,
5976 struct ieee80211_rx_stats * ptarget_stats
5979 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5980 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5981 //ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5986 static void TranslateRxSignalStuff819xpci(struct net_device *dev,
5987 struct sk_buff *skb,
5988 struct ieee80211_rx_stats * pstats,
5989 prx_desc_819x_pci pdesc,
5990 prx_fwinfo_819x_pci pdrvinfo)
5992 // TODO: We must only check packet for current MAC address. Not finish
5993 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5994 bool bpacket_match_bssid, bpacket_toself;
5995 bool bPacketBeacon=false, bToSelfBA=false;
5996 static struct ieee80211_rx_stats previous_stats;
5997 struct ieee80211_hdr_3addr *hdr;
6000 // Get Signal Quality for only RX data queue (but not command queue)
6005 /* Get MAC frame start address. */
6006 tmp_buf = skb->data;
6008 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
6009 fc = le16_to_cpu(hdr->frame_ctl);
6010 type = WLAN_FC_GET_TYPE(fc);
6011 praddr = hdr->addr1;
6013 /* Check if the received packet is acceptabe. */
6014 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
6015 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
6016 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
6017 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
6019 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
6021 bPacketBeacon = true;
6022 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
6024 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
6026 if((eqMacAddr(praddr,dev->dev_addr)))
6028 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
6032 if(bpacket_match_bssid)
6034 priv->stats.numpacket_matchbssid++;
6037 priv->stats.numpacket_toself++;
6040 // Process PHY information for previous packet (RSSI/PWDB/EVM)
6042 // Because phy information is contained in the last packet of AMPDU only, so driver
6043 // should process phy information of previous packet
6044 rtl8192_process_phyinfo(priv, tmp_buf,&previous_stats, pstats);
6045 rtl8192_query_rxphystatus(priv, pstats, pdesc, pdrvinfo, &previous_stats, bpacket_match_bssid,
6046 bpacket_toself ,bPacketBeacon, bToSelfBA);
6047 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
6052 static void rtl8192_tx_resume(struct net_device *dev)
6054 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6055 struct ieee80211_device *ieee = priv->ieee80211;
6056 struct sk_buff *skb;
6059 for(queue_index = BK_QUEUE; queue_index < TXCMD_QUEUE;queue_index++) {
6060 while((!skb_queue_empty(&ieee->skb_waitQ[queue_index]))&&
6061 (priv->ieee80211->check_nic_enough_desc(dev,queue_index) > 0)) {
6062 /* 1. dequeue the packet from the wait queue */
6063 skb = skb_dequeue(&ieee->skb_waitQ[queue_index]);
6064 /* 2. tx the packet directly */
6065 ieee->softmac_data_hard_start_xmit(skb,dev,0/* rate useless now*/);
6067 if(queue_index!=MGNT_QUEUE) {
6068 ieee->stats.tx_packets++;
6069 ieee->stats.tx_bytes += skb->len;
6076 void rtl8192_irq_tx_tasklet(struct r8192_priv *priv)
6078 rtl8192_tx_resume(priv->ieee80211->dev);
6082 * Function: UpdateReceivedRateHistogramStatistics
6083 * Overview: Recored down the received data rate
6091 * (Adapter->RxStats.ReceivedRateHistogram[] is updated)
6095 static void UpdateReceivedRateHistogramStatistics8190(
6096 struct net_device *dev,
6097 struct ieee80211_rx_stats* pstats
6100 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6101 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
6103 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
6105 /* 2007/03/09 MH We will not update rate of packet from rx cmd queue. */
6107 if (pRfd->queue_id == CMPK_RX_QUEUE_ID)
6112 else if(pstats->bICV)
6115 if(pstats->bShortPreamble)
6116 preamble_guardinterval = 1;// short
6118 preamble_guardinterval = 0;// long
6120 switch(pstats->rate)
6125 case MGN_1M: rateIndex = 0; break;
6126 case MGN_2M: rateIndex = 1; break;
6127 case MGN_5_5M: rateIndex = 2; break;
6128 case MGN_11M: rateIndex = 3; break;
6132 case MGN_6M: rateIndex = 4; break;
6133 case MGN_9M: rateIndex = 5; break;
6134 case MGN_12M: rateIndex = 6; break;
6135 case MGN_18M: rateIndex = 7; break;
6136 case MGN_24M: rateIndex = 8; break;
6137 case MGN_36M: rateIndex = 9; break;
6138 case MGN_48M: rateIndex = 10; break;
6139 case MGN_54M: rateIndex = 11; break;
6141 // 11n High throughput rate
6143 case MGN_MCS0: rateIndex = 12; break;
6144 case MGN_MCS1: rateIndex = 13; break;
6145 case MGN_MCS2: rateIndex = 14; break;
6146 case MGN_MCS3: rateIndex = 15; break;
6147 case MGN_MCS4: rateIndex = 16; break;
6148 case MGN_MCS5: rateIndex = 17; break;
6149 case MGN_MCS6: rateIndex = 18; break;
6150 case MGN_MCS7: rateIndex = 19; break;
6151 case MGN_MCS8: rateIndex = 20; break;
6152 case MGN_MCS9: rateIndex = 21; break;
6153 case MGN_MCS10: rateIndex = 22; break;
6154 case MGN_MCS11: rateIndex = 23; break;
6155 case MGN_MCS12: rateIndex = 24; break;
6156 case MGN_MCS13: rateIndex = 25; break;
6157 case MGN_MCS14: rateIndex = 26; break;
6158 case MGN_MCS15: rateIndex = 27; break;
6159 default: rateIndex = 28; break;
6161 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
6162 priv->stats.received_rate_histogram[0][rateIndex]++; //total
6163 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
6166 static void rtl8192_rx(struct net_device *dev)
6168 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6169 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
6170 bool unicast_packet = false;
6171 struct ieee80211_rx_stats stats = {
6175 .freq = IEEE80211_24GHZ_BAND,
6177 unsigned int count = priv->rxringcount;
6179 stats.nic_type = NIC_8192E;
6182 rx_desc_819x_pci *pdesc = &priv->rx_ring[priv->rx_idx];//rx descriptor
6183 struct sk_buff *skb = priv->rx_buf[priv->rx_idx];//rx pkt
6186 /* wait data to be filled by hardware */
6189 stats.bICV = pdesc->ICV;
6190 stats.bCRC = pdesc->CRC32;
6191 stats.bHwError = pdesc->CRC32 | pdesc->ICV;
6193 stats.Length = pdesc->Length;
6194 if(stats.Length < 24)
6195 stats.bHwError |= 1;
6197 if(stats.bHwError) {
6198 stats.bShift = false;
6201 if (pdesc->Length <500)
6202 priv->stats.rxcrcerrmin++;
6203 else if (pdesc->Length >1000)
6204 priv->stats.rxcrcerrmax++;
6206 priv->stats.rxcrcerrmid++;
6210 prx_fwinfo_819x_pci pDrvInfo = NULL;
6211 struct sk_buff *new_skb = dev_alloc_skb(priv->rxbuffersize);
6213 if (unlikely(!new_skb)) {
6217 stats.RxDrvInfoSize = pdesc->RxDrvInfoSize;
6218 stats.RxBufShift = ((pdesc->Shift)&0x03);
6219 stats.Decrypted = !pdesc->SWDec;
6221 pci_dma_sync_single_for_cpu(priv->pdev,
6222 *((dma_addr_t *)skb->cb),
6224 PCI_DMA_FROMDEVICE);
6225 skb_put(skb, pdesc->Length);
6226 pDrvInfo = (rx_fwinfo_819x_pci *)(skb->data + stats.RxBufShift);
6227 skb_reserve(skb, stats.RxDrvInfoSize + stats.RxBufShift);
6229 stats.rate = HwRateToMRate90((bool)pDrvInfo->RxHT, (u8)pDrvInfo->RxRate);
6230 stats.bShortPreamble = pDrvInfo->SPLCP;
6232 /* it is debug only. It should be disabled in released driver.
6233 * 2007.1.11 by Emily
6235 UpdateReceivedRateHistogramStatistics8190(dev, &stats);
6237 stats.bIsAMPDU = (pDrvInfo->PartAggr==1);
6238 stats.bFirstMPDU = (pDrvInfo->PartAggr==1) && (pDrvInfo->FirstAGGR==1);
6240 stats.TimeStampLow = pDrvInfo->TSFL;
6241 stats.TimeStampHigh = read_nic_dword(dev, TSFR+4);
6243 UpdateRxPktTimeStamp8190(dev, &stats);
6246 // Get Total offset of MPDU Frame Body
6248 if((stats.RxBufShift + stats.RxDrvInfoSize) > 0)
6251 stats.RxIs40MHzPacket = pDrvInfo->BW;
6254 TranslateRxSignalStuff819xpci(dev,skb, &stats, pdesc, pDrvInfo);
6257 if(pDrvInfo->FirstAGGR==1 || pDrvInfo->PartAggr == 1)
6258 RT_TRACE(COMP_RXDESC, "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
6259 pDrvInfo->FirstAGGR, pDrvInfo->PartAggr);
6260 skb_trim(skb, skb->len - 4/*sCrcLng*/);
6261 /* rx packets statistics */
6262 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
6263 unicast_packet = false;
6265 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
6267 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
6270 /* unicast packet */
6271 unicast_packet = true;
6274 stats.packetlength = stats.Length-4;
6275 stats.fraglength = stats.packetlength;
6276 stats.fragoffset = 0;
6277 stats.ntotalfrag = 1;
6279 if(!ieee80211_rtl_rx(priv->ieee80211, skb, &stats)){
6280 dev_kfree_skb_any(skb);
6283 if(unicast_packet) {
6284 priv->stats.rxbytesunicast += skb->len;
6289 priv->rx_buf[priv->rx_idx] = skb;
6290 *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev, skb_tail_pointer(skb), priv->rxbuffersize, PCI_DMA_FROMDEVICE);
6295 pdesc->BufferAddress = cpu_to_le32(*((dma_addr_t *)skb->cb));
6297 pdesc->Length = priv->rxbuffersize;
6298 if (priv->rx_idx == priv->rxringcount-1)
6300 priv->rx_idx = (priv->rx_idx + 1) % priv->rxringcount;
6305 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
6307 rtl8192_rx(priv->ieee80211->dev);
6309 write_nic_dword(priv->ieee80211->dev, INTA_MASK,read_nic_dword(priv->ieee80211->dev, INTA_MASK) | IMR_RDU);
6312 static const struct net_device_ops rtl8192_netdev_ops = {
6313 .ndo_open = rtl8192_open,
6314 .ndo_stop = rtl8192_close,
6315 /* .ndo_get_stats = rtl8192_stats, */
6316 .ndo_tx_timeout = tx_timeout,
6317 .ndo_do_ioctl = rtl8192_ioctl,
6318 .ndo_set_multicast_list = r8192_set_multicast,
6319 .ndo_set_mac_address = r8192_set_mac_adr,
6320 .ndo_start_xmit = ieee80211_rtl_xmit,
6323 /****************************************************************************
6324 ---------------------------- PCI_STUFF---------------------------
6325 *****************************************************************************/
6327 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
6328 const struct pci_device_id *id)
6330 unsigned long ioaddr = 0;
6331 struct net_device *dev = NULL;
6332 struct r8192_priv *priv= NULL;
6335 #ifdef CONFIG_RTL8192_IO_MAP
6336 unsigned long pio_start, pio_len, pio_flags;
6338 unsigned long pmem_start, pmem_len, pmem_flags;
6339 #endif //end #ifdef RTL_IO_MAP
6341 RT_TRACE(COMP_INIT,"Configuring chip resources");
6343 if( pci_enable_device (pdev) ){
6344 RT_TRACE(COMP_ERR,"Failed to enable PCI device");
6348 pci_set_master(pdev);
6349 //pci_set_wmi(pdev);
6350 pci_set_dma_mask(pdev, 0xffffff00ULL);
6351 pci_set_consistent_dma_mask(pdev,0xffffff00ULL);
6352 dev = alloc_ieee80211(sizeof(struct r8192_priv));
6356 pci_set_drvdata(pdev, dev);
6357 SET_NETDEV_DEV(dev, &pdev->dev);
6358 priv = ieee80211_priv(dev);
6359 priv->ieee80211 = netdev_priv(dev);
6361 if((pdev->subsystem_vendor == PCI_VENDOR_ID_DLINK)&&(pdev->subsystem_device == 0x3304)){
6362 priv->ieee80211->bSupportRemoteWakeUp = 1;
6365 priv->ieee80211->bSupportRemoteWakeUp = 0;
6368 #ifdef CONFIG_RTL8192_IO_MAP
6370 pio_start = (unsigned long)pci_resource_start (pdev, 0);
6371 pio_len = (unsigned long)pci_resource_len (pdev, 0);
6372 pio_flags = (unsigned long)pci_resource_flags (pdev, 0);
6374 if (!(pio_flags & IORESOURCE_IO)) {
6375 RT_TRACE(COMP_ERR,"region #0 not a PIO resource, aborting");
6379 //DMESG("IO space @ 0x%08lx", pio_start );
6380 if( ! request_region( pio_start, pio_len, RTL819xE_MODULE_NAME ) ){
6381 RT_TRACE(COMP_ERR,"request_region failed!");
6386 dev->base_addr = ioaddr; // device I/O address
6390 pmem_start = pci_resource_start(pdev, 1);
6391 pmem_len = pci_resource_len(pdev, 1);
6392 pmem_flags = pci_resource_flags (pdev, 1);
6394 if (!(pmem_flags & IORESOURCE_MEM)) {
6395 RT_TRACE(COMP_ERR,"region #1 not a MMIO resource, aborting");
6399 //DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
6400 if( ! request_mem_region(pmem_start, pmem_len, RTL819xE_MODULE_NAME)) {
6401 RT_TRACE(COMP_ERR,"request_mem_region failed!");
6406 ioaddr = (unsigned long)ioremap_nocache( pmem_start, pmem_len);
6407 if( ioaddr == (unsigned long)NULL ){
6408 RT_TRACE(COMP_ERR,"ioremap failed!");
6409 // release_mem_region( pmem_start, pmem_len );
6413 dev->mem_start = ioaddr; // shared mem start
6414 dev->mem_end = ioaddr + pci_resource_len(pdev, 0); // shared mem end
6416 #endif //end #ifdef RTL_IO_MAP
6418 /* We disable the RETRY_TIMEOUT register (0x41) to keep
6419 * PCI Tx retries from interfering with C3 CPU state */
6420 pci_write_config_byte(pdev, 0x41, 0x00);
6423 pci_read_config_byte(pdev, 0x05, &unit);
6424 pci_write_config_byte(pdev, 0x05, unit & (~0x04));
6426 dev->irq = pdev->irq;
6429 dev->netdev_ops = &rtl8192_netdev_ops;
6431 dev->open = rtl8192_open;
6432 dev->stop = rtl8192_close;
6433 //dev->hard_start_xmit = rtl8192_8023_hard_start_xmit;
6434 dev->tx_timeout = tx_timeout;
6435 //dev->wireless_handlers = &r8192_wx_handlers_def;
6436 dev->do_ioctl = rtl8192_ioctl;
6437 dev->set_multicast_list = r8192_set_multicast;
6438 dev->set_mac_address = r8192_set_mac_adr;
6441 //DMESG("Oops: i'm coming\n");
6442 #if WIRELESS_EXT >= 12
6443 #if WIRELESS_EXT < 17
6444 dev->get_wireless_stats = r8192_get_wireless_stats;
6446 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
6448 //dev->get_wireless_stats = r8192_get_wireless_stats;
6449 dev->type=ARPHRD_ETHER;
6451 dev->watchdog_timeo = HZ*3; //modified by john, 0805
6453 if (dev_alloc_name(dev, ifname) < 0){
6454 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
6456 dev_alloc_name(dev, ifname);
6459 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
6460 if(rtl8192_init(dev)!=0){
6461 RT_TRACE(COMP_ERR, "Initialization failed");
6465 netif_carrier_off(dev);
6466 netif_stop_queue(dev);
6468 register_netdev(dev);
6469 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
6470 rtl8192_proc_init_one(dev);
6473 RT_TRACE(COMP_INIT, "Driver probe completed\n");
6478 #ifdef CONFIG_RTL8180_IO_MAP
6480 if( dev->base_addr != 0 ){
6482 release_region(dev->base_addr,
6483 pci_resource_len(pdev, 0) );
6486 if( dev->mem_start != (unsigned long)NULL ){
6487 iounmap( (void *)dev->mem_start );
6488 release_mem_region( pci_resource_start(pdev, 1),
6489 pci_resource_len(pdev, 1) );
6491 #endif //end #ifdef RTL_IO_MAP
6497 free_irq(dev->irq, dev);
6500 free_ieee80211(dev);
6503 pci_disable_device(pdev);
6505 DMESG("wlan driver load failed\n");
6506 pci_set_drvdata(pdev, NULL);
6511 /* detach all the work and timer structure declared or inititialized
6512 * in r8192_init function.
6514 void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
6516 /* call cancel_work_sync instead of cancel_delayed_work if and only if Linux_version_code
6517 * is or is newer than 2.6.20 and work structure is defined to be struct work_struct.
6518 * Otherwise call cancel_delayed_work is enough.
6519 * FIXME (2.6.20 should 2.6.22, work_struct should not cancel)
6521 cancel_delayed_work(&priv->watch_dog_wq);
6522 cancel_delayed_work(&priv->update_beacon_wq);
6523 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
6524 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
6526 cancel_delayed_work(&priv->gpio_change_rf_wq);
6528 cancel_work_sync(&priv->reset_wq);
6529 cancel_work_sync(&priv->qos_activate);
6530 //cancel_work_sync(&priv->SetBWModeWorkItem);
6531 //cancel_work_sync(&priv->SwChnlWorkItem);
6536 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev)
6538 struct net_device *dev = pci_get_drvdata(pdev);
6539 struct r8192_priv *priv ;
6543 unregister_netdev(dev);
6545 priv=ieee80211_priv(dev);
6547 rtl8192_proc_remove_one(dev);
6550 if (priv->pFirmware)
6552 vfree(priv->pFirmware);
6553 priv->pFirmware = NULL;
6555 // priv->rf_close(dev);
6556 // rtl8192_usb_deleteendpoints(dev);
6557 destroy_workqueue(priv->priv_wq);
6558 /* redundant with rtl8192_down */
6559 // rtl8192_irq_disable(dev);
6560 // rtl8192_reset(dev);
6564 /* free tx/rx rings */
6565 rtl8192_free_rx_ring(dev);
6566 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
6567 rtl8192_free_tx_ring(dev, i);
6572 printk("Freeing irq %d\n",dev->irq);
6573 free_irq(dev->irq, dev);
6580 // free_beacon_desc_ring(dev,priv->txbeaconcount);
6582 #ifdef CONFIG_RTL8180_IO_MAP
6584 if( dev->base_addr != 0 ){
6586 release_region(dev->base_addr,
6587 pci_resource_len(pdev, 0) );
6590 if( dev->mem_start != (unsigned long)NULL ){
6591 iounmap( (void *)dev->mem_start );
6592 release_mem_region( pci_resource_start(pdev, 1),
6593 pci_resource_len(pdev, 1) );
6595 #endif /*end #ifdef RTL_IO_MAP*/
6596 free_ieee80211(dev);
6600 pci_disable_device(pdev);
6601 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
6604 extern int ieee80211_rtl_init(void);
6605 extern void ieee80211_rtl_exit(void);
6607 static int __init rtl8192_pci_module_init(void)
6611 retval = ieee80211_rtl_init();
6615 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
6616 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
6617 RT_TRACE(COMP_INIT, "Initializing module");
6618 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
6619 rtl8192_proc_module_init();
6620 if(0!=pci_register_driver(&rtl8192_pci_driver))
6622 DMESG("No device found");
6623 /*pci_unregister_driver (&rtl8192_pci_driver);*/
6630 static void __exit rtl8192_pci_module_exit(void)
6632 pci_unregister_driver(&rtl8192_pci_driver);
6634 RT_TRACE(COMP_DOWN, "Exiting");
6635 rtl8192_proc_module_remove();
6636 ieee80211_rtl_exit();
6639 //warning message WB
6640 irqreturn_t rtl8192_interrupt(int irq, void *netdev)
6642 struct net_device *dev = (struct net_device *) netdev;
6643 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6644 unsigned long flags;
6646 /* We should return IRQ_NONE, but for now let me keep this */
6647 if(priv->irq_enabled == 0){
6651 spin_lock_irqsave(&priv->irq_th_lock,flags);
6655 inta = read_nic_dword(dev, ISR);// & priv->IntrMask;
6656 write_nic_dword(dev,ISR,inta); // reset int situation
6658 priv->stats.shints++;
6659 //DMESG("Enter interrupt, ISR value = 0x%08x", inta);
6661 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6664 most probably we can safely return IRQ_NONE,
6665 but for now is better to avoid problems
6671 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6677 DMESG("NIC irq %x",inta);
6679 //priv->irqpending = inta;
6682 if(!netif_running(dev)) {
6683 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6687 if(inta & IMR_TIMEOUT0){
6688 // write_nic_dword(dev, TimerInt, 0);
6689 //DMESG("=================>waking up");
6690 // rtl8180_hw_wakeup(dev);
6693 if(inta & IMR_TBDOK){
6694 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6695 rtl8192_tx_isr(dev, BEACON_QUEUE);
6696 priv->stats.txbeaconokint++;
6699 if(inta & IMR_TBDER){
6700 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6701 rtl8192_tx_isr(dev, BEACON_QUEUE);
6702 priv->stats.txbeaconerr++;
6705 if(inta & IMR_MGNTDOK ) {
6706 RT_TRACE(COMP_INTR, "Manage ok interrupt!\n");
6707 priv->stats.txmanageokint++;
6708 rtl8192_tx_isr(dev,MGNT_QUEUE);
6712 if(inta & IMR_COMDOK)
6714 priv->stats.txcmdpktokint++;
6715 rtl8192_tx_isr(dev,TXCMD_QUEUE);
6720 DMESG("Frame arrived !");
6722 priv->stats.rxint++;
6723 tasklet_schedule(&priv->irq_rx_tasklet);
6726 if(inta & IMR_BcnInt) {
6727 RT_TRACE(COMP_INTR, "prepare beacon for interrupt!\n");
6728 tasklet_schedule(&priv->irq_prepare_beacon_tasklet);
6732 RT_TRACE(COMP_INTR, "rx descriptor unavailable!\n");
6733 priv->stats.rxrdu++;
6734 /* reset int situation */
6735 write_nic_dword(dev,INTA_MASK,read_nic_dword(dev, INTA_MASK) & ~IMR_RDU);
6736 tasklet_schedule(&priv->irq_rx_tasklet);
6739 if(inta & IMR_RXFOVW){
6740 RT_TRACE(COMP_INTR, "rx overflow !\n");
6741 priv->stats.rxoverflow++;
6742 tasklet_schedule(&priv->irq_rx_tasklet);
6745 if(inta & IMR_TXFOVW) priv->stats.txoverflow++;
6747 if(inta & IMR_BKDOK){
6748 RT_TRACE(COMP_INTR, "BK Tx OK interrupt!\n");
6749 priv->stats.txbkokint++;
6750 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6751 rtl8192_tx_isr(dev,BK_QUEUE);
6752 rtl8192_try_wake_queue(dev, BK_QUEUE);
6755 if(inta & IMR_BEDOK){
6756 RT_TRACE(COMP_INTR, "BE TX OK interrupt!\n");
6757 priv->stats.txbeokint++;
6758 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6759 rtl8192_tx_isr(dev,BE_QUEUE);
6760 rtl8192_try_wake_queue(dev, BE_QUEUE);
6763 if(inta & IMR_VIDOK){
6764 RT_TRACE(COMP_INTR, "VI TX OK interrupt!\n");
6765 priv->stats.txviokint++;
6766 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6767 rtl8192_tx_isr(dev,VI_QUEUE);
6768 rtl8192_try_wake_queue(dev, VI_QUEUE);
6771 if(inta & IMR_VODOK){
6772 priv->stats.txvookint++;
6773 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6774 rtl8192_tx_isr(dev,VO_QUEUE);
6775 rtl8192_try_wake_queue(dev, VO_QUEUE);
6778 force_pci_posting(dev);
6779 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6784 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
6787 unsigned long flags;
6789 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6791 spin_lock_irqsave(&priv->tx_lock,flags);
6792 enough_desc = check_nic_enough_desc(dev,pri);
6793 spin_unlock_irqrestore(&priv->tx_lock,flags);
6796 ieee80211_rtl_wake_queue(priv->ieee80211);
6801 void EnableHWSecurityConfig8192(struct net_device *dev)
6803 u8 SECR_value = 0x0;
6804 // struct ieee80211_device* ieee1 = container_of(&dev, struct ieee80211_device, dev);
6805 //printk("==>ieee1:%p, dev:%p\n", ieee1, dev);
6806 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6807 struct ieee80211_device* ieee = priv->ieee80211;
6808 //printk("==>ieee:%p, dev:%p\n", ieee, dev);
6809 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
6811 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
6813 SECR_value |= SCR_RxUseDK;
6814 SECR_value |= SCR_TxUseDK;
6816 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
6818 SECR_value |= SCR_RxUseDK;
6819 SECR_value |= SCR_TxUseDK;
6824 //add HWSec active enable here.
6825 //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
6826 ieee->hwsec_active = 1;
6828 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
6830 ieee->hwsec_active = 0;
6831 SECR_value &= ~SCR_RxDecEnable;
6834 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__, \
6835 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
6837 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
6841 #define TOTAL_CAM_ENTRY 32
6842 //#define CAM_CONTENT_COUNT 8
6843 void setKey( struct net_device *dev,
6851 u32 TargetCommand = 0;
6852 u32 TargetContent = 0;
6856 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6857 RT_RF_POWER_STATE rtState;
6858 rtState = priv->ieee80211->eRFPowerState;
6859 if(priv->ieee80211->PowerSaveControl.bInactivePs){
6860 if(rtState == eRfOff){
6861 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
6863 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
6864 //up(&priv->wx_sem);
6868 down(&priv->ieee80211->ips_sem);
6870 up(&priv->ieee80211->ips_sem);
6874 priv->ieee80211->is_set_key = true;
6876 if (EntryNo >= TOTAL_CAM_ENTRY)
6877 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
6879 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
6882 usConfig |= BIT15 | (KeyType<<2);
6884 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
6885 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
6888 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
6889 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
6890 TargetCommand |= BIT31|BIT16;
6892 if(i==0){//MAC|Config
6893 TargetContent = (u32)(*(MacAddr+0)) << 16|
6894 (u32)(*(MacAddr+1)) << 24|
6897 write_nic_dword(dev, WCAMI, TargetContent);
6898 write_nic_dword(dev, RWCAM, TargetCommand);
6899 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6902 TargetContent = (u32)(*(MacAddr+2)) |
6903 (u32)(*(MacAddr+3)) << 8|
6904 (u32)(*(MacAddr+4)) << 16|
6905 (u32)(*(MacAddr+5)) << 24;
6906 write_nic_dword(dev, WCAMI, TargetContent);
6907 write_nic_dword(dev, RWCAM, TargetCommand);
6909 else { //Key Material
6910 if(KeyContent != NULL)
6912 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6913 write_nic_dword(dev, RWCAM, TargetCommand);
6917 RT_TRACE(COMP_SEC,"=========>after set key, usconfig:%x\n", usConfig);
6919 // This function seems not ready! WB
6920 void CamPrintDbgReg(struct net_device* dev)
6922 unsigned long rvalue;
6923 unsigned char ucValue;
6924 write_nic_dword(dev, DCAM, 0x80000000);
6926 rvalue = read_nic_dword(dev, DCAM); //delay_ms(40);
6927 RT_TRACE(COMP_SEC, " TX CAM=%8lX ",rvalue);
6928 if((rvalue & 0x40000000) != 0x4000000)
6929 RT_TRACE(COMP_SEC, "-->TX Key Not Found ");
6931 write_nic_dword(dev, DCAM, 0x00000000); //delay_ms(40);
6932 rvalue = read_nic_dword(dev, DCAM); //delay_ms(40);
6933 RT_TRACE(COMP_SEC, "RX CAM=%8lX ",rvalue);
6934 if((rvalue & 0x40000000) != 0x4000000)
6935 RT_TRACE(COMP_SEC, "-->CAM Key Not Found ");
6936 ucValue = read_nic_byte(dev, SECR);
6937 RT_TRACE(COMP_SEC, "WPA_Config=%x \n",ucValue);
6940 bool NicIFEnableNIC(struct net_device* dev)
6942 RT_STATUS init_status = RT_STATUS_SUCCESS;
6943 struct r8192_priv* priv = ieee80211_priv(dev);
6944 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
6948 RT_TRACE(COMP_ERR, "ERR!!! %s(): Driver is already down!\n",__FUNCTION__);
6949 priv->bdisable_nic = false; //YJ,add,091111
6952 // <1> Reset memory: descriptor, buffer,..
6953 //NicIFResetMemory(Adapter);
6955 // <2> Enable Adapter
6956 //printk("===========>%s()\n",__FUNCTION__);
6957 //priv->bfirst_init = true;
6958 init_status = rtl8192_adapter_start(dev);
6959 if (init_status != RT_STATUS_SUCCESS) {
6960 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
6961 priv->bdisable_nic = false; //YJ,add,091111
6964 //printk("start adapter finished\n");
6965 RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
6966 //priv->bfirst_init = false;
6968 // <3> Enable Interrupt
6969 rtl8192_irq_enable(dev);
6970 priv->bdisable_nic = false;
6971 //RT_TRACE(COMP_PS,"<===========%s()\n",__FUNCTION__);
6972 return (init_status == RT_STATUS_SUCCESS) ? true:false;
6974 bool NicIFDisableNIC(struct net_device* dev)
6977 struct r8192_priv* priv = ieee80211_priv(dev);
6979 // <1> Disable Interrupt
6980 //RT_TRACE(COMP_PS, "=========>%s()\n",__FUNCTION__);
6981 priv->bdisable_nic = true; //YJ,move,091109
6982 tmp_state = priv->ieee80211->state;
6984 ieee80211_softmac_stop_protocol(priv->ieee80211, false);
6986 priv->ieee80211->state = tmp_state;
6987 rtl8192_cancel_deferred_work(priv);
6988 rtl8192_irq_disable(dev);
6989 // <2> Stop all timer
6991 // <3> Disable Adapter
6992 rtl8192_halt_adapter(dev, false);
6993 // priv->bdisable_nic = true;
6994 //RT_TRACE(COMP_PS, "<=========%s()\n",__FUNCTION__);
7000 /***************************************************************************
7001 ------------------- module init / exit stubs ----------------
7002 ****************************************************************************/
7003 module_init(rtl8192_pci_module_init);
7004 module_exit(rtl8192_pci_module_exit);