1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 * Linux device driver for RTL8190P / RTL8192E
5 * Based on the r8180 driver, which is:
6 * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 * The full GNU General Public License is included in this distribution in the
21 * file called LICENSE.
23 * Contact Information:
24 * Jerry chuang <wlanfae@realtek.com>
28 #undef RX_DONT_PASS_UL
30 #undef DEBUG_RX_VERBOSE
36 #undef DEBUG_TX_FILLDESC
41 #undef DEBUG_REGISTERS
43 #undef DEBUG_IRQ_TASKLET
47 //#define CONFIG_RTL8192_IO_MAP
48 #include <linux/vmalloc.h>
49 #include <linux/slab.h>
50 #include <asm/uaccess.h>
51 #include "r8192E_hw.h"
53 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
54 #include "r8180_93cx6.h" /* Card EEPROM */
55 #include "r8192E_wx.h"
56 #include "r819xE_phy.h" //added by WB 4.30.2008
57 #include "r819xE_phyreg.h"
58 #include "r819xE_cmdpkt.h"
59 #include "r8192E_dm.h"
66 #include "ieee80211/dot11d.h"
69 //set here to open your trace code. //WB
70 u32 rt_global_debug_component =
88 // COMP_POWER_TRACKING |
90 COMP_ERR ; //always open err flags on
92 static const struct pci_device_id rtl8192_pci_id_tbl[] __devinitdata = {
96 { PCI_DEVICE(0x10ec, 0x8190) },
98 { PCI_DEVICE(0x07aa, 0x0045) },
99 { PCI_DEVICE(0x07aa, 0x0046) },
102 { PCI_DEVICE(0x10ec, 0x8192) },
105 { PCI_DEVICE(0x07aa, 0x0044) },
106 { PCI_DEVICE(0x07aa, 0x0047) },
111 static char ifname[IFNAMSIZ] = "wlan%d";
112 static int hwwep = 1; //default use hw. set 0 to use software security
113 static int channels = 0x3fff;
115 MODULE_LICENSE("GPL");
116 MODULE_VERSION("V 1.1");
117 MODULE_DEVICE_TABLE(pci, rtl8192_pci_id_tbl);
118 //MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
119 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
122 module_param_string(ifname, ifname, sizeof(ifname), S_IRUGO|S_IWUSR);
123 module_param(hwwep,int, S_IRUGO|S_IWUSR);
124 module_param(channels,int, S_IRUGO|S_IWUSR);
126 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
127 MODULE_PARM_DESC(hwwep," Try to use hardware WEP support. Still broken and not available on all cards");
128 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
130 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
131 const struct pci_device_id *id);
132 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev);
134 static struct pci_driver rtl8192_pci_driver = {
135 .name = RTL819xE_MODULE_NAME, /* Driver name */
136 .id_table = rtl8192_pci_id_tbl, /* PCI_ID table */
137 .probe = rtl8192_pci_probe, /* probe fn */
138 .remove = __devexit_p(rtl8192_pci_disconnect), /* remove fn */
140 .suspend = rtl8192E_suspend, /* PM suspend fn */
141 .resume = rtl8192E_resume, /* PM resume fn */
143 .suspend = NULL, /* PM suspend fn */
144 .resume = NULL, /* PM resume fn */
148 static void rtl8192_start_beacon(struct net_device *dev);
149 static void rtl8192_stop_beacon(struct net_device *dev);
150 static void rtl819x_watchdog_wqcallback(struct work_struct *work);
151 static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
152 static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv);
153 static void rtl8192_prepare_beacon(struct r8192_priv *priv);
154 static irqreturn_t rtl8192_interrupt(int irq, void *netdev);
155 static void rtl8192_try_wake_queue(struct net_device *dev, int pri);
156 static void rtl819xE_tx_cmd(struct net_device *dev, struct sk_buff *skb);
157 static void rtl8192_update_ratr_table(struct net_device* dev);
158 static void rtl8192_restart(struct work_struct *work);
159 static void watch_dog_timer_callback(unsigned long data);
160 static int _rtl8192_up(struct net_device *dev);
161 static void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
165 typedef struct _CHANNEL_LIST
169 }CHANNEL_LIST, *PCHANNEL_LIST;
171 static const CHANNEL_LIST ChannelPlan[] = {
172 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64,149,153,157,161,165},24}, //FCC
173 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
174 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
175 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
176 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, //MKK //MKK
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
179 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
180 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, // For 11a , TELEC
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
182 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14},14} //For Global Domain. 1-11:active scan, 12-14 passive scan. //+YJ, 080626
185 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
187 int i, max_chan=-1, min_chan=-1;
188 struct ieee80211_device* ieee = priv->ieee80211;
189 switch (channel_plan)
191 case COUNTRY_CODE_FCC:
192 case COUNTRY_CODE_IC:
193 case COUNTRY_CODE_ETSI:
194 case COUNTRY_CODE_SPAIN:
195 case COUNTRY_CODE_FRANCE:
196 case COUNTRY_CODE_MKK:
197 case COUNTRY_CODE_MKK1:
198 case COUNTRY_CODE_ISRAEL:
199 case COUNTRY_CODE_TELEC:
200 case COUNTRY_CODE_MIC:
203 ieee->bGlobalDomain = false;
204 //acturally 8225 & 8256 rf chip only support B,G,24N mode
205 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256))
212 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
214 if (ChannelPlan[channel_plan].Len != 0){
215 // Clear old channel map
216 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
217 // Set new channel map
218 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
220 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
222 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
227 case COUNTRY_CODE_GLOBAL_DOMAIN:
229 GET_DOT11D_INFO(ieee)->bEnabled = 0; //this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain setting
231 ieee->bGlobalDomain = true;
241 #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 )
242 /* 2007/07/25 MH Defien temp tx fw info. */
243 static TX_FWINFO_T Tmp_TxFwInfo;
246 #define rx_hal_is_cck_rate(_pdrvinfo)\
247 (_pdrvinfo->RxRate == DESC90_RATE1M ||\
248 _pdrvinfo->RxRate == DESC90_RATE2M ||\
249 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
250 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
254 void CamResetAllEntry(struct net_device *dev)
256 write_nic_dword(dev, RWCAM, BIT31|BIT30);
260 void write_cam(struct net_device *dev, u8 addr, u32 data)
262 write_nic_dword(dev, WCAMI, data);
263 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
265 u32 read_cam(struct net_device *dev, u8 addr)
267 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
268 return read_nic_dword(dev, 0xa8);
271 #ifdef CONFIG_RTL8180_IO_MAP
273 u8 read_nic_byte(struct net_device *dev, int x)
275 return 0xff&inb(dev->base_addr +x);
278 u32 read_nic_dword(struct net_device *dev, int x)
280 return inl(dev->base_addr +x);
283 u16 read_nic_word(struct net_device *dev, int x)
285 return inw(dev->base_addr +x);
288 void write_nic_byte(struct net_device *dev, int x,u8 y)
290 outb(y&0xff,dev->base_addr +x);
293 void write_nic_word(struct net_device *dev, int x,u16 y)
295 outw(y,dev->base_addr +x);
298 void write_nic_dword(struct net_device *dev, int x,u32 y)
300 outl(y,dev->base_addr +x);
303 #else /* RTL_IO_MAP */
305 u8 read_nic_byte(struct net_device *dev, int x)
307 return 0xff&readb((u8*)dev->mem_start +x);
310 u32 read_nic_dword(struct net_device *dev, int x)
312 return readl((u8*)dev->mem_start +x);
315 u16 read_nic_word(struct net_device *dev, int x)
317 return readw((u8*)dev->mem_start +x);
320 void write_nic_byte(struct net_device *dev, int x,u8 y)
322 writeb(y,(u8*)dev->mem_start +x);
326 void write_nic_dword(struct net_device *dev, int x,u32 y)
328 writel(y,(u8*)dev->mem_start +x);
332 void write_nic_word(struct net_device *dev, int x,u16 y)
334 writew(y,(u8*)dev->mem_start +x);
338 #endif /* RTL_IO_MAP */
340 u8 rtl8192e_ap_sec_type(struct ieee80211_device *ieee)
342 static const u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
343 static const u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
344 int wpa_ie_len= ieee->wpa_ie_len;
345 struct ieee80211_crypt_data* crypt;
348 crypt = ieee->crypt[ieee->tx_keyidx];
350 encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY) ||
351 (ieee->host_encrypt && crypt && crypt->ops &&
352 (0 == strcmp(crypt->ops->name,"WEP")));
355 if(encrypt && (wpa_ie_len == 0)) {
356 // wep encryption, no N mode setting */
358 } else if((wpa_ie_len != 0)) {
359 // parse pairwise key type */
360 if (((ieee->wpa_ie[0] == 0xdd) && (!memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) ||
361 ((ieee->wpa_ie[0] == 0x30) && (!memcmp(&ieee->wpa_ie[10],ccmp_rsn_ie, 4))))
371 rtl8192e_SetHwReg(struct net_device *dev,u8 variable,u8* val)
373 struct r8192_priv* priv = ieee80211_priv(dev);
379 write_nic_dword(dev, BSSIDR, ((u32*)(val))[0]);
380 write_nic_word(dev, BSSIDR+2, ((u16*)(val+2))[0]);
383 case HW_VAR_MEDIA_STATUS:
385 RT_OP_MODE OpMode = *((RT_OP_MODE *)(val));
386 u8 btMsr = read_nic_byte(dev, MSR);
392 case RT_OP_MODE_INFRASTRUCTURE:
396 case RT_OP_MODE_IBSS:
409 write_nic_byte(dev, MSR, btMsr);
413 case HW_VAR_CECHK_BSSID:
417 Type = ((u8*)(val))[0];
418 RegRCR = read_nic_dword(dev,RCR);
419 priv->ReceiveConfig = RegRCR;
422 RegRCR |= (RCR_CBSSID);
423 else if (Type == false)
424 RegRCR &= (~RCR_CBSSID);
426 write_nic_dword(dev, RCR,RegRCR);
427 priv->ReceiveConfig = RegRCR;
432 case HW_VAR_SLOT_TIME:
434 priv->slot_time = val[0];
435 write_nic_byte(dev, SLOT_TIME, val[0]);
440 case HW_VAR_ACK_PREAMBLE:
443 priv->short_preamble = (bool)(*(u8*)val );
444 regTmp = priv->basic_rate;
445 if (priv->short_preamble)
446 regTmp |= BRSR_AckShortPmb;
447 write_nic_dword(dev, RRSR, regTmp);
452 write_nic_dword(dev, CPU_GEN, ((u32*)(val))[0]);
461 static struct proc_dir_entry *rtl8192_proc = NULL;
463 static int proc_get_stats_ap(char *page, char **start,
464 off_t offset, int count,
465 int *eof, void *data)
467 struct net_device *dev = data;
468 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
469 struct ieee80211_device *ieee = priv->ieee80211;
470 struct ieee80211_network *target;
473 list_for_each_entry(target, &ieee->network_list, list) {
475 len += snprintf(page + len, count - len,
476 "%s ", target->ssid);
478 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
479 len += snprintf(page + len, count - len,
483 len += snprintf(page + len, count - len,
493 static int proc_get_registers(char *page, char **start,
494 off_t offset, int count,
495 int *eof, void *data)
497 struct net_device *dev = data;
502 /* This dump the current register page */
503 len += snprintf(page + len, count - len,
504 "\n####################page 0##################\n ");
508 len += snprintf(page + len, count - len,
511 for(i=0;i<16 && n<=max;i++,n++)
512 len += snprintf(page + len, count - len,
513 "%2x ",read_nic_byte(dev,n));
515 len += snprintf(page + len, count - len,"\n");
516 len += snprintf(page + len, count - len,
517 "\n####################page 1##################\n ");
520 len += snprintf(page + len, count - len,
523 for(i=0;i<16 && n<=max;i++,n++)
524 len += snprintf(page + len, count - len,
525 "%2x ",read_nic_byte(dev,0x100|n));
528 len += snprintf(page + len, count - len,
529 "\n####################page 3##################\n ");
532 len += snprintf(page + len, count - len,
535 for(i=0;i<16 && n<=max;i++,n++)
536 len += snprintf(page + len, count - len,
537 "%2x ",read_nic_byte(dev,0x300|n));
545 static int proc_get_stats_tx(char *page, char **start,
546 off_t offset, int count,
547 int *eof, void *data)
549 struct net_device *dev = data;
550 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
554 len += snprintf(page + len, count - len,
555 "TX VI priority ok int: %lu\n"
556 // "TX VI priority error int: %lu\n"
557 "TX VO priority ok int: %lu\n"
558 // "TX VO priority error int: %lu\n"
559 "TX BE priority ok int: %lu\n"
560 // "TX BE priority error int: %lu\n"
561 "TX BK priority ok int: %lu\n"
562 // "TX BK priority error int: %lu\n"
563 "TX MANAGE priority ok int: %lu\n"
564 // "TX MANAGE priority error int: %lu\n"
565 "TX BEACON priority ok int: %lu\n"
566 "TX BEACON priority error int: %lu\n"
567 "TX CMDPKT priority ok int: %lu\n"
568 // "TX high priority ok int: %lu\n"
569 // "TX high priority failed error int: %lu\n"
570 // "TX queue resume: %lu\n"
571 "TX queue stopped?: %d\n"
572 "TX fifo overflow: %lu\n"
573 // "TX beacon: %lu\n"
574 // "TX VI queue: %d\n"
575 // "TX VO queue: %d\n"
576 // "TX BE queue: %d\n"
577 // "TX BK queue: %d\n"
578 // "TX HW queue: %d\n"
579 // "TX VI dropped: %lu\n"
580 // "TX VO dropped: %lu\n"
581 // "TX BE dropped: %lu\n"
582 // "TX BK dropped: %lu\n"
583 "TX total data packets %lu\n"
584 "TX total data bytes :%lu\n",
585 // "TX beacon aborted: %lu\n",
586 priv->stats.txviokint,
587 // priv->stats.txvierr,
588 priv->stats.txvookint,
589 // priv->stats.txvoerr,
590 priv->stats.txbeokint,
591 // priv->stats.txbeerr,
592 priv->stats.txbkokint,
593 // priv->stats.txbkerr,
594 priv->stats.txmanageokint,
595 // priv->stats.txmanageerr,
596 priv->stats.txbeaconokint,
597 priv->stats.txbeaconerr,
598 priv->stats.txcmdpktokint,
599 // priv->stats.txhpokint,
600 // priv->stats.txhperr,
601 // priv->stats.txresumed,
602 netif_queue_stopped(dev),
603 priv->stats.txoverflow,
604 // priv->stats.txbeacon,
605 // atomic_read(&(priv->tx_pending[VI_QUEUE])),
606 // atomic_read(&(priv->tx_pending[VO_QUEUE])),
607 // atomic_read(&(priv->tx_pending[BE_QUEUE])),
608 // atomic_read(&(priv->tx_pending[BK_QUEUE])),
609 // read_nic_byte(dev, TXFIFOCOUNT),
610 // priv->stats.txvidrop,
611 // priv->stats.txvodrop,
612 priv->ieee80211->stats.tx_packets,
613 priv->ieee80211->stats.tx_bytes
616 // priv->stats.txbedrop,
617 // priv->stats.txbkdrop
618 // priv->stats.txdatapkt
619 // priv->stats.txbeaconerr
628 static int proc_get_stats_rx(char *page, char **start,
629 off_t offset, int count,
630 int *eof, void *data)
632 struct net_device *dev = data;
633 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
637 len += snprintf(page + len, count - len,
640 "RX rx overflow error: %lu\n"
641 "RX invalid urb error: %lu\n",
644 priv->stats.rxoverflow,
645 priv->stats.rxurberr);
651 static void rtl8192_proc_module_init(void)
653 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
654 rtl8192_proc=create_proc_entry(RTL819xE_MODULE_NAME, S_IFDIR, init_net.proc_net);
658 static void rtl8192_proc_module_remove(void)
660 remove_proc_entry(RTL819xE_MODULE_NAME, init_net.proc_net);
664 static void rtl8192_proc_remove_one(struct net_device *dev)
666 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
668 printk("dev name=======> %s\n",dev->name);
671 // remove_proc_entry("stats-hw", priv->dir_dev);
672 remove_proc_entry("stats-tx", priv->dir_dev);
673 remove_proc_entry("stats-rx", priv->dir_dev);
674 // remove_proc_entry("stats-ieee", priv->dir_dev);
675 remove_proc_entry("stats-ap", priv->dir_dev);
676 remove_proc_entry("registers", priv->dir_dev);
677 // remove_proc_entry("cck-registers",priv->dir_dev);
678 // remove_proc_entry("ofdm-registers",priv->dir_dev);
679 //remove_proc_entry(dev->name, rtl8192_proc);
680 remove_proc_entry("wlan0", rtl8192_proc);
681 priv->dir_dev = NULL;
686 static void rtl8192_proc_init_one(struct net_device *dev)
688 struct proc_dir_entry *e;
689 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
690 priv->dir_dev = create_proc_entry(dev->name,
691 S_IFDIR | S_IRUGO | S_IXUGO,
693 if (!priv->dir_dev) {
694 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
698 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
699 priv->dir_dev, proc_get_stats_rx, dev);
702 RT_TRACE(COMP_ERR,"Unable to initialize "
703 "/proc/net/rtl8192/%s/stats-rx\n",
708 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
709 priv->dir_dev, proc_get_stats_tx, dev);
712 RT_TRACE(COMP_ERR, "Unable to initialize "
713 "/proc/net/rtl8192/%s/stats-tx\n",
717 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
718 priv->dir_dev, proc_get_stats_ap, dev);
721 RT_TRACE(COMP_ERR, "Unable to initialize "
722 "/proc/net/rtl8192/%s/stats-ap\n",
726 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
727 priv->dir_dev, proc_get_registers, dev);
729 RT_TRACE(COMP_ERR, "Unable to initialize "
730 "/proc/net/rtl8192/%s/registers\n",
735 short check_nic_enough_desc(struct net_device *dev, int prio)
737 struct r8192_priv *priv = ieee80211_priv(dev);
738 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
740 /* for now we reserve two free descriptor as a safety boundary
741 * between the tail and the head
743 return (ring->entries - skb_queue_len(&ring->queue) >= 2);
746 static void tx_timeout(struct net_device *dev)
748 struct r8192_priv *priv = ieee80211_priv(dev);
750 schedule_work(&priv->reset_wq);
754 static void rtl8192_irq_enable(struct net_device *dev)
756 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
757 priv->irq_enabled = 1;
758 write_nic_dword(dev,INTA_MASK, priv->irq_mask);
761 void rtl8192_irq_disable(struct net_device *dev)
763 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
765 write_nic_dword(dev,INTA_MASK,0);
766 priv->irq_enabled = 0;
769 void rtl8192_update_msr(struct net_device *dev)
771 struct r8192_priv *priv = ieee80211_priv(dev);
774 msr = read_nic_byte(dev, MSR);
775 msr &= ~ MSR_LINK_MASK;
777 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
778 * msr must be updated if the state is ASSOCIATING.
779 * this is intentional and make sense for ad-hoc and
780 * master (see the create BSS/IBSS func)
782 if (priv->ieee80211->state == IEEE80211_LINKED){
784 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
785 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
786 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
787 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
788 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
789 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
792 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
794 write_nic_byte(dev, MSR, msr);
797 void rtl8192_set_chan(struct net_device *dev,short ch)
799 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
803 /* need to implement rf set channel here WB */
805 if (priv->rf_set_chan)
806 priv->rf_set_chan(dev, priv->chan);
809 void rtl8192_rx_enable(struct net_device *dev)
811 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
813 write_nic_dword(dev, RDQDA,priv->rx_ring_dma);
816 /* the TX_DESC_BASE setting is according to the following queue index
825 * BEACON_QUEUE ===> 8
827 static const u32 TX_DESC_BASE[] = {BKQDA, BEQDA, VIQDA, VOQDA, HCCAQDA, CQDA, MQDA, HQDA, BQDA};
828 void rtl8192_tx_enable(struct net_device *dev)
830 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
833 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
834 write_nic_dword(dev, TX_DESC_BASE[i], priv->tx_ring[i].dma);
836 ieee80211_reset_queue(priv->ieee80211);
840 static void rtl8192_free_rx_ring(struct net_device *dev)
842 struct r8192_priv *priv = ieee80211_priv(dev);
845 for (i = 0; i < priv->rxringcount; i++) {
846 struct sk_buff *skb = priv->rx_buf[i];
850 pci_unmap_single(priv->pdev,
851 *((dma_addr_t *)skb->cb),
852 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
856 pci_free_consistent(priv->pdev, sizeof(*priv->rx_ring) * priv->rxringcount,
857 priv->rx_ring, priv->rx_ring_dma);
858 priv->rx_ring = NULL;
861 static void rtl8192_free_tx_ring(struct net_device *dev, unsigned int prio)
863 struct r8192_priv *priv = ieee80211_priv(dev);
864 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
866 while (skb_queue_len(&ring->queue)) {
867 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
868 struct sk_buff *skb = __skb_dequeue(&ring->queue);
870 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
871 skb->len, PCI_DMA_TODEVICE);
873 ring->idx = (ring->idx + 1) % ring->entries;
876 pci_free_consistent(priv->pdev, sizeof(*ring->desc)*ring->entries,
877 ring->desc, ring->dma);
881 void PHY_SetRtl8192eRfOff(struct net_device* dev)
883 //disable RF-Chip A/B
884 rtl8192_setBBreg(dev, rFPGA0_XA_RFInterfaceOE, BIT4, 0x0);
885 //analog to digital off, for power save
886 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0x300, 0x0);
887 //digital to analog off, for power save
888 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x18, 0x0);
890 rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, 0xf, 0x0);
892 rtl8192_setBBreg(dev, rOFDM1_TRxPathEnable, 0xf, 0x0);
893 //analog to digital part2 off, for power save
894 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x60, 0x0);
895 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x4, 0x0);
896 // Analog parameter!!Change bias and Lbus control.
897 write_nic_byte(dev, ANAPAR_FOR_8192PciE, 0x07);
901 void rtl8192_halt_adapter(struct net_device *dev, bool reset)
903 struct r8192_priv *priv = ieee80211_priv(dev);
909 OpMode = RT_OP_MODE_NO_LINK;
910 priv->ieee80211->SetHwRegHandler(dev, HW_VAR_MEDIA_STATUS, &OpMode);
912 if(!priv->ieee80211->bSupportRemoteWakeUp)
914 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
915 //priv->ieee80211->SetHwRegHandler(dev, HW_VAR_COMMAND, &u1bTmp ); // Using HW_VAR_COMMAND instead of writing CMDR directly. Rewrited by Annie, 2006-04-07.
916 write_nic_byte(dev, CMDR, u1bTmp);
923 //PlatformStallExecution(150000);
927 priv->bHwRfOffAction = 2;
931 // Call MgntActSet_RF_State instead to prevent RF config race condition.
932 // By Bruce, 2008-01-17.
934 if(!priv->ieee80211->bSupportRemoteWakeUp)
936 //MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_INIT);
937 //MgntActSet_RF_State(Adapter, eRfOff, Adapter->MgntInfo.RfOffReason);
938 //if(Adapter->HardwareType == HARDWARE_TYPE_RTL8190P)
940 PHY_SetRtl8192eRfOff(dev);
942 // 2006.11.30. System reset bit
943 //priv->ieee80211->GetHwRegHandler(dev, HW_VAR_CPU_RST, (u32*)(&ulRegRead) );
944 ulRegRead = read_nic_dword(dev,CPU_GEN);
945 ulRegRead|=CPU_GEN_SYSTEM_RESET;
946 //priv->ieee80211->SetHwRegHandler(dev, HW_VAR_CPU_RST, &ulRegRead);
947 write_nic_dword(dev,CPU_GEN, ulRegRead);
952 write_nic_dword(dev, WFCRC0, 0xffffffff);
953 write_nic_dword(dev, WFCRC1, 0xffffffff);
954 write_nic_dword(dev, WFCRC2, 0xffffffff);
957 write_nic_byte(dev, PMR, 0x5);
958 //Disable tx, enanble rx
959 write_nic_byte(dev, MacBlkCtrl, 0xa);
963 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
964 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
966 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
967 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
970 skb_queue_purge(&priv->skb_queue);
973 static const u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
974 inline u16 rtl8192_rate2rate(short rate)
976 if (rate >11) return 0;
977 return rtl_rate[rate];
980 static void rtl8192_data_hard_stop(struct net_device *dev)
984 static void rtl8192_data_hard_resume(struct net_device *dev)
989 * this function TX data frames when the ieee80211 stack requires this.
990 * It checks also if we need to stop the ieee tx queue, eventually do it
992 static void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
994 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
996 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
997 u8 queue_index = tcb_desc->queue_index;
999 /* shall not be referred by command packet */
1000 assert(queue_index != TXCMD_QUEUE);
1002 if (priv->bHwRadioOff || (!priv->up))
1008 memcpy(skb->cb, &dev, sizeof(dev));
1010 skb_push(skb, priv->ieee80211->tx_headroom);
1011 ret = rtl8192_tx(dev, skb);
1016 if (queue_index != MGNT_QUEUE) {
1017 priv->ieee80211->stats.tx_bytes += (skb->len - priv->ieee80211->tx_headroom);
1018 priv->ieee80211->stats.tx_packets++;
1023 * This is a rough attempt to TX a frame
1024 * This is called by the ieee 80211 stack to TX management frames.
1025 * If the ring is full packet are dropped (for data frame the queue
1026 * is stopped before this can happen).
1028 static int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1030 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1032 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1033 u8 queue_index = tcb_desc->queue_index;
1035 if (queue_index != TXCMD_QUEUE) {
1036 if (priv->bHwRadioOff || (!priv->up))
1043 memcpy(skb->cb, &dev, sizeof(dev));
1044 if (queue_index == TXCMD_QUEUE) {
1045 rtl819xE_tx_cmd(dev, skb);
1049 tcb_desc->RATRIndex = 7;
1050 tcb_desc->bTxDisableRateFallBack = 1;
1051 tcb_desc->bTxUseDriverAssingedRate = 1;
1052 tcb_desc->bTxEnableFwCalcDur = 1;
1053 skb_push(skb, priv->ieee80211->tx_headroom);
1054 ret = rtl8192_tx(dev, skb);
1064 static void rtl8192_tx_isr(struct net_device *dev, int prio)
1066 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1068 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
1070 while (skb_queue_len(&ring->queue)) {
1071 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1072 struct sk_buff *skb;
1074 /* beacon packet will only use the first descriptor defaultly,
1075 * and the OWN may not be cleared by the hardware
1077 if(prio != BEACON_QUEUE) {
1080 ring->idx = (ring->idx + 1) % ring->entries;
1083 skb = __skb_dequeue(&ring->queue);
1084 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1085 skb->len, PCI_DMA_TODEVICE);
1089 if (prio == MGNT_QUEUE){
1090 if (priv->ieee80211->ack_tx_to_ieee){
1091 if (rtl8192_is_tx_queue_empty(dev)){
1092 priv->ieee80211->ack_tx_to_ieee = 0;
1093 ieee80211_ps_tx_ack(priv->ieee80211, 1);
1098 if(prio != BEACON_QUEUE) {
1099 /* try to deal with the pending packets */
1100 tasklet_schedule(&priv->irq_tx_tasklet);
1105 static void rtl8192_stop_beacon(struct net_device *dev)
1109 static void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1111 struct r8192_priv *priv = ieee80211_priv(dev);
1112 struct ieee80211_network *net;
1113 u8 i=0, basic_rate = 0;
1114 net = & priv->ieee80211->current_network;
1116 for (i=0; i<net->rates_len; i++)
1118 basic_rate = net->rates[i]&0x7f;
1121 case MGN_1M: *rate_config |= RRSR_1M; break;
1122 case MGN_2M: *rate_config |= RRSR_2M; break;
1123 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1124 case MGN_11M: *rate_config |= RRSR_11M; break;
1125 case MGN_6M: *rate_config |= RRSR_6M; break;
1126 case MGN_9M: *rate_config |= RRSR_9M; break;
1127 case MGN_12M: *rate_config |= RRSR_12M; break;
1128 case MGN_18M: *rate_config |= RRSR_18M; break;
1129 case MGN_24M: *rate_config |= RRSR_24M; break;
1130 case MGN_36M: *rate_config |= RRSR_36M; break;
1131 case MGN_48M: *rate_config |= RRSR_48M; break;
1132 case MGN_54M: *rate_config |= RRSR_54M; break;
1135 for (i=0; i<net->rates_ex_len; i++)
1137 basic_rate = net->rates_ex[i]&0x7f;
1140 case MGN_1M: *rate_config |= RRSR_1M; break;
1141 case MGN_2M: *rate_config |= RRSR_2M; break;
1142 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1143 case MGN_11M: *rate_config |= RRSR_11M; break;
1144 case MGN_6M: *rate_config |= RRSR_6M; break;
1145 case MGN_9M: *rate_config |= RRSR_9M; break;
1146 case MGN_12M: *rate_config |= RRSR_12M; break;
1147 case MGN_18M: *rate_config |= RRSR_18M; break;
1148 case MGN_24M: *rate_config |= RRSR_24M; break;
1149 case MGN_36M: *rate_config |= RRSR_36M; break;
1150 case MGN_48M: *rate_config |= RRSR_48M; break;
1151 case MGN_54M: *rate_config |= RRSR_54M; break;
1157 #define SHORT_SLOT_TIME 9
1158 #define NON_SHORT_SLOT_TIME 20
1160 static void rtl8192_update_cap(struct net_device* dev, u16 cap)
1163 struct r8192_priv *priv = ieee80211_priv(dev);
1164 struct ieee80211_network *net = &priv->ieee80211->current_network;
1165 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1166 tmp = priv->basic_rate;
1167 if (priv->short_preamble)
1168 tmp |= BRSR_AckShortPmb;
1169 write_nic_dword(dev, RRSR, tmp);
1171 if (net->mode & (IEEE_G|IEEE_N_24G))
1174 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1176 slot_time = SHORT_SLOT_TIME;
1178 else //long slot time
1179 slot_time = NON_SHORT_SLOT_TIME;
1180 priv->slot_time = slot_time;
1181 write_nic_byte(dev, SLOT_TIME, slot_time);
1186 static void rtl8192_net_update(struct net_device *dev)
1189 struct r8192_priv *priv = ieee80211_priv(dev);
1190 struct ieee80211_network *net;
1191 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1192 u16 rate_config = 0;
1193 net = &priv->ieee80211->current_network;
1194 //update Basic rate: RR, BRSR
1195 rtl8192_config_rate(dev, &rate_config);
1196 // 2007.01.16, by Emily
1197 // Select RRSR (in Legacy-OFDM and CCK)
1198 // For 8190, we select only 24M, 12M, 6M, 11M, 5.5M, 2M, and 1M from the Basic rate.
1199 // We do not use other rates.
1200 priv->basic_rate = rate_config &= 0x15f;
1202 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1203 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1206 rtl8192_update_msr(dev);
1210 // rtl8192_update_cap(dev, net->capability);
1211 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1213 write_nic_word(dev, ATIMWND, 2);
1214 write_nic_word(dev, BCN_DMATIME, 256);
1215 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1216 // write_nic_word(dev, BcnIntTime, 100);
1217 //BIT15 of BCN_DRV_EARLY_INT will indicate whether software beacon or hw beacon is applied.
1218 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
1219 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1221 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1222 // TODO: BcnIFS may required to be changed on ASIC
1223 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1225 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1231 void rtl819xE_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1233 struct r8192_priv *priv = ieee80211_priv(dev);
1234 struct rtl8192_tx_ring *ring;
1235 tx_desc_819x_pci *entry;
1239 unsigned long flags;
1241 ring = &priv->tx_ring[TXCMD_QUEUE];
1242 mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1244 spin_lock_irqsave(&priv->irq_th_lock,flags);
1245 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1246 entry = &ring->desc[idx];
1248 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1250 entry->LINIP = tcb_desc->bLastIniPkt;
1251 entry->FirstSeg = 1;//first segment
1252 entry->LastSeg = 1; //last segment
1253 if(tcb_desc->bCmdOrInit == DESC_PACKET_TYPE_INIT) {
1254 entry->CmdInit = DESC_PACKET_TYPE_INIT;
1256 entry->CmdInit = DESC_PACKET_TYPE_NORMAL;
1257 entry->Offset = sizeof(TX_FWINFO_8190PCI) + 8;
1258 entry->PktSize = (u16)(tcb_desc->pkt_size + entry->Offset);
1259 entry->QueueSelect = QSLT_CMD;
1260 entry->TxFWInfoSize = 0x08;
1261 entry->RATid = (u8)DESC_PACKET_TYPE_INIT;
1263 entry->TxBufferSize = skb->len;
1264 entry->TxBuffAddr = cpu_to_le32(mapping);
1267 #ifdef JOHN_DUMP_TXDESC
1269 tx_desc_819x_pci *entry1 = &ring->desc[0];
1270 unsigned int *ptr= (unsigned int *)entry1;
1271 printk("<Tx descriptor>:\n");
1272 for (i = 0; i < 8; i++)
1273 printk("%8x ", ptr[i]);
1277 __skb_queue_tail(&ring->queue, skb);
1278 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1280 write_nic_byte(dev, TPPoll, TPPoll_CQ);
1286 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1287 * in TxFwInfo data structure
1289 static u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1291 u8 QueueSelect = 0x0; //defualt set to
1295 QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
1299 QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
1303 QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
1307 QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
1310 QueueSelect = QSLT_MGNT;
1314 QueueSelect = QSLT_BEACON;
1317 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
1318 // TODO: Remove Assertions
1319 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
1321 QueueSelect = QSLT_CMD;
1325 //QueueSelect = QSLT_HIGH;
1329 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
1335 static u8 MRateToHwRate8190Pci(u8 rate)
1337 u8 ret = DESC90_RATE1M;
1340 case MGN_1M: ret = DESC90_RATE1M; break;
1341 case MGN_2M: ret = DESC90_RATE2M; break;
1342 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
1343 case MGN_11M: ret = DESC90_RATE11M; break;
1344 case MGN_6M: ret = DESC90_RATE6M; break;
1345 case MGN_9M: ret = DESC90_RATE9M; break;
1346 case MGN_12M: ret = DESC90_RATE12M; break;
1347 case MGN_18M: ret = DESC90_RATE18M; break;
1348 case MGN_24M: ret = DESC90_RATE24M; break;
1349 case MGN_36M: ret = DESC90_RATE36M; break;
1350 case MGN_48M: ret = DESC90_RATE48M; break;
1351 case MGN_54M: ret = DESC90_RATE54M; break;
1353 // HT rate since here
1354 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
1355 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
1356 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
1357 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
1358 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
1359 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
1360 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
1361 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
1362 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
1363 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
1364 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1365 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1366 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1367 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1368 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1369 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1370 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1378 static u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1382 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1384 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1391 * The tx procedure is just as following,
1392 * skb->cb will contain all the following information,
1393 * priority, morefrag, rate, &dev.
1395 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
1397 struct r8192_priv *priv = ieee80211_priv(dev);
1398 struct rtl8192_tx_ring *ring;
1399 unsigned long flags;
1400 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1401 tx_desc_819x_pci *pdesc = NULL;
1402 TX_FWINFO_8190PCI *pTxFwInfo = NULL;
1404 bool multi_addr=false,broad_addr=false,uni_addr=false;
1405 u8* pda_addr = NULL;
1408 if(priv->bdisable_nic){
1409 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);
1414 priv->ieee80211->bAwakePktSent = true;
1417 mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1418 /* collect the tx packets statitcs */
1419 pda_addr = ((u8*)skb->data) + sizeof(TX_FWINFO_8190PCI);
1420 if(is_multicast_ether_addr(pda_addr))
1422 else if(is_broadcast_ether_addr(pda_addr))
1428 priv->stats.txbytesunicast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1430 priv->stats.txbytesmulticast +=(u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1432 priv->stats.txbytesbroadcast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1434 /* fill tx firmware */
1435 pTxFwInfo = (PTX_FWINFO_8190PCI)skb->data;
1436 memset(pTxFwInfo,0,sizeof(TX_FWINFO_8190PCI));
1437 pTxFwInfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
1438 pTxFwInfo->TxRate = MRateToHwRate8190Pci((u8)tcb_desc->data_rate);
1439 pTxFwInfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1440 pTxFwInfo->Short = QueryIsShort(pTxFwInfo->TxHT, pTxFwInfo->TxRate, tcb_desc);
1442 /* Aggregation related */
1443 if(tcb_desc->bAMPDUEnable) {
1444 pTxFwInfo->AllowAggregation = 1;
1445 pTxFwInfo->RxMF = tcb_desc->ampdu_factor;
1446 pTxFwInfo->RxAMD = tcb_desc->ampdu_density;
1448 pTxFwInfo->AllowAggregation = 0;
1449 pTxFwInfo->RxMF = 0;
1450 pTxFwInfo->RxAMD = 0;
1454 // Protection mode related
1456 pTxFwInfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
1457 pTxFwInfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
1458 pTxFwInfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
1459 pTxFwInfo->RtsHT= (tcb_desc->rts_rate&0x80)?1:0;
1460 pTxFwInfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1461 pTxFwInfo->RtsBandwidth = 0;
1462 pTxFwInfo->RtsSubcarrier = tcb_desc->RTSSC;
1463 pTxFwInfo->RtsShort = (pTxFwInfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):(tcb_desc->bRTSUseShortGI?1:0);
1465 // Set Bandwidth and sub-channel settings.
1467 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
1469 if(tcb_desc->bPacketBW)
1471 pTxFwInfo->TxBandwidth = 1;
1473 pTxFwInfo->TxSubCarrier = 3;
1475 pTxFwInfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode, cosa 04012008
1480 pTxFwInfo->TxBandwidth = 0;
1481 pTxFwInfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1484 pTxFwInfo->TxBandwidth = 0;
1485 pTxFwInfo->TxSubCarrier = 0;
1490 /* 2007/07/25 MH Copy current TX FW info.*/
1491 memcpy((void*)(&Tmp_TxFwInfo), (void*)(pTxFwInfo), sizeof(TX_FWINFO_8190PCI));
1492 printk("&&&&&&&&&&&&&&&&&&&&&&====>print out fwinf\n");
1493 printk("===>enable fwcacl:%d\n", Tmp_TxFwInfo.EnableCPUDur);
1494 printk("===>RTS STBC:%d\n", Tmp_TxFwInfo.RtsSTBC);
1495 printk("===>RTS Subcarrier:%d\n", Tmp_TxFwInfo.RtsSubcarrier);
1496 printk("===>Allow Aggregation:%d\n", Tmp_TxFwInfo.AllowAggregation);
1497 printk("===>TX HT bit:%d\n", Tmp_TxFwInfo.TxHT);
1498 printk("===>Tx rate:%d\n", Tmp_TxFwInfo.TxRate);
1499 printk("===>Received AMPDU Density:%d\n", Tmp_TxFwInfo.RxAMD);
1500 printk("===>Received MPDU Factor:%d\n", Tmp_TxFwInfo.RxMF);
1501 printk("===>TxBandwidth:%d\n", Tmp_TxFwInfo.TxBandwidth);
1502 printk("===>TxSubCarrier:%d\n", Tmp_TxFwInfo.TxSubCarrier);
1504 printk("<=====**********************out of print\n");
1507 spin_lock_irqsave(&priv->irq_th_lock,flags);
1508 ring = &priv->tx_ring[tcb_desc->queue_index];
1509 if (tcb_desc->queue_index != BEACON_QUEUE) {
1510 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1515 pdesc = &ring->desc[idx];
1516 if((pdesc->OWN == 1) && (tcb_desc->queue_index != BEACON_QUEUE)) {
1517 RT_TRACE(COMP_ERR,"No more TX desc@%d, ring->idx = %d,idx = %d,%x",
1518 tcb_desc->queue_index,ring->idx, idx,skb->len);
1519 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1523 /* fill tx descriptor */
1524 memset((u8*)pdesc,0,12);
1528 pdesc->Offset = sizeof(TX_FWINFO_8190PCI) + 8; //We must add 8!! Emily
1529 pdesc->PktSize = (u16)skb->len-sizeof(TX_FWINFO_8190PCI);
1533 pdesc->RATid = tcb_desc->RATRIndex;
1537 pdesc->SecType = 0x0;
1538 if (tcb_desc->bHwSec) {
1539 switch (priv->ieee80211->pairwise_key_type) {
1540 case KEY_TYPE_WEP40:
1541 case KEY_TYPE_WEP104:
1542 pdesc->SecType = 0x1;
1546 pdesc->SecType = 0x2;
1550 pdesc->SecType = 0x3;
1554 pdesc->SecType = 0x0;
1565 pdesc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1566 pdesc->TxFWInfoSize = sizeof(TX_FWINFO_8190PCI);
1568 pdesc->DISFB = tcb_desc->bTxDisableRateFallBack;
1569 pdesc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1573 pdesc->TxBufferSize = skb->len;
1575 pdesc->TxBuffAddr = cpu_to_le32(mapping);
1576 __skb_queue_tail(&ring->queue, skb);
1578 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1579 dev->trans_start = jiffies;
1580 write_nic_word(dev,TPPoll,0x01<<tcb_desc->queue_index);
1584 static short rtl8192_alloc_rx_desc_ring(struct net_device *dev)
1586 struct r8192_priv *priv = ieee80211_priv(dev);
1587 rx_desc_819x_pci *entry = NULL;
1590 priv->rx_ring = pci_alloc_consistent(priv->pdev,
1591 sizeof(*priv->rx_ring) * priv->rxringcount, &priv->rx_ring_dma);
1593 if (!priv->rx_ring || (unsigned long)priv->rx_ring & 0xFF) {
1594 RT_TRACE(COMP_ERR,"Cannot allocate RX ring\n");
1598 memset(priv->rx_ring, 0, sizeof(*priv->rx_ring) * priv->rxringcount);
1601 for (i = 0; i < priv->rxringcount; i++) {
1602 struct sk_buff *skb = dev_alloc_skb(priv->rxbuffersize);
1603 dma_addr_t *mapping;
1604 entry = &priv->rx_ring[i];
1607 priv->rx_buf[i] = skb;
1608 mapping = (dma_addr_t *)skb->cb;
1609 *mapping = pci_map_single(priv->pdev, skb_tail_pointer(skb),
1610 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
1612 entry->BufferAddress = cpu_to_le32(*mapping);
1614 entry->Length = priv->rxbuffersize;
1622 static int rtl8192_alloc_tx_desc_ring(struct net_device *dev,
1623 unsigned int prio, unsigned int entries)
1625 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1626 tx_desc_819x_pci *ring;
1630 ring = pci_alloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma);
1631 if (!ring || (unsigned long)ring & 0xFF) {
1632 RT_TRACE(COMP_ERR, "Cannot allocate TX ring (prio = %d)\n", prio);
1636 memset(ring, 0, sizeof(*ring)*entries);
1637 priv->tx_ring[prio].desc = ring;
1638 priv->tx_ring[prio].dma = dma;
1639 priv->tx_ring[prio].idx = 0;
1640 priv->tx_ring[prio].entries = entries;
1641 skb_queue_head_init(&priv->tx_ring[prio].queue);
1643 for (i = 0; i < entries; i++)
1644 ring[i].NextDescAddress =
1645 cpu_to_le32((u32)dma + ((i + 1) % entries) * sizeof(*ring));
1651 static short rtl8192_pci_initdescring(struct net_device *dev)
1655 struct r8192_priv *priv = ieee80211_priv(dev);
1657 ret = rtl8192_alloc_rx_desc_ring(dev);
1663 /* general process for other queue */
1664 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1665 ret = rtl8192_alloc_tx_desc_ring(dev, i, priv->txringcount);
1667 goto err_free_rings;
1671 /* specific process for hardware beacon process */
1672 ret = rtl8192_alloc_tx_desc_ring(dev, MAX_TX_QUEUE_COUNT - 1, 2);
1674 goto err_free_rings;
1680 rtl8192_free_rx_ring(dev);
1681 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
1682 if (priv->tx_ring[i].desc)
1683 rtl8192_free_tx_ring(dev, i);
1687 static void rtl8192_pci_resetdescring(struct net_device *dev)
1689 struct r8192_priv *priv = ieee80211_priv(dev);
1692 /* force the rx_idx to the first one */
1694 rx_desc_819x_pci *entry = NULL;
1695 for (i = 0; i < priv->rxringcount; i++) {
1696 entry = &priv->rx_ring[i];
1702 /* after reset, release previous pending packet, and force the
1703 * tx idx to the first one */
1704 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1705 if (priv->tx_ring[i].desc) {
1706 struct rtl8192_tx_ring *ring = &priv->tx_ring[i];
1708 while (skb_queue_len(&ring->queue)) {
1709 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1710 struct sk_buff *skb = __skb_dequeue(&ring->queue);
1712 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1713 skb->len, PCI_DMA_TODEVICE);
1715 ring->idx = (ring->idx + 1) % ring->entries;
1722 static void rtl8192_link_change(struct net_device *dev)
1724 struct r8192_priv *priv = ieee80211_priv(dev);
1725 struct ieee80211_device* ieee = priv->ieee80211;
1726 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
1727 if (ieee->state == IEEE80211_LINKED)
1729 rtl8192_net_update(dev);
1730 rtl8192_update_ratr_table(dev);
1732 //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
1733 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
1734 EnableHWSecurityConfig8192(dev);
1739 write_nic_byte(dev, 0x173, 0);
1741 /*update timing params*/
1742 //rtl8192_set_chan(dev, priv->chan);
1744 rtl8192_update_msr(dev);
1746 // 2007/10/16 MH MAC Will update TSF according to all received beacon, so we have
1747 // // To set CBSSID bit when link with any AP or STA.
1748 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
1751 reg = read_nic_dword(dev, RCR);
1752 if (priv->ieee80211->state == IEEE80211_LINKED)
1753 priv->ReceiveConfig = reg |= RCR_CBSSID;
1755 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
1756 write_nic_dword(dev, RCR, reg);
1761 static const struct ieee80211_qos_parameters def_qos_parameters = {
1762 {3,3,3,3},/* cw_min */
1763 {7,7,7,7},/* cw_max */
1764 {2,2,2,2},/* aifs */
1765 {0,0,0,0},/* flags */
1766 {0,0,0,0} /* tx_op_limit */
1769 static void rtl8192_update_beacon(struct work_struct * work)
1771 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
1772 struct net_device *dev = priv->ieee80211->dev;
1773 struct ieee80211_device* ieee = priv->ieee80211;
1774 struct ieee80211_network* net = &ieee->current_network;
1776 if (ieee->pHTInfo->bCurrentHTSupport)
1777 HTUpdateSelfAndPeerSetting(ieee, net);
1778 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
1779 rtl8192_update_cap(dev, net->capability);
1783 * background support to run QoS activate functionality
1785 static const int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
1786 static void rtl8192_qos_activate(struct work_struct * work)
1788 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
1789 struct net_device *dev = priv->ieee80211->dev;
1790 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
1791 u8 mode = priv->ieee80211->current_network.mode;
1796 mutex_lock(&priv->mutex);
1797 if(priv->ieee80211->state != IEEE80211_LINKED)
1799 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
1800 /* It better set slot time at first */
1801 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
1802 /* update the ac parameter to related registers */
1803 for(i = 0; i < QOS_QUEUE_NUM; i++) {
1804 //Mode G/A: slotTimeTimer = 9; Mode B: 20
1805 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
1806 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
1807 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
1808 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
1809 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
1810 //printk("===>u4bAcParam:%x, ", u4bAcParam);
1811 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
1812 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
1816 mutex_unlock(&priv->mutex);
1819 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
1821 struct ieee80211_network *network)
1824 u32 size = sizeof(struct ieee80211_qos_parameters);
1826 if(priv->ieee80211->state !=IEEE80211_LINKED)
1829 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1832 if (network->flags & NETWORK_HAS_QOS_MASK) {
1833 if (active_network &&
1834 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
1835 network->qos_data.active = network->qos_data.supported;
1837 if ((network->qos_data.active == 1) && (active_network == 1) &&
1838 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
1839 (network->qos_data.old_param_count !=
1840 network->qos_data.param_count)) {
1841 network->qos_data.old_param_count =
1842 network->qos_data.param_count;
1843 queue_work(priv->priv_wq, &priv->qos_activate);
1844 RT_TRACE (COMP_QOS, "QoS parameters change call "
1848 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1849 &def_qos_parameters, size);
1851 if ((network->qos_data.active == 1) && (active_network == 1)) {
1852 queue_work(priv->priv_wq, &priv->qos_activate);
1853 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
1855 network->qos_data.active = 0;
1856 network->qos_data.supported = 0;
1862 /* handle manage frame frame beacon and probe response */
1863 static int rtl8192_handle_beacon(struct net_device * dev,
1864 struct ieee80211_beacon * beacon,
1865 struct ieee80211_network * network)
1867 struct r8192_priv *priv = ieee80211_priv(dev);
1869 rtl8192_qos_handle_probe_response(priv,1,network);
1871 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
1877 * handling the beaconing responses. if we get different QoS setting
1878 * off the network from the associated setting, adjust the QoS setting
1880 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
1881 struct ieee80211_network *network)
1884 unsigned long flags;
1885 u32 size = sizeof(struct ieee80211_qos_parameters);
1886 int set_qos_param = 0;
1888 if ((priv == NULL) || (network == NULL))
1891 if(priv->ieee80211->state !=IEEE80211_LINKED)
1894 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1897 spin_lock_irqsave(&priv->ieee80211->lock, flags);
1898 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
1899 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1900 &network->qos_data.parameters,
1901 sizeof(struct ieee80211_qos_parameters));
1902 priv->ieee80211->current_network.qos_data.active = 1;
1904 if((priv->ieee80211->current_network.qos_data.param_count !=
1905 network->qos_data.param_count))
1909 /* update qos parameter for current network */
1910 priv->ieee80211->current_network.qos_data.old_param_count =
1911 priv->ieee80211->current_network.qos_data.param_count;
1912 priv->ieee80211->current_network.qos_data.param_count =
1913 network->qos_data.param_count;
1916 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1917 &def_qos_parameters, size);
1918 priv->ieee80211->current_network.qos_data.active = 0;
1919 priv->ieee80211->current_network.qos_data.supported = 0;
1923 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
1925 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
1926 if (set_qos_param == 1)
1927 queue_work(priv->priv_wq, &priv->qos_activate);
1933 static int rtl8192_handle_assoc_response(struct net_device *dev,
1934 struct ieee80211_assoc_response_frame *resp,
1935 struct ieee80211_network *network)
1937 struct r8192_priv *priv = ieee80211_priv(dev);
1938 rtl8192_qos_association_resp(priv, network);
1943 /* updateRATRTabel for MCS only. Basic rate is not implemented. */
1944 static void rtl8192_update_ratr_table(struct net_device* dev)
1946 struct r8192_priv* priv = ieee80211_priv(dev);
1947 struct ieee80211_device* ieee = priv->ieee80211;
1948 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
1952 rtl8192_config_rate(dev, (u16*)(&ratr_value));
1953 ratr_value |= (*(u16*)(pMcsRate)) << 12;
1958 ratr_value &= 0x00000FF0;
1961 ratr_value &= 0x0000000F;
1964 ratr_value &= 0x00000FF7;
1968 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
1969 ratr_value &= 0x0007F007;
1971 if (priv->rf_type == RF_1T2R)
1972 ratr_value &= 0x000FF007;
1974 ratr_value &= 0x0F81F007;
1980 ratr_value &= 0x0FFFFFFF;
1981 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
1982 ratr_value |= 0x80000000;
1983 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
1984 ratr_value |= 0x80000000;
1986 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
1987 write_nic_byte(dev, UFWP, 1);
1990 static bool GetNmodeSupportBySecCfg8190Pci(struct net_device*dev)
1994 struct r8192_priv *priv = ieee80211_priv(dev);
1995 struct ieee80211_device *ieee = priv->ieee80211;
1996 return !(ieee->rtllib_ap_sec_type &&
1997 (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP)));
1999 struct r8192_priv* priv = ieee80211_priv(dev);
2000 struct ieee80211_device* ieee = priv->ieee80211;
2001 int wpa_ie_len= ieee->wpa_ie_len;
2002 struct ieee80211_crypt_data* crypt;
2005 crypt = ieee->crypt[ieee->tx_keyidx];
2006 encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2009 if(encrypt && (wpa_ie_len == 0)) {
2010 /* wep encryption, no N mode setting */
2012 // } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
2013 } else if((wpa_ie_len != 0)) {
2014 /* parse pairwise key type */
2015 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
2016 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))))
2021 //RT_TRACE(COMP_ERR,"In %s The GroupEncAlgorithm is [4]\n",__FUNCTION__ );
2029 static void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2031 struct ieee80211_device* ieee = priv->ieee80211;
2032 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
2033 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2035 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2036 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
2037 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
2040 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2043 static u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2045 struct r8192_priv *priv = ieee80211_priv(dev);
2047 switch(priv->rf_chip)
2052 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2055 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2058 ret = WIRELESS_MODE_B;
2064 static void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2066 struct r8192_priv *priv = ieee80211_priv(dev);
2067 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2070 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2072 if(bSupportMode & WIRELESS_MODE_N_24G)
2074 wireless_mode = WIRELESS_MODE_N_24G;
2076 else if(bSupportMode & WIRELESS_MODE_N_5G)
2078 wireless_mode = WIRELESS_MODE_N_5G;
2080 else if((bSupportMode & WIRELESS_MODE_A))
2082 wireless_mode = WIRELESS_MODE_A;
2084 else if((bSupportMode & WIRELESS_MODE_G))
2086 wireless_mode = WIRELESS_MODE_G;
2088 else if((bSupportMode & WIRELESS_MODE_B))
2090 wireless_mode = WIRELESS_MODE_B;
2093 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2094 wireless_mode = WIRELESS_MODE_B;
2097 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2098 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2100 priv->ieee80211->mode = wireless_mode;
2102 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2103 priv->ieee80211->pHTInfo->bEnableHT = 1;
2105 priv->ieee80211->pHTInfo->bEnableHT = 0;
2106 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2107 rtl8192_refresh_supportrate(priv);
2112 static bool GetHalfNmodeSupportByAPs819xPci(struct net_device* dev)
2114 struct r8192_priv* priv = ieee80211_priv(dev);
2115 struct ieee80211_device* ieee = priv->ieee80211;
2117 return ieee->bHalfWirelessN24GMode;
2120 short rtl8192_is_tx_queue_empty(struct net_device *dev)
2123 struct r8192_priv *priv = ieee80211_priv(dev);
2124 for (i=0; i<=MGNT_QUEUE; i++)
2126 if ((i== TXCMD_QUEUE) || (i == HCCA_QUEUE) )
2128 if (skb_queue_len(&(&priv->tx_ring[i])->queue) > 0){
2129 printk("===>tx queue is not empty:%d, %d\n", i, skb_queue_len(&(&priv->tx_ring[i])->queue));
2136 static void rtl8192_hw_sleep_down(struct net_device *dev)
2138 struct r8192_priv *priv = ieee80211_priv(dev);
2139 unsigned long flags = 0;
2141 spin_lock_irqsave(&priv->rf_ps_lock,flags);
2142 if (priv->RFChangeInProgress) {
2143 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2144 RT_TRACE(COMP_RF, "rtl8192_hw_sleep_down(): RF Change in progress! \n");
2145 printk("rtl8192_hw_sleep_down(): RF Change in progress!\n");
2148 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2150 MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
2153 static void rtl8192_hw_sleep_wq (struct work_struct *work)
2155 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2156 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
2157 struct net_device *dev = ieee->dev;
2159 rtl8192_hw_sleep_down(dev);
2162 static void rtl8192_hw_wakeup(struct net_device* dev)
2164 struct r8192_priv *priv = ieee80211_priv(dev);
2165 unsigned long flags = 0;
2167 spin_lock_irqsave(&priv->rf_ps_lock,flags);
2168 if (priv->RFChangeInProgress) {
2169 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2170 RT_TRACE(COMP_RF, "rtl8192_hw_wakeup(): RF Change in progress! \n");
2171 printk("rtl8192_hw_wakeup(): RF Change in progress! schedule wake up task again\n");
2172 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
2175 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2177 MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS);
2180 void rtl8192_hw_wakeup_wq (struct work_struct *work)
2182 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2183 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
2184 struct net_device *dev = ieee->dev;
2185 rtl8192_hw_wakeup(dev);
2189 #define MIN_SLEEP_TIME 50
2190 #define MAX_SLEEP_TIME 10000
2191 static void rtl8192_hw_to_sleep(struct net_device *dev, u32 th, u32 tl)
2193 struct r8192_priv *priv = ieee80211_priv(dev);
2196 unsigned long flags;
2198 spin_lock_irqsave(&priv->ps_lock,flags);
2200 // Writing HW register with 0 equals to disable
2201 // the timer, that is not really what we want
2203 tl -= MSECS(8+16+7);
2205 // If the interval in witch we are requested to sleep is too
2206 // short then give up and remain awake
2207 // when we sleep after send null frame, the timer will be too short to sleep.
2209 if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
2210 ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
2211 spin_unlock_irqrestore(&priv->ps_lock,flags);
2212 printk("too short to sleep::%x, %x, %lx\n",tl, rb, MSECS(MIN_SLEEP_TIME));
2216 if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
2217 ((tl < rb) && (tl>MSECS(69)) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))||
2218 ((tl<rb)&&(tl<MSECS(69))&&((tl+0xffffffff-rb)>MSECS(MAX_SLEEP_TIME)))) {
2219 printk("========>too long to sleep:%x, %x, %lx\n", tl, rb, MSECS(MAX_SLEEP_TIME));
2220 spin_unlock_irqrestore(&priv->ps_lock,flags);
2224 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
2225 queue_delayed_work(priv->ieee80211->wq,
2226 &priv->ieee80211->hw_wakeup_wq,tmp);
2227 //PowerSave not supported when kernel version less 2.6.20
2229 queue_delayed_work(priv->ieee80211->wq,
2230 (void *)&priv->ieee80211->hw_sleep_wq,0);
2231 spin_unlock_irqrestore(&priv->ps_lock,flags);
2235 static void rtl8192_init_priv_variable(struct net_device* dev)
2237 struct r8192_priv *priv = ieee80211_priv(dev);
2239 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
2241 // Default Halt the NIC if RF is OFF.
2242 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_HALT_NIC;
2243 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_CLK_REQ;
2244 pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_ASPM;
2245 pPSC->RegRfPsLevel |= RT_RF_LPS_LEVEL_ASPM;
2246 pPSC->bLeisurePs = true;
2247 pPSC->RegMaxLPSAwakeIntvl = 5;
2248 priv->bHwRadioOff = false;
2250 priv->being_init_adapter = false;
2251 priv->txbuffsize = 1600;//1024;
2252 priv->txfwbuffersize = 4096;
2253 priv->txringcount = 64;//32;
2254 //priv->txbeaconcount = priv->txringcount;
2255 priv->txbeaconcount = 2;
2256 priv->rxbuffersize = 9100;//2048;//1024;
2257 priv->rxringcount = MAX_RX_COUNT;//64;
2258 priv->irq_enabled=0;
2259 priv->card_8192 = NIC_8192E;
2260 priv->rx_skb_complete = 1;
2261 priv->chan = 1; //set to channel 1
2262 priv->RegWirelessMode = WIRELESS_MODE_AUTO;
2263 priv->RegChannelPlan = 0xf;
2264 priv->nrxAMPDU_size = 0;
2265 priv->nrxAMPDU_aggr_num = 0;
2266 priv->last_rxdesc_tsf_high = 0;
2267 priv->last_rxdesc_tsf_low = 0;
2268 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2269 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2270 priv->ieee80211->ieee_up=0;
2271 priv->retry_rts = DEFAULT_RETRY_RTS;
2272 priv->retry_data = DEFAULT_RETRY_DATA;
2273 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2274 priv->ieee80211->rate = 110; //11 mbps
2275 priv->ieee80211->short_slot = 1;
2276 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2277 priv->bcck_in_ch14 = false;
2278 priv->bfsync_processing = false;
2279 priv->CCKPresentAttentuation = 0;
2280 priv->rfa_txpowertrackingindex = 0;
2281 priv->rfc_txpowertrackingindex = 0;
2283 priv->ScanDelay = 50;//for Scan TODO
2284 //added by amy for silent reset
2285 priv->ResetProgress = RESET_TYPE_NORESET;
2286 priv->bForcedSilentReset = 0;
2287 priv->bDisableNormalResetCheck = false;
2288 priv->force_reset = false;
2289 //added by amy for power save
2291 priv->ieee80211->RfOffReason = 0;
2292 priv->RFChangeInProgress = false;
2293 priv->bHwRfOffAction = 0;
2294 priv->SetRFPowerStateInProgress = false;
2295 priv->ieee80211->PowerSaveControl.bInactivePs = true;
2296 priv->ieee80211->PowerSaveControl.bIPSModeBackup = false;
2298 priv->txpower_checkcnt = 0;
2299 priv->thermal_readback_index =0;
2300 priv->txpower_tracking_callback_cnt = 0;
2301 priv->ccktxpower_adjustcnt_ch14 = 0;
2302 priv->ccktxpower_adjustcnt_not_ch14 = 0;
2304 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2305 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2306 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2307 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2308 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;/* |
2309 IEEE_SOFTMAC_BEACONS;*///added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2311 priv->ieee80211->active_scan = 1;
2312 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2313 priv->ieee80211->host_encrypt = 1;
2314 priv->ieee80211->host_decrypt = 1;
2315 //priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2316 //priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2317 priv->ieee80211->start_send_beacons = rtl8192_start_beacon;//+by david 081107
2318 priv->ieee80211->stop_send_beacons = rtl8192_stop_beacon;//+by david 081107
2319 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2320 priv->ieee80211->set_chan = rtl8192_set_chan;
2321 priv->ieee80211->link_change = rtl8192_link_change;
2322 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2323 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2324 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2325 priv->ieee80211->init_wmmparam_flag = 0;
2326 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2327 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2328 priv->ieee80211->tx_headroom = sizeof(TX_FWINFO_8190PCI);
2329 priv->ieee80211->qos_support = 1;
2330 priv->ieee80211->dot11PowerSaveMode = 0;
2332 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2333 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2334 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2335 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2337 priv->ieee80211->sta_wake_up = rtl8192_hw_wakeup;
2338 // priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
2339 priv->ieee80211->enter_sleep_state = rtl8192_hw_to_sleep;
2340 priv->ieee80211->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
2342 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8190Pci;
2343 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2344 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xPci;
2347 priv->ieee80211->InitialGainHandler = InitialGain819xPci;
2350 priv->ieee80211->ieee80211_ips_leave_wq = ieee80211_ips_leave_wq;
2351 priv->ieee80211->ieee80211_ips_leave = ieee80211_ips_leave;
2354 priv->ieee80211->LeisurePSLeave = LeisurePSLeave;
2357 priv->ieee80211->SetHwRegHandler = rtl8192e_SetHwReg;
2358 priv->ieee80211->rtllib_ap_sec_type = rtl8192e_ap_sec_type;
2360 priv->card_type = USB;
2362 priv->ShortRetryLimit = 0x30;
2363 priv->LongRetryLimit = 0x30;
2365 priv->EarlyRxThreshold = 7;
2366 priv->enable_gpio0 = 0;
2368 priv->TransmitConfig = 0;
2370 priv->ReceiveConfig = RCR_ADD3 |
2371 RCR_AMF | RCR_ADF | //accept management/data
2372 RCR_AICV | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2373 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2374 RCR_AAP | ((u32)7<<RCR_MXDMA_OFFSET) |
2375 ((u32)7 << RCR_FIFO_OFFSET) | RCR_ONLYERLPKT;
2377 priv->irq_mask = (u32)(IMR_ROK | IMR_VODOK | IMR_VIDOK | IMR_BEDOK | IMR_BKDOK |
2378 IMR_HCCADOK | IMR_MGNTDOK | IMR_COMDOK | IMR_HIGHDOK |
2379 IMR_BDOK | IMR_RXCMDOK | IMR_TIMEOUT0 | IMR_RDU | IMR_RXFOVW |
2380 IMR_TXFOVW | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
2382 priv->AcmControl = 0;
2383 priv->pFirmware = (rt_firmware*)vmalloc(sizeof(rt_firmware));
2384 if (priv->pFirmware)
2385 memset(priv->pFirmware, 0, sizeof(rt_firmware));
2387 /* rx related queue */
2388 skb_queue_head_init(&priv->rx_queue);
2389 skb_queue_head_init(&priv->skb_queue);
2391 /* Tx related queue */
2392 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2393 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2395 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2396 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2398 priv->rf_set_chan = rtl8192_phy_SwChnl;
2401 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2403 spin_lock_init(&priv->tx_lock);
2404 spin_lock_init(&priv->irq_lock);//added by thomas
2405 spin_lock_init(&priv->irq_th_lock);
2406 spin_lock_init(&priv->rf_ps_lock);
2407 spin_lock_init(&priv->ps_lock);
2408 //spin_lock_init(&priv->rf_lock);
2409 sema_init(&priv->wx_sem,1);
2410 sema_init(&priv->rf_sem,1);
2411 mutex_init(&priv->mutex);
2414 /* init tasklet and wait_queue here */
2415 #define DRV_NAME "wlan0"
2416 static void rtl8192_init_priv_task(struct net_device* dev)
2418 struct r8192_priv *priv = ieee80211_priv(dev);
2420 #ifdef PF_SYNCTHREAD
2421 priv->priv_wq = create_workqueue(DRV_NAME,0);
2423 priv->priv_wq = create_workqueue(DRV_NAME);
2427 INIT_WORK(&priv->ieee80211->ips_leave_wq, (void*)IPSLeave_wq);
2430 // INIT_WORK(&priv->reset_wq, (void(*)(void*)) rtl8192_restart);
2431 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2432 // INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2433 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2434 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2435 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2436 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2437 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2438 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2439 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2440 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq);
2441 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq);
2443 tasklet_init(&priv->irq_rx_tasklet,
2444 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2445 (unsigned long)priv);
2446 tasklet_init(&priv->irq_tx_tasklet,
2447 (void(*)(unsigned long))rtl8192_irq_tx_tasklet,
2448 (unsigned long)priv);
2449 tasklet_init(&priv->irq_prepare_beacon_tasklet,
2450 (void(*)(unsigned long))rtl8192_prepare_beacon,
2451 (unsigned long)priv);
2454 static void rtl8192_get_eeprom_size(struct net_device* dev)
2457 struct r8192_priv *priv = ieee80211_priv(dev);
2458 RT_TRACE(COMP_INIT, "===========>%s()\n", __FUNCTION__);
2459 curCR = read_nic_dword(dev, EPROM_CMD);
2460 RT_TRACE(COMP_INIT, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD, curCR);
2461 //whether need I consider BIT5?
2462 priv->epromtype = (curCR & EPROM_CMD_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2463 RT_TRACE(COMP_INIT, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2467 * used to swap endian. as ntohl & htonl are not
2468 * neccessary to swap endian, so use this instead.
2470 static inline u16 endian_swap(u16* data)
2473 *data = (tmp >> 8) | (tmp << 8);
2478 * Adapter->EEPROMAddressSize should be set before this function call.
2479 * EEPROM address size can be got through GetEEPROMSize8185()
2481 static void rtl8192_read_eeprom_info(struct net_device* dev)
2483 struct r8192_priv *priv = ieee80211_priv(dev);
2487 u8 ICVer8192, ICVer8256;
2489 u16 i,usValue, IC_Version;
2493 u8 EepromTxPower[100];
2495 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01};
2496 RT_TRACE(COMP_INIT, "====> rtl8192_read_eeprom_info\n");
2499 // TODO: I don't know if we need to apply EF function to EEPROM read function
2501 //2 Read EEPROM ID to make sure autoload is success
2502 EEPROMId = eprom_read(dev, 0);
2503 if( EEPROMId != RTL8190_EEPROM_ID )
2505 RT_TRACE(COMP_ERR, "EEPROM ID is invalid:%x, %x\n", EEPROMId, RTL8190_EEPROM_ID);
2506 priv->AutoloadFailFlag=true;
2510 priv->AutoloadFailFlag=false;
2514 // Assign Chip Version ID
2516 // Read IC Version && Channel Plan
2517 if(!priv->AutoloadFailFlag)
2520 priv->eeprom_vid = eprom_read(dev, (EEPROM_VID >> 1));
2521 priv->eeprom_did = eprom_read(dev, (EEPROM_DID >> 1));
2523 usValue = eprom_read(dev, (u16)(EEPROM_Customer_ID>>1)) >> 8 ;
2524 priv->eeprom_CustomerID = (u8)( usValue & 0xff);
2525 usValue = eprom_read(dev, (EEPROM_ICVersion_ChannelPlan>>1));
2526 priv->eeprom_ChannelPlan = usValue&0xff;
2527 IC_Version = ((usValue&0xff00)>>8);
2530 priv->card_8192_version = (VERSION_8190)(IC_Version);
2533 ICVer8192 = (IC_Version&0xf); //bit0~3; 1:A cut, 2:B cut, 3:C cut...
2534 ICVer8256 = ((IC_Version&0xf0)>>4);//bit4~6, bit7 reserved for other RF chip; 1:A cut, 2:B cut, 3:C cut...
2535 RT_TRACE(COMP_INIT, "\nICVer8192 = 0x%x\n", ICVer8192);
2536 RT_TRACE(COMP_INIT, "\nICVer8256 = 0x%x\n", ICVer8256);
2537 if(ICVer8192 == 0x2) //B-cut
2539 if(ICVer8256 == 0x5) //E-cut
2540 priv->card_8192_version= VERSION_8190_BE;
2544 switch(priv->card_8192_version)
2546 case VERSION_8190_BD:
2547 case VERSION_8190_BE:
2550 priv->card_8192_version = VERSION_8190_BD;
2553 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", priv->card_8192_version);
2557 priv->card_8192_version = VERSION_8190_BD;
2558 priv->eeprom_vid = 0;
2559 priv->eeprom_did = 0;
2560 priv->eeprom_CustomerID = 0;
2561 priv->eeprom_ChannelPlan = 0;
2562 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", 0xff);
2565 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
2566 RT_TRACE(COMP_INIT, "EEPROM DID = 0x%4x\n", priv->eeprom_did);
2567 RT_TRACE(COMP_INIT,"EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
2569 //2 Read Permanent MAC address
2570 if(!priv->AutoloadFailFlag)
2572 for(i = 0; i < 6; i += 2)
2574 usValue = eprom_read(dev, (u16) ((EEPROM_NODE_ADDRESS_BYTE_0+i)>>1));
2575 *(u16*)(&dev->dev_addr[i]) = usValue;
2578 // when auto load failed, the last address byte set to be a random one.
2579 // added by david woo.2007/11/7
2580 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2583 RT_TRACE(COMP_INIT, "Permanent Address = %pM\n", dev->dev_addr);
2585 //2 TX Power Check EEPROM Fail or not
2586 if(priv->card_8192_version > VERSION_8190_BD) {
2587 priv->bTXPowerDataReadFromEEPORM = true;
2589 priv->bTXPowerDataReadFromEEPORM = false;
2592 // 2007/11/15 MH 8190PCI Default=2T4R, 8192PCIE default=1T2R
2593 priv->rf_type = RTL819X_DEFAULT_RF_TYPE;
2595 if(priv->card_8192_version > VERSION_8190_BD)
2597 // Read RF-indication and Tx Power gain index diff of legacy to HT OFDM rate.
2598 if(!priv->AutoloadFailFlag)
2600 tempval = (eprom_read(dev, (EEPROM_RFInd_PowerDiff>>1))) & 0xff;
2601 priv->EEPROMLegacyHTTxPowerDiff = tempval & 0xf; // bit[3:0]
2603 if (tempval&0x80) //RF-indication, bit[7]
2604 priv->rf_type = RF_1T2R;
2606 priv->rf_type = RF_2T4R;
2610 priv->EEPROMLegacyHTTxPowerDiff = EEPROM_Default_LegacyHTTxPowerDiff;
2612 RT_TRACE(COMP_INIT, "EEPROMLegacyHTTxPowerDiff = %d\n",
2613 priv->EEPROMLegacyHTTxPowerDiff);
2615 // Read ThermalMeter from EEPROM
2616 if(!priv->AutoloadFailFlag)
2618 priv->EEPROMThermalMeter = (u8)(((eprom_read(dev, (EEPROM_ThermalMeter>>1))) & 0xff00)>>8);
2622 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2624 RT_TRACE(COMP_INIT, "ThermalMeter = %d\n", priv->EEPROMThermalMeter);
2625 //vivi, for tx power track
2626 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2628 if(priv->epromtype == EPROM_93c46)
2630 // Read antenna tx power offset of B/C/D to A and CrystalCap from EEPROM
2631 if(!priv->AutoloadFailFlag)
2633 usValue = eprom_read(dev, (EEPROM_TxPwDiff_CrystalCap>>1));
2634 priv->EEPROMAntPwDiff = (usValue&0x0fff);
2635 priv->EEPROMCrystalCap = (u8)((usValue&0xf000)>>12);
2639 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2640 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2642 RT_TRACE(COMP_INIT, "EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2643 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2646 // Get per-channel Tx Power Level
2648 for(i=0; i<14; i+=2)
2650 if(!priv->AutoloadFailFlag)
2652 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_CCK+i)>>1) );
2656 usValue = EEPROM_Default_TxPower;
2658 *((u16*)(&priv->EEPROMTxPowerLevelCCK[i])) = usValue;
2659 RT_TRACE(COMP_INIT,"CCK Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK[i]);
2660 RT_TRACE(COMP_INIT, "CCK Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelCCK[i+1]);
2662 for(i=0; i<14; i+=2)
2664 if(!priv->AutoloadFailFlag)
2666 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_OFDM_24G+i)>>1) );
2670 usValue = EEPROM_Default_TxPower;
2672 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[i])) = usValue;
2673 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelOFDM24G[i]);
2674 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelOFDM24G[i+1]);
2677 else if(priv->epromtype== EPROM_93c56)
2680 // Read CrystalCap from EEPROM
2681 if(!priv->AutoloadFailFlag)
2683 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2684 priv->EEPROMCrystalCap = (u8)(((eprom_read(dev, (EEPROM_C56_CrystalCap>>1))) & 0xf000)>>12);
2688 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2689 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2691 RT_TRACE(COMP_INIT,"EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2692 RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2694 // Get Tx Power Level by Channel
2695 if(!priv->AutoloadFailFlag)
2697 // Read Tx power of Channel 1 ~ 14 from EEPROM.
2698 for(i = 0; i < 12; i+=2)
2701 offset = EEPROM_C56_RfA_CCK_Chnl1_TxPwIndex + i;
2703 offset = EEPROM_C56_RfC_CCK_Chnl1_TxPwIndex + i - 6;
2704 usValue = eprom_read(dev, (offset>>1));
2705 *((u16*)(&EepromTxPower[i])) = usValue;
2708 for(i = 0; i < 12; i++)
2711 priv->EEPROMRfACCKChnl1TxPwLevel[i] = EepromTxPower[i];
2712 else if ((i >=3 )&&(i <= 5))
2713 priv->EEPROMRfAOfdmChnlTxPwLevel[i-3] = EepromTxPower[i];
2714 else if ((i >=6 )&&(i <= 8))
2715 priv->EEPROMRfCCCKChnl1TxPwLevel[i-6] = EepromTxPower[i];
2717 priv->EEPROMRfCOfdmChnlTxPwLevel[i-9] = EepromTxPower[i];
2722 priv->EEPROMRfACCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2723 priv->EEPROMRfACCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2724 priv->EEPROMRfACCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2726 priv->EEPROMRfAOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2727 priv->EEPROMRfAOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2728 priv->EEPROMRfAOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2730 priv->EEPROMRfCCCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2731 priv->EEPROMRfCCCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2732 priv->EEPROMRfCCCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2734 priv->EEPROMRfCOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2735 priv->EEPROMRfCOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2736 priv->EEPROMRfCOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2738 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[0]);
2739 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[1]);
2740 RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[2]);
2741 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[0]);
2742 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[1]);
2743 RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[2]);
2744 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[0]);
2745 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[1]);
2746 RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[2]);
2747 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[0]);
2748 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[1]);
2749 RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[2]);
2754 // Update HAL variables.
2756 if(priv->epromtype == EPROM_93c46)
2760 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK[i];
2761 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[i];
2763 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2764 // Antenna B gain offset to antenna A, bit0~3
2765 priv->AntennaTxPwDiff[0] = (priv->EEPROMAntPwDiff & 0xf);
2766 // Antenna C gain offset to antenna A, bit4~7
2767 priv->AntennaTxPwDiff[1] = ((priv->EEPROMAntPwDiff & 0xf0)>>4);
2768 // Antenna D gain offset to antenna A, bit8~11
2769 priv->AntennaTxPwDiff[2] = ((priv->EEPROMAntPwDiff & 0xf00)>>8);
2770 // CrystalCap, bit12~15
2771 priv->CrystalCap = priv->EEPROMCrystalCap;
2772 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2773 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
2774 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
2776 else if(priv->epromtype == EPROM_93c56)
2778 //char cck_pwr_diff_a=0, cck_pwr_diff_c=0;
2780 //cck_pwr_diff_a = pHalData->EEPROMRfACCKChnl7TxPwLevel - pHalData->EEPROMRfAOfdmChnlTxPwLevel[1];
2781 //cck_pwr_diff_c = pHalData->EEPROMRfCCCKChnl7TxPwLevel - pHalData->EEPROMRfCOfdmChnlTxPwLevel[1];
2782 for(i=0; i<3; i++) // channel 1~3 use the same Tx Power Level.
2784 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[0];
2785 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[0];
2786 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[0];
2787 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[0];
2789 for(i=3; i<9; i++) // channel 4~9 use the same Tx Power Level
2791 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[1];
2792 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[1];
2793 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[1];
2794 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[1];
2796 for(i=9; i<14; i++) // channel 10~14 use the same Tx Power Level
2798 priv->TxPowerLevelCCK_A[i] = priv->EEPROMRfACCKChnl1TxPwLevel[2];
2799 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[2];
2800 priv->TxPowerLevelCCK_C[i] = priv->EEPROMRfCCCKChnl1TxPwLevel[2];
2801 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[2];
2804 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_A[i]);
2806 RT_TRACE(COMP_INIT,"priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_A[i]);
2808 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_C[i]);
2810 RT_TRACE(COMP_INIT, "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_C[i]);
2811 priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2812 priv->AntennaTxPwDiff[0] = 0;
2813 priv->AntennaTxPwDiff[1] = 0;
2814 priv->AntennaTxPwDiff[2] = 0;
2815 priv->CrystalCap = priv->EEPROMCrystalCap;
2816 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2817 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
2818 priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
2822 if(priv->rf_type == RF_1T2R)
2824 RT_TRACE(COMP_INIT, "\n1T2R config\n");
2826 else if (priv->rf_type == RF_2T4R)
2828 RT_TRACE(COMP_INIT, "\n2T4R config\n");
2831 // 2008/01/16 MH We can only know RF type in the function. So we have to init
2832 // DIG RATR table again.
2833 init_rate_adaptive(dev);
2835 //1 Make a copy for following variables and we can change them if we want
2837 priv->rf_chip= RF_8256;
2839 if(priv->RegChannelPlan == 0xf)
2841 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2845 priv->ChannelPlan = priv->RegChannelPlan;
2849 // Used PID and DID to Set CustomerID
2851 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304 )
2853 priv->CustomerID = RT_CID_DLINK;
2856 switch(priv->eeprom_CustomerID)
2858 case EEPROM_CID_DEFAULT:
2859 priv->CustomerID = RT_CID_DEFAULT;
2861 case EEPROM_CID_CAMEO:
2862 priv->CustomerID = RT_CID_819x_CAMEO;
2864 case EEPROM_CID_RUNTOP:
2865 priv->CustomerID = RT_CID_819x_RUNTOP;
2867 case EEPROM_CID_NetCore:
2868 priv->CustomerID = RT_CID_819x_Netcore;
2870 case EEPROM_CID_TOSHIBA: // Merge by Jacken, 2008/01/31
2871 priv->CustomerID = RT_CID_TOSHIBA;
2872 if(priv->eeprom_ChannelPlan&0x80)
2873 priv->ChannelPlan = priv->eeprom_ChannelPlan&0x7f;
2875 priv->ChannelPlan = 0x0;
2876 RT_TRACE(COMP_INIT, "Toshiba ChannelPlan = 0x%x\n",
2879 case EEPROM_CID_Nettronix:
2880 priv->ScanDelay = 100; //cosa add for scan
2881 priv->CustomerID = RT_CID_Nettronix;
2883 case EEPROM_CID_Pronet:
2884 priv->CustomerID = RT_CID_PRONET;
2886 case EEPROM_CID_DLINK:
2887 priv->CustomerID = RT_CID_DLINK;
2890 case EEPROM_CID_WHQL:
2891 //Adapter->bInHctTest = TRUE;//do not supported
2893 //priv->bSupportTurboMode = FALSE;
2894 //priv->bAutoTurboBy8186 = FALSE;
2896 //pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
2897 //pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
2898 //pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
2902 // value from RegCustomerID
2906 //Avoid the channel plan array overflow, by Bruce, 2007-08-27.
2907 if(priv->ChannelPlan > CHANNEL_PLAN_LEN - 1)
2908 priv->ChannelPlan = 0; //FCC
2910 switch(priv->CustomerID)
2912 case RT_CID_DEFAULT:
2914 priv->LedStrategy = HW_LED;
2917 priv->LedStrategy = SW_LED_MODE1;
2922 case RT_CID_819x_CAMEO:
2923 priv->LedStrategy = SW_LED_MODE2;
2926 case RT_CID_819x_RUNTOP:
2927 priv->LedStrategy = SW_LED_MODE3;
2930 case RT_CID_819x_Netcore:
2931 priv->LedStrategy = SW_LED_MODE4;
2934 case RT_CID_Nettronix:
2935 priv->LedStrategy = SW_LED_MODE5;
2939 priv->LedStrategy = SW_LED_MODE6;
2942 case RT_CID_TOSHIBA: //Modify by Jacken 2008/01/31
2948 priv->LedStrategy = HW_LED;
2951 priv->LedStrategy = SW_LED_MODE1;
2958 if( priv->eeprom_vid == 0x1186 && priv->eeprom_did == 0x3304)
2959 priv->ieee80211->bSupportRemoteWakeUp = true;
2961 priv->ieee80211->bSupportRemoteWakeUp = false;
2964 RT_TRACE(COMP_INIT, "RegChannelPlan(%d)\n", priv->RegChannelPlan);
2965 RT_TRACE(COMP_INIT, "ChannelPlan = %d \n", priv->ChannelPlan);
2966 RT_TRACE(COMP_INIT, "LedStrategy = %d \n", priv->LedStrategy);
2967 RT_TRACE(COMP_TRACE, "<==== ReadAdapterInfo\n");
2973 static short rtl8192_get_channel_map(struct net_device * dev)
2975 struct r8192_priv *priv = ieee80211_priv(dev);
2976 #ifdef ENABLE_DOT11D
2977 if(priv->ChannelPlan> COUNTRY_CODE_GLOBAL_DOMAIN){
2978 printk("rtl8180_init:Error channel plan! Set to default.\n");
2979 priv->ChannelPlan= 0;
2981 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
2983 rtl819x_set_channel_map(priv->ChannelPlan, priv);
2986 //Set Default Channel Plan
2988 DMESG("No channels, aborting");
2992 priv->ChannelPlan= 0;//hikaru
2993 // set channels 1..14 allowed in given locale
2994 for (i=1; i<=14; i++) {
2995 (priv->ieee80211->channel_map)[i] = (u8)(ch & 0x01);
3002 static short rtl8192_init(struct net_device *dev)
3004 struct r8192_priv *priv = ieee80211_priv(dev);
3005 memset(&(priv->stats),0,sizeof(struct Stats));
3006 rtl8192_init_priv_variable(dev);
3007 rtl8192_init_priv_lock(priv);
3008 rtl8192_init_priv_task(dev);
3009 rtl8192_get_eeprom_size(dev);
3010 rtl8192_read_eeprom_info(dev);
3011 rtl8192_get_channel_map(dev);
3013 init_timer(&priv->watch_dog_timer);
3014 priv->watch_dog_timer.data = (unsigned long)dev;
3015 priv->watch_dog_timer.function = watch_dog_timer_callback;
3016 #if defined(IRQF_SHARED)
3017 if(request_irq(dev->irq, (void*)rtl8192_interrupt, IRQF_SHARED, dev->name, dev)){
3019 if(request_irq(dev->irq, (void *)rtl8192_interrupt, SA_SHIRQ, dev->name, dev)){
3021 printk("Error allocating IRQ %d",dev->irq);
3025 printk("IRQ %d",dev->irq);
3027 if(rtl8192_pci_initdescring(dev)!=0){
3028 printk("Endopoints initialization failed");
3032 //rtl8192_rx_enable(dev);
3033 //rtl8192_adapter_start(dev);
3038 * Actually only set RRSR, RATR and BW_OPMODE registers
3039 * not to do all the hw config as its name says
3040 * This part need to modified according to the rate set we filtered
3042 static void rtl8192_hwconfig(struct net_device* dev)
3044 u32 regRATR = 0, regRRSR = 0;
3045 u8 regBwOpMode = 0, regTmp = 0;
3046 struct r8192_priv *priv = ieee80211_priv(dev);
3048 // Set RRSR, RATR, and BW_OPMODE registers
3050 switch(priv->ieee80211->mode)
3052 case WIRELESS_MODE_B:
3053 regBwOpMode = BW_OPMODE_20MHZ;
3054 regRATR = RATE_ALL_CCK;
3055 regRRSR = RATE_ALL_CCK;
3057 case WIRELESS_MODE_A:
3058 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
3059 regRATR = RATE_ALL_OFDM_AG;
3060 regRRSR = RATE_ALL_OFDM_AG;
3062 case WIRELESS_MODE_G:
3063 regBwOpMode = BW_OPMODE_20MHZ;
3064 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3065 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3067 case WIRELESS_MODE_AUTO:
3068 case WIRELESS_MODE_N_24G:
3069 // It support CCK rate by default.
3070 // CCK rate will be filtered out only when associated AP does not support it.
3071 regBwOpMode = BW_OPMODE_20MHZ;
3072 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3073 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3075 case WIRELESS_MODE_N_5G:
3076 regBwOpMode = BW_OPMODE_5G;
3077 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3078 regRRSR = RATE_ALL_OFDM_AG;
3082 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
3085 ratr_value = regRATR;
3086 if (priv->rf_type == RF_1T2R)
3088 ratr_value &= ~(RATE_ALL_OFDM_2SS);
3090 write_nic_dword(dev, RATR0, ratr_value);
3091 write_nic_byte(dev, UFWP, 1);
3093 regTmp = read_nic_byte(dev, 0x313);
3094 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
3095 write_nic_dword(dev, RRSR, regRRSR);
3098 // Set Retry Limit here
3100 write_nic_word(dev, RETRY_LIMIT,
3101 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT |
3102 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3103 // Set Contention Window here
3107 // Set Tx Antenna including Feedback control
3109 // Set Auto Rate fallback control
3115 static RT_STATUS rtl8192_adapter_start(struct net_device *dev)
3117 struct r8192_priv *priv = ieee80211_priv(dev);
3118 // struct ieee80211_device *ieee = priv->ieee80211;
3120 RT_STATUS rtStatus = RT_STATUS_SUCCESS;
3124 u8 ICVersion,SwitchingRegulatorOutput;
3126 bool bfirmwareok = true;
3130 u32 tmpRegA, tmpRegC, TempCCk;
3133 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3134 priv->being_init_adapter = true;
3135 rtl8192_pci_resetdescring(dev);
3136 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
3137 priv->Rf_Mode = RF_OP_By_SW_3wire;
3140 if(priv->ResetProgress == RESET_TYPE_NORESET)
3142 write_nic_byte(dev, ANAPAR, 0x37);
3143 // Accordign to designer's explain, LBUS active will never > 10ms. We delay 10ms
3144 // Joseph increae the time to prevent firmware download fail
3148 //PlatformSleepUs(10000);
3149 // For any kind of InitializeAdapter process, we shall use system now!!
3150 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3152 // Set to eRfoff in order not to count receive count.
3153 if(priv->RegRfOff == TRUE)
3154 priv->ieee80211->eRFPowerState = eRfOff;
3157 //3 //Config CPUReset Register
3159 //3 Firmware Reset Or Not
3160 ulRegRead = read_nic_dword(dev, CPU_GEN);
3161 if(priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3162 { //called from MPInitialized. do nothing
3163 ulRegRead |= CPU_GEN_SYSTEM_RESET;
3164 }else if(priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3165 ulRegRead |= CPU_GEN_FIRMWARE_RESET; // Called from MPReset
3167 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3170 //2008.06.03, for WOL 90 hw bug
3171 ulRegRead &= (~(CPU_GEN_GPIO_UART));
3174 write_nic_dword(dev, CPU_GEN, ulRegRead);
3180 //3 //Fix the issue of E-cut high temperature issue
3183 ICVersion = read_nic_byte(dev, IC_VERRSION);
3184 if(ICVersion >= 0x4) //E-cut only
3186 // HW SD suggest that we should not wirte this register too often, so driver
3187 // should readback this register. This register will be modified only when
3189 SwitchingRegulatorOutput = read_nic_byte(dev, SWREGULATOR);
3190 if(SwitchingRegulatorOutput != 0xb8)
3192 write_nic_byte(dev, SWREGULATOR, 0xa8);
3194 write_nic_byte(dev, SWREGULATOR, 0xb8);
3201 //3// Initialize BB before MAC
3203 RT_TRACE(COMP_INIT, "BB Config Start!\n");
3204 rtStatus = rtl8192_BBConfig(dev);
3205 if(rtStatus != RT_STATUS_SUCCESS)
3207 RT_TRACE(COMP_ERR, "BB Config failed\n");
3210 RT_TRACE(COMP_INIT,"BB Config Finished!\n");
3212 //3//Set Loopback mode or Normal mode
3214 //2006.12.13 by emily. Note!We should not merge these two CPU_GEN register writings
3215 // because setting of System_Reset bit reset MAC to default transmission mode.
3216 //Loopback mode or not
3217 priv->LoopbackMode = RTL819X_NO_LOOPBACK;
3218 //priv->LoopbackMode = RTL819X_MAC_LOOPBACK;
3219 if(priv->ResetProgress == RESET_TYPE_NORESET)
3221 ulRegRead = read_nic_dword(dev, CPU_GEN);
3222 if(priv->LoopbackMode == RTL819X_NO_LOOPBACK)
3224 ulRegRead = ((ulRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3226 else if (priv->LoopbackMode == RTL819X_MAC_LOOPBACK )
3228 ulRegRead |= CPU_CCK_LOOPBACK;
3232 RT_TRACE(COMP_ERR,"Serious error: wrong loopback mode setting\n");
3235 //2008.06.03, for WOL
3236 //ulRegRead &= (~(CPU_GEN_GPIO_UART));
3237 write_nic_dword(dev, CPU_GEN, ulRegRead);
3239 // 2006.11.29. After reset cpu, we sholud wait for a second, otherwise, it may fail to write registers. Emily
3242 //3Set Hardware(Do nothing now)
3243 rtl8192_hwconfig(dev);
3244 //2=======================================================
3245 // Common Setting for all of the FPGA platform. (part 1)
3246 //2=======================================================
3247 // If there is changes, please make sure it applies to all of the FPGA version
3249 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3253 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3254 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) |
3258 write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3259 (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) ));
3263 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3264 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3266 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3268 //3 Initialize Number of Reserved Pages in Firmware Queue
3270 if(priv->bInHctTest)
3272 PlatformEFIOWrite4Byte(Adapter, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK_DTM << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3273 NUM_OF_PAGE_IN_FW_QUEUE_BE_DTM << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3274 NUM_OF_PAGE_IN_FW_QUEUE_VI_DTM << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3275 NUM_OF_PAGE_IN_FW_QUEUE_VO_DTM <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3276 PlatformEFIOWrite4Byte(Adapter, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3277 PlatformEFIOWrite4Byte(Adapter, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3278 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3279 NUM_OF_PAGE_IN_FW_QUEUE_PUB_DTM<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3284 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3285 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3286 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3287 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3288 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3289 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3290 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3291 NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3294 rtl8192_tx_enable(dev);
3295 rtl8192_rx_enable(dev);
3296 //3Set Response Rate Setting Register
3297 // CCK rate is supported by default.
3298 // CCK rate will be filtered out only when associated AP does not support it.
3299 ulRegRead = (0xFFF00000 & read_nic_dword(dev, RRSR)) | RATE_ALL_OFDM_AG | RATE_ALL_CCK;
3300 write_nic_dword(dev, RRSR, ulRegRead);
3301 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3304 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3305 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3307 //rtl8192_actset_wirelessmode(dev,priv->RegWirelessMode);
3308 if(priv->ResetProgress == RESET_TYPE_NORESET)
3309 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3310 //-----------------------------------------------------------------------------
3311 // Set up security related. 070106, by rcnjko:
3312 // 1. Clear all H/W keys.
3313 // 2. Enable H/W encryption/decryption.
3314 //-----------------------------------------------------------------------------
3315 CamResetAllEntry(dev);
3317 u8 SECR_value = 0x0;
3318 SECR_value |= SCR_TxEncEnable;
3319 SECR_value |= SCR_RxDecEnable;
3320 SECR_value |= SCR_NoSKMC;
3321 write_nic_byte(dev, SECR, SECR_value);
3324 write_nic_word(dev, ATIMWND, 2);
3325 write_nic_word(dev, BCN_INTERVAL, 100);
3326 for (i=0; i<QOS_QUEUE_NUM; i++)
3327 write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
3329 // Switching regulator controller: This is set temporarily.
3330 // It's not sure if this can be removed in the future.
3331 // PJ advised to leave it by default.
3333 write_nic_byte(dev, 0xbe, 0xc0);
3335 //2=======================================================
3336 // Set PHY related configuration defined in MAC register bank
3337 //2=======================================================
3338 rtl8192_phy_configmac(dev);
3340 if (priv->card_8192_version > (u8) VERSION_8190_BD) {
3341 rtl8192_phy_getTxPower(dev);
3342 rtl8192_phy_setTxPower(dev, priv->chan);
3346 tmpvalue = read_nic_byte(dev, IC_VERRSION);
3347 priv->IC_Cut = tmpvalue;
3348 RT_TRACE(COMP_INIT, "priv->IC_Cut = 0x%x\n", priv->IC_Cut);
3349 if(priv->IC_Cut >= IC_VersionCut_D)
3351 //pHalData->bDcut = TRUE;
3352 if(priv->IC_Cut == IC_VersionCut_D)
3353 RT_TRACE(COMP_INIT, "D-cut\n");
3354 if(priv->IC_Cut == IC_VersionCut_E)
3356 RT_TRACE(COMP_INIT, "E-cut\n");
3357 // HW SD suggest that we should not wirte this register too often, so driver
3358 // should readback this register. This register will be modified only when
3364 //pHalData->bDcut = FALSE;
3365 RT_TRACE(COMP_INIT, "Before C-cut\n");
3370 RT_TRACE(COMP_INIT, "Load Firmware!\n");
3371 bfirmwareok = init_firmware(dev);
3372 if(bfirmwareok != true) {
3373 rtStatus = RT_STATUS_FAILURE;
3376 RT_TRACE(COMP_INIT, "Load Firmware finished!\n");
3379 if(priv->ResetProgress == RESET_TYPE_NORESET)
3381 RT_TRACE(COMP_INIT, "RF Config Started!\n");
3382 rtStatus = rtl8192_phy_RFConfig(dev);
3383 if(rtStatus != RT_STATUS_SUCCESS)
3385 RT_TRACE(COMP_ERR, "RF Config failed\n");
3388 RT_TRACE(COMP_INIT, "RF Config Finished!\n");
3390 rtl8192_phy_updateInitGain(dev);
3392 /*---- Set CCK and OFDM Block "ON"----*/
3393 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3394 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3398 write_nic_byte(dev, 0x87, 0x0);
3401 //2008.06.03, for WOL
3402 ucRegRead = read_nic_byte(dev, GPE);
3404 write_nic_byte(dev, GPE, ucRegRead);
3406 ucRegRead = read_nic_byte(dev, GPO);
3408 write_nic_byte(dev, GPO, ucRegRead);
3411 //2=======================================================
3413 //2=======================================================
3417 if(priv->RegRfOff == TRUE)
3418 { // User disable RF via registry.
3419 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RegRfOff ----------\n",__FUNCTION__);
3420 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW);
3421 #if 0//cosa, ask SD3 willis and he doesn't know what is this for
3422 // Those action will be discard in MgntActSet_RF_State because off the same state
3423 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3424 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3427 else if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS)
3428 { // H/W or S/W RF OFF before sleep.
3429 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3430 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3432 else if(priv->ieee80211->RfOffReason >= RF_CHANGE_BY_IPS)
3433 { // H/W or S/W RF OFF before sleep.
3434 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3435 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3439 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): RF-ON \n",__FUNCTION__);
3440 priv->ieee80211->eRFPowerState = eRfOn;
3441 priv->ieee80211->RfOffReason = 0;
3442 //DrvIFIndicateCurrentPhyStatus(Adapter);
3444 //Adapter->HalFunc.LedControlHandler(Adapter, LED_CTL_POWER_ON);
3447 // If inactive power mode is enabled, disable rf while in disconnected state.
3448 // But we should still tell upper layer we are in rf on state.
3449 // 2007.07.16, by shien chang.
3451 //if(!Adapter->bInHctTest)
3452 //IPSEnter(Adapter);
3459 // We can force firmware to do RF-R/W
3460 if(priv->ieee80211->FwRWRF)
3461 priv->Rf_Mode = RF_OP_By_FW;
3463 priv->Rf_Mode = RF_OP_By_SW_3wire;
3465 priv->Rf_Mode = RF_OP_By_SW_3wire;
3469 if(priv->ResetProgress == RESET_TYPE_NORESET)
3471 dm_initialize_txpower_tracking(dev);
3473 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3474 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3476 if(priv->rf_type == RF_2T4R){
3477 for(i = 0; i<TxBBGainTableLength; i++)
3479 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3481 priv->rfa_txpowertrackingindex= (u8)i;
3482 priv->rfa_txpowertrackingindex_real= (u8)i;
3483 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3488 for(i = 0; i<TxBBGainTableLength; i++)
3490 if(tmpRegC == priv->txbbgain_table[i].txbbgain_value)
3492 priv->rfc_txpowertrackingindex= (u8)i;
3493 priv->rfc_txpowertrackingindex_real= (u8)i;
3494 priv->rfc_txpowertracking_default = priv->rfc_txpowertrackingindex;
3498 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3500 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3502 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3504 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3508 priv->CCKPresentAttentuation_40Mdefault = 0;
3509 priv->CCKPresentAttentuation_difference = 0;
3510 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3511 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3512 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3513 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_initial = %d\n", priv->rfc_txpowertrackingindex);
3514 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_real_initial = %d\n", priv->rfc_txpowertrackingindex_real);
3515 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3516 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3520 if(priv->ResetProgress == RESET_TYPE_NORESET)
3522 dm_initialize_txpower_tracking(dev);
3524 if(priv->IC_Cut >= IC_VersionCut_D)
3526 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3527 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3528 for(i = 0; i<TxBBGainTableLength; i++)
3530 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3532 priv->rfa_txpowertrackingindex= (u8)i;
3533 priv->rfa_txpowertrackingindex_real= (u8)i;
3534 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3539 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3541 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3543 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3545 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3549 priv->CCKPresentAttentuation_40Mdefault = 0;
3550 priv->CCKPresentAttentuation_difference = 0;
3551 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3552 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3553 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3554 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3555 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3556 priv->btxpower_tracking = FALSE;//TEMPLY DISABLE
3561 rtl8192_irq_enable(dev);
3562 priv->being_init_adapter = false;
3567 static void rtl8192_prepare_beacon(struct r8192_priv *priv)
3569 struct sk_buff *skb;
3570 //unsigned long flags;
3573 skb = ieee80211_get_beacon(priv->ieee80211);
3574 tcb_desc = (cb_desc *)(skb->cb + 8);
3575 //spin_lock_irqsave(&priv->tx_lock,flags);
3576 /* prepare misc info for the beacon xmit */
3577 tcb_desc->queue_index = BEACON_QUEUE;
3578 /* IBSS does not support HT yet, use 1M defaultly */
3579 tcb_desc->data_rate = 2;
3580 tcb_desc->RATRIndex = 7;
3581 tcb_desc->bTxDisableRateFallBack = 1;
3582 tcb_desc->bTxUseDriverAssingedRate = 1;
3584 skb_push(skb, priv->ieee80211->tx_headroom);
3586 rtl8192_tx(priv->ieee80211->dev,skb);
3588 //spin_unlock_irqrestore (&priv->tx_lock, flags);
3593 * configure registers for beacon tx and enables it via
3594 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3595 * be used to stop beacon transmission
3597 static void rtl8192_start_beacon(struct net_device *dev)
3599 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3600 struct ieee80211_network *net = &priv->ieee80211->current_network;
3605 DMESG("Enabling beacon TX");
3606 //rtl8192_prepare_beacon(dev);
3607 rtl8192_irq_disable(dev);
3608 //rtl8192_beacon_tx_enable(dev);
3611 write_nic_word(dev, ATIMWND, 2);
3613 /* Beacon interval (in unit of TU) */
3614 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
3617 * DrvErlyInt (in unit of TU).
3618 * (Time to send interrupt to notify driver to c
3619 * hange beacon content)
3621 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
3624 * BcnDMATIM(in unit of us).
3625 * Indicates the time before TBTT to perform beacon queue DMA
3627 write_nic_word(dev, BCN_DMATIME, 256);
3630 * Force beacon frame transmission even after receiving
3631 * beacon frame from other ad hoc STA
3633 write_nic_byte(dev, BCN_ERR_THRESH, 100);
3635 /* Set CW and IFS */
3636 BcnTimeCfg |= BcnCW<<BCN_TCFG_CW_SHIFT;
3637 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
3638 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
3641 /* enable the interrupt for ad-hoc process */
3642 rtl8192_irq_enable(dev);
3645 static bool HalTxCheckStuck8190Pci(struct net_device *dev)
3647 u16 RegTxCounter = read_nic_word(dev, 0x128);
3648 struct r8192_priv *priv = ieee80211_priv(dev);
3649 bool bStuck = FALSE;
3650 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3651 if(priv->TxCounter==RegTxCounter)
3654 priv->TxCounter = RegTxCounter;
3660 * Assumption: RT_TX_SPINLOCK is acquired.
3663 TxCheckStuck(struct net_device *dev)
3665 struct r8192_priv *priv = ieee80211_priv(dev);
3667 ptx_ring head=NULL,tail=NULL,txring = NULL;
3668 u8 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3669 bool bCheckFwTxCnt = false;
3672 // Decide Stuch threshold according to current power save mode
3674 switch (priv->ieee80211->dot11PowerSaveMode)
3676 // The threshold value may required to be adjusted .
3677 case eActive: // Active/Continuous access.
3678 ResetThreshold = NIC_SEND_HANG_THRESHOLD_NORMAL;
3680 case eMaxPs: // Max power save mode.
3681 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3683 case eFastPs: // Fast power save mode.
3684 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3689 // Check whether specific tcb has been queued for a specific time
3691 for(QueueID = 0; QueueID < MAX_TX_QUEUE; QueueID++)
3695 if(QueueID == TXCMD_QUEUE)
3700 tail=priv->txmapringtail;
3701 head=priv->txmapringhead;
3705 tail=priv->txbkpringtail;
3706 head=priv->txbkpringhead;
3710 tail=priv->txbepringtail;
3711 head=priv->txbepringhead;
3715 tail=priv->txvipringtail;
3716 head=priv->txvipringhead;
3720 tail=priv->txvopringtail;
3721 head=priv->txvopringhead;
3736 RT_TRACE(COMP_ERR,"%s():txring is NULL , BUG!\n",__FUNCTION__);
3739 txring->nStuckCount++;
3740 bCheckFwTxCnt = TRUE;
3746 if(HalTxCheckStuck8190Pci(dev))
3748 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3749 return RESET_TYPE_SILENT;
3753 return RESET_TYPE_NORESET;
3757 static bool HalRxCheckStuck8190Pci(struct net_device *dev)
3759 struct r8192_priv *priv = ieee80211_priv(dev);
3760 u16 RegRxCounter = read_nic_word(dev, 0x130);
3761 bool bStuck = FALSE;
3762 static u8 rx_chk_cnt = 0;
3763 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3764 // If rssi is small, we should check rx for long time because of bad rx.
3765 // or maybe it will continuous silent reset every 2 seconds.
3767 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3769 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
3771 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3772 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3773 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
3785 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
3786 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
3787 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
3791 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3797 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3804 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
3810 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
3813 if(priv->RxCounter==RegRxCounter)
3816 priv->RxCounter = RegRxCounter;
3821 static RESET_TYPE RxCheckStuck(struct net_device *dev)
3824 if(HalRxCheckStuck8190Pci(dev))
3826 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
3827 return RESET_TYPE_SILENT;
3830 return RESET_TYPE_NORESET;
3834 rtl819x_ifcheck_resetornot(struct net_device *dev)
3836 struct r8192_priv *priv = ieee80211_priv(dev);
3837 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
3838 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
3839 RT_RF_POWER_STATE rfState;
3841 rfState = priv->ieee80211->eRFPowerState;
3843 TxResetType = TxCheckStuck(dev);
3845 if( rfState != eRfOff &&
3846 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3847 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
3849 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3850 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3851 // if driver is in firmware download failure status, driver should initialize RF in the following
3852 // silent reset procedure Emily, 2008.01.21
3854 // Driver should not check RX stuck in IBSS mode because it is required to
3855 // set Check BSSID in order to send beacon, however, if check BSSID is
3856 // set, STA cannot hear any packet a all. Emily, 2008.04.12
3857 RxResetType = RxCheckStuck(dev);
3861 RT_TRACE(COMP_RESET,"%s(): TxResetType is %d, RxResetType is %d\n",__FUNCTION__,TxResetType,RxResetType);
3862 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
3863 return RESET_TYPE_NORMAL;
3864 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT)
3865 return RESET_TYPE_SILENT;
3867 return RESET_TYPE_NORESET;
3872 static void CamRestoreAllEntry(struct net_device *dev)
3875 struct r8192_priv *priv = ieee80211_priv(dev);
3876 const u8* MacAddr = priv->ieee80211->current_network.bssid;
3878 static const u8 CAM_CONST_ADDR[4][6] = {
3879 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3880 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3881 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3882 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3883 static const u8 CAM_CONST_BROAD[] =
3884 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3886 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3889 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
3890 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
3893 for(EntryId=0; EntryId<4; EntryId++)
3896 MacAddr = CAM_CONST_ADDR[EntryId];
3900 priv->ieee80211->pairwise_key_type,
3908 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
3912 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3916 priv->ieee80211->pairwise_key_type,
3924 priv->ieee80211->pairwise_key_type,
3930 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
3934 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3938 priv->ieee80211->pairwise_key_type,
3946 priv->ieee80211->pairwise_key_type,
3955 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
3957 MacAddr = CAM_CONST_BROAD;
3958 for(EntryId=1 ; EntryId<4 ; EntryId++)
3964 priv->ieee80211->group_key_type,
3970 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3974 priv->ieee80211->group_key_type,
3979 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
3981 MacAddr = CAM_CONST_BROAD;
3982 for(EntryId=1; EntryId<4 ; EntryId++)
3988 priv->ieee80211->group_key_type,
3995 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3999 priv->ieee80211->group_key_type,
4007 * This function is used to fix Tx/Rx stop bug temporarily.
4008 * This function will do "system reset" to NIC when Tx or Rx is stuck.
4009 * The method checking Tx/Rx stuck of this function is supported by FW,
4010 * which reports Tx and Rx counter to register 0x128 and 0x130.
4012 static void rtl819x_ifsilentreset(struct net_device *dev)
4014 struct r8192_priv *priv = ieee80211_priv(dev);
4016 int reset_status = 0;
4017 struct ieee80211_device *ieee = priv->ieee80211;
4022 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
4023 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
4025 if(priv->ResetProgress==RESET_TYPE_NORESET)
4029 //LZM for PS-Poll AID issue. 090429
4030 if(priv->ieee80211->state == IEEE80211_LINKED)
4031 LeisurePSLeave(dev);
4034 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
4036 // Set the variable for reset.
4037 priv->ResetProgress = RESET_TYPE_SILENT;
4038 // rtl8192_close(dev);
4040 down(&priv->wx_sem);
4043 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
4048 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
4049 if(!netif_queue_stopped(dev))
4050 netif_stop_queue(dev);
4052 dm_backup_dynamic_mechanism_state(dev);
4054 rtl8192_irq_disable(dev);
4055 rtl8192_cancel_deferred_work(priv);
4057 del_timer_sync(&priv->watch_dog_timer);
4058 ieee->sync_scan_hurryup = 1;
4059 if(ieee->state == IEEE80211_LINKED)
4061 down(&ieee->wx_sem);
4062 printk("ieee->state is IEEE80211_LINKED\n");
4063 ieee80211_stop_send_beacons(priv->ieee80211);
4064 del_timer_sync(&ieee->associate_timer);
4065 cancel_delayed_work(&ieee->associate_retry_wq);
4066 ieee80211_stop_scan(ieee);
4070 printk("ieee->state is NOT LINKED\n");
4071 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4073 rtl8192_halt_adapter(dev, true);
4075 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
4076 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
4077 reset_status = _rtl8192_up(dev);
4079 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
4080 if(reset_status == -1)
4089 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n",__FUNCTION__);
4093 ieee->is_silent_reset = 1;
4095 EnableHWSecurityConfig8192(dev);
4097 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4099 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4102 queue_work(ieee->wq, &ieee->associate_complete_wq);
4106 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
4108 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4109 ieee->link_change(ieee->dev);
4111 // notify_wx_assoc_event(ieee);
4113 ieee80211_start_send_beacons(ieee);
4115 if (ieee->data_hard_resume)
4116 ieee->data_hard_resume(ieee->dev);
4117 netif_carrier_on(ieee->dev);
4121 CamRestoreAllEntry(dev);
4123 // Restore the previous setting for all dynamic mechanism
4124 dm_restore_dynamic_mechanism_state(dev);
4126 priv->ResetProgress = RESET_TYPE_NORESET;
4127 priv->reset_count++;
4129 priv->bForcedSilentReset =false;
4130 priv->bResetInProgress = false;
4132 // For test --> force write UFWP.
4133 write_nic_byte(dev, UFWP, 1);
4134 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4140 void InactivePsWorkItemCallback(struct net_device *dev)
4142 struct r8192_priv *priv = ieee80211_priv(dev);
4143 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4145 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() ---------> \n");
4147 // This flag "bSwRfProcessing", indicates the status of IPS procedure, should be set if the IPS workitem
4148 // is really scheduled.
4149 // The old code, sets this flag before scheduling the IPS workitem and however, at the same time the
4150 // previous IPS workitem did not end yet, fails to schedule the current workitem. Thus, bSwRfProcessing
4151 // blocks the IPS procedure of switching RF.
4152 // By Bruce, 2007-12-25.
4154 pPSC->bSwRfProcessing = TRUE;
4156 RT_TRACE(COMP_RF, "InactivePsWorkItemCallback(): Set RF to %s.\n",
4157 pPSC->eInactivePowerState == eRfOff?"OFF":"ON");
4160 MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
4163 // To solve CAM values miss in RF OFF, rewrite CAM values after RF ON. By Bruce, 2007-09-20.
4165 pPSC->bSwRfProcessing = FALSE;
4166 RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() <--------- \n");
4170 /* Change current and default preamble mode. */
4171 bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev, u8 rtPsMode)
4173 struct r8192_priv *priv = ieee80211_priv(dev);
4175 // Currently, we do not change power save mode on IBSS mode.
4176 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4182 // <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
4183 // some AP will not response to our mgnt frames with PwrMgt bit set,
4184 // e.g. cannot associate the AP.
4185 // So I commented out it. 2005.02.16, by rcnjko.
4187 // // Change device's power save mode.
4188 // Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
4190 // Update power save mode configured.
4191 //RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__FUNCTION__,rtPsMode);
4192 if(!priv->ps_force) {
4193 priv->ieee80211->ps = rtPsMode;
4196 // Awake immediately
4197 if(priv->ieee80211->sta_sleep != 0 && rtPsMode == IEEE80211_PS_DISABLED)
4199 unsigned long flags;
4201 //PlatformSetTimer(Adapter, &(pMgntInfo->AwakeTimer), 0);
4202 // Notify the AP we awke.
4203 rtl8192_hw_wakeup(dev);
4204 priv->ieee80211->sta_sleep = 0;
4206 spin_lock_irqsave(&(priv->ieee80211->mgmt_tx_lock), flags);
4207 printk("LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
4208 ieee80211_sta_ps_send_null_frame(priv->ieee80211, 0);
4209 spin_unlock_irqrestore(&(priv->ieee80211->mgmt_tx_lock), flags);
4215 /* Enter the leisure power save mode. */
4216 void LeisurePSEnter(struct net_device *dev)
4218 struct r8192_priv *priv = ieee80211_priv(dev);
4219 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4221 //RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
4222 //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
4223 // pPSC->bLeisurePs, priv->ieee80211->ps,pPSC->LpsIdleCount,RT_CHECK_FOR_HANG_PERIOD);
4225 if(!((priv->ieee80211->iw_mode == IW_MODE_INFRA) &&
4226 (priv->ieee80211->state == IEEE80211_LINKED)) ||
4227 (priv->ieee80211->iw_mode == IW_MODE_ADHOC) ||
4228 (priv->ieee80211->iw_mode == IW_MODE_MASTER))
4231 if (pPSC->bLeisurePs)
4233 // Idle for a while if we connect to AP a while ago.
4234 if(pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) // 4 Sec
4237 if(priv->ieee80211->ps == IEEE80211_PS_DISABLED)
4240 //RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter 802.11 power save mode...\n");
4241 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST);
4246 pPSC->LpsIdleCount++;
4251 /* Leave leisure power save mode. */
4252 void LeisurePSLeave(struct net_device *dev)
4254 struct r8192_priv *priv = ieee80211_priv(dev);
4255 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4257 if (pPSC->bLeisurePs)
4259 if(priv->ieee80211->ps != IEEE80211_PS_DISABLED)
4261 // move to lps_wakecomplete()
4262 //RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n");
4263 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_DISABLED);
4271 /* Enter the inactive power save mode. RF will be off */
4273 IPSEnter(struct net_device *dev)
4275 struct r8192_priv *priv = ieee80211_priv(dev);
4276 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4277 RT_RF_POWER_STATE rtState;
4279 if (pPSC->bInactivePs)
4281 rtState = priv->ieee80211->eRFPowerState;
4283 // Added by Bruce, 2007-12-25.
4284 // Do not enter IPS in the following conditions:
4285 // (1) RF is already OFF or Sleep
4286 // (2) bSwRfProcessing (indicates the IPS is still under going)
4287 // (3) Connectted (only disconnected can trigger IPS)
4288 // (4) IBSS (send Beacon)
4289 // (5) AP mode (send Beacon)
4291 if (rtState == eRfOn && !pPSC->bSwRfProcessing
4292 && (priv->ieee80211->state != IEEE80211_LINKED) )
4294 RT_TRACE(COMP_RF,"IPSEnter(): Turn off RF.\n");
4295 //printk("IPSEnter(): Turn off RF.\n");
4296 pPSC->eInactivePowerState = eRfOff;
4297 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4298 InactivePsWorkItemCallback(dev);
4305 // Leave the inactive power save mode, RF will be on.
4306 // 2007.08.17, by shien chang.
4309 IPSLeave(struct net_device *dev)
4311 struct r8192_priv *priv = ieee80211_priv(dev);
4312 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4313 RT_RF_POWER_STATE rtState;
4315 if (pPSC->bInactivePs)
4317 rtState = priv->ieee80211->eRFPowerState;
4318 if (rtState != eRfOn && !pPSC->bSwRfProcessing && priv->ieee80211->RfOffReason <= RF_CHANGE_BY_IPS)
4320 RT_TRACE(COMP_POWER, "IPSLeave(): Turn on RF.\n");
4321 //printk("IPSLeave(): Turn on RF.\n");
4322 pPSC->eInactivePowerState = eRfOn;
4323 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4324 InactivePsWorkItemCallback(dev);
4329 void IPSLeave_wq(void *data)
4331 struct ieee80211_device *ieee = container_of(data,struct ieee80211_device,ips_leave_wq);
4332 struct net_device *dev = ieee->dev;
4334 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4335 down(&priv->ieee80211->ips_sem);
4337 up(&priv->ieee80211->ips_sem);
4340 void ieee80211_ips_leave_wq(struct net_device *dev)
4342 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4343 RT_RF_POWER_STATE rtState;
4344 rtState = priv->ieee80211->eRFPowerState;
4346 if(priv->ieee80211->PowerSaveControl.bInactivePs){
4347 if(rtState == eRfOff){
4348 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
4350 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
4354 printk("=========>%s(): IPSLeave\n",__FUNCTION__);
4355 queue_work(priv->ieee80211->wq,&priv->ieee80211->ips_leave_wq);
4360 //added by amy 090331 end
4361 void ieee80211_ips_leave(struct net_device *dev)
4363 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4364 down(&priv->ieee80211->ips_sem);
4366 up(&priv->ieee80211->ips_sem);
4370 static void rtl819x_update_rxcounts(
4371 struct r8192_priv *priv,
4380 *TotalRxDataNum = 0;
4382 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4383 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4384 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4385 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4386 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4387 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4392 static void rtl819x_watchdog_wqcallback(struct work_struct *work)
4394 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4395 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4396 struct net_device *dev = priv->ieee80211->dev;
4397 struct ieee80211_device* ieee = priv->ieee80211;
4398 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4399 static u8 check_reset_cnt=0;
4400 unsigned long flags;
4401 bool bBusyTraffic = false;
4402 static u8 last_time = 0;
4403 bool bEnterPS = false;
4405 if ((!priv->up) || priv->bHwRadioOff)
4410 hal_dm_watchdog(dev);
4412 // printk("watch_dog ENABLE_IPS\n");
4413 if(ieee->actscanning == false){
4414 //printk("%d,%d,%d,%d\n", ieee->eRFPowerState, ieee->is_set_key, ieee->proto_stoppping, ieee->wx_set_enc);
4415 if((ieee->iw_mode == IW_MODE_INFRA) && (ieee->state == IEEE80211_NOLINK) &&
4416 (ieee->eRFPowerState == eRfOn)&&!ieee->is_set_key &&
4417 (!ieee->proto_stoppping) && !ieee->wx_set_enc){
4418 if(ieee->PowerSaveControl.ReturnPoint == IPS_CALLBACK_NONE){
4419 //printk("====================>haha:IPSEnter()\n");
4421 //ieee80211_stop_scan(priv->ieee80211);
4426 {//to get busy traffic condition
4427 if(ieee->state == IEEE80211_LINKED)
4429 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 100 ||
4430 ieee->LinkDetectInfo.NumTxOkInPeriod> 100 ) {
4431 bBusyTraffic = true;
4435 //added by amy for Leisure PS
4436 if( ((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod + ieee->LinkDetectInfo.NumTxOkInPeriod) > 8 ) ||
4437 (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2) )
4439 //printk("ieee->LinkDetectInfo.NumRxUnicastOkInPeriod is %d,ieee->LinkDetectInfo.NumTxOkInPeriod is %d\n",
4440 // ieee->LinkDetectInfo.NumRxUnicastOkInPeriod,ieee->LinkDetectInfo.NumTxOkInPeriod);
4448 //printk("***bEnterPS = %d\n", bEnterPS);
4449 // LeisurePS only work in infra mode.
4452 LeisurePSEnter(dev);
4456 LeisurePSLeave(dev);
4464 //RT_TRACE(COMP_LPS,"====>no link LPS leave\n");
4465 LeisurePSLeave(dev);
4469 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4470 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4471 ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
4472 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4476 //added by amy for AP roaming
4479 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4481 u32 TotalRxBcnNum = 0;
4482 u32 TotalRxDataNum = 0;
4484 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4485 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4487 if( ieee->eRFPowerState == eRfOff)
4488 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4489 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4490 // Dot11d_Reset(dev);
4491 ieee->state = IEEE80211_ASSOCIATING;
4492 notify_wx_assoc_event(priv->ieee80211);
4493 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4494 ieee->is_roaming = true;
4495 ieee->is_set_key = false;
4496 ieee->link_change(dev);
4497 queue_work(ieee->wq, &ieee->associate_procedure_wq);
4500 ieee->LinkDetectInfo.NumRecvBcnInPeriod=0;
4501 ieee->LinkDetectInfo.NumRecvDataInPeriod=0;
4504 //check if reset the driver
4505 spin_lock_irqsave(&priv->tx_lock,flags);
4506 if(check_reset_cnt++ >= 3 && !ieee->is_roaming && (last_time != 1))
4508 ResetType = rtl819x_ifcheck_resetornot(dev);
4509 check_reset_cnt = 3;
4510 //DbgPrint("Start to check silent reset\n");
4512 spin_unlock_irqrestore(&priv->tx_lock,flags);
4513 if(!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_NORMAL)
4515 priv->ResetProgress = RESET_TYPE_NORMAL;
4516 RT_TRACE(COMP_RESET,"%s(): NOMAL RESET\n",__FUNCTION__);
4519 /* disable silent reset temply 2008.9.11*/
4521 if( ((priv->force_reset) || (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT))) // This is control by OID set in Pomelo
4524 rtl819x_ifsilentreset(dev);
4529 priv->force_reset = false;
4530 priv->bForcedSilentReset = false;
4531 priv->bResetInProgress = false;
4532 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4536 void watch_dog_timer_callback(unsigned long data)
4538 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4539 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq,0);
4540 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4544 static int _rtl8192_up(struct net_device *dev)
4546 struct r8192_priv *priv = ieee80211_priv(dev);
4548 RT_STATUS init_status = RT_STATUS_SUCCESS;
4550 priv->ieee80211->ieee_up=1;
4551 priv->bdisable_nic = false; //YJ,add,091111
4552 RT_TRACE(COMP_INIT, "Bringing up iface");
4554 init_status = rtl8192_adapter_start(dev);
4555 if(init_status != RT_STATUS_SUCCESS)
4557 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
4560 RT_TRACE(COMP_INIT, "start adapter finished\n");
4562 if(priv->ieee80211->eRFPowerState!=eRfOn)
4563 MgntActSet_RF_State(dev, eRfOn, priv->ieee80211->RfOffReason);
4565 if(priv->ieee80211->state != IEEE80211_LINKED)
4566 ieee80211_softmac_start_protocol(priv->ieee80211);
4567 ieee80211_reset_queue(priv->ieee80211);
4568 watch_dog_timer_callback((unsigned long) dev);
4569 if(!netif_queue_stopped(dev))
4570 netif_start_queue(dev);
4572 netif_wake_queue(dev);
4578 static int rtl8192_open(struct net_device *dev)
4580 struct r8192_priv *priv = ieee80211_priv(dev);
4583 down(&priv->wx_sem);
4584 ret = rtl8192_up(dev);
4591 int rtl8192_up(struct net_device *dev)
4593 struct r8192_priv *priv = ieee80211_priv(dev);
4595 if (priv->up == 1) return -1;
4597 return _rtl8192_up(dev);
4601 static int rtl8192_close(struct net_device *dev)
4603 struct r8192_priv *priv = ieee80211_priv(dev);
4606 down(&priv->wx_sem);
4608 ret = rtl8192_down(dev);
4616 int rtl8192_down(struct net_device *dev)
4618 struct r8192_priv *priv = ieee80211_priv(dev);
4620 if (priv->up == 0) return -1;
4623 //LZM for PS-Poll AID issue. 090429
4624 if(priv->ieee80211->state == IEEE80211_LINKED)
4625 LeisurePSLeave(dev);
4629 priv->ieee80211->ieee_up = 0;
4630 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4632 if (!netif_queue_stopped(dev))
4633 netif_stop_queue(dev);
4635 rtl8192_irq_disable(dev);
4636 rtl8192_cancel_deferred_work(priv);
4638 del_timer_sync(&priv->watch_dog_timer);
4640 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4642 rtl8192_halt_adapter(dev,false);
4643 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4645 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4651 void rtl8192_commit(struct net_device *dev)
4653 struct r8192_priv *priv = ieee80211_priv(dev);
4655 if (priv->up == 0) return ;
4658 ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4660 rtl8192_irq_disable(dev);
4661 rtl8192_halt_adapter(dev,true);
4665 static void rtl8192_restart(struct work_struct *work)
4667 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4668 struct net_device *dev = priv->ieee80211->dev;
4670 down(&priv->wx_sem);
4672 rtl8192_commit(dev);
4677 static void r8192_set_multicast(struct net_device *dev)
4679 struct r8192_priv *priv = ieee80211_priv(dev);
4682 //down(&priv->wx_sem);
4686 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4688 if (promisc != priv->promisc) {
4690 // rtl8192_commit(dev);
4693 priv->promisc = promisc;
4695 //schedule_work(&priv->reset_wq);
4696 //up(&priv->wx_sem);
4700 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
4702 struct r8192_priv *priv = ieee80211_priv(dev);
4703 struct sockaddr *addr = mac;
4705 down(&priv->wx_sem);
4707 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4709 schedule_work(&priv->reset_wq);
4715 /* based on ipw2200 driver */
4716 static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4718 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4719 struct iwreq *wrq = (struct iwreq *)rq;
4721 struct ieee80211_device *ieee = priv->ieee80211;
4723 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4724 struct iw_point *p = &wrq->u.data;
4725 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
4727 down(&priv->wx_sem);
4730 if (p->length < sizeof(struct ieee_param) || !p->pointer){
4735 ipw = kmalloc(p->length, GFP_KERNEL);
4740 if (copy_from_user(ipw, p->pointer, p->length)) {
4747 case RTL_IOCTL_WPA_SUPPLICANT:
4748 //parse here for HW security
4749 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
4751 if (ipw->u.crypt.set_tx)
4753 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4754 ieee->pairwise_key_type = KEY_TYPE_CCMP;
4755 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4756 ieee->pairwise_key_type = KEY_TYPE_TKIP;
4757 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4759 if (ipw->u.crypt.key_len == 13)
4760 ieee->pairwise_key_type = KEY_TYPE_WEP104;
4761 else if (ipw->u.crypt.key_len == 5)
4762 ieee->pairwise_key_type = KEY_TYPE_WEP40;
4765 ieee->pairwise_key_type = KEY_TYPE_NA;
4767 if (ieee->pairwise_key_type)
4769 memcpy((u8*)key, ipw->u.crypt.key, 16);
4770 EnableHWSecurityConfig8192(dev);
4771 //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!
4773 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4774 if (ieee->auth_mode != 2) //LEAP WEP will never set this.
4775 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4777 if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) && ieee->pHTInfo->bCurrentHTSupport){
4778 write_nic_byte(dev, 0x173, 1); //fix aes bug
4782 else //if (ipw->u.crypt.idx) //group key use idx > 0
4784 memcpy((u8*)key, ipw->u.crypt.key, 16);
4785 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4786 ieee->group_key_type= KEY_TYPE_CCMP;
4787 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4788 ieee->group_key_type = KEY_TYPE_TKIP;
4789 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4791 if (ipw->u.crypt.key_len == 13)
4792 ieee->group_key_type = KEY_TYPE_WEP104;
4793 else if (ipw->u.crypt.key_len == 5)
4794 ieee->group_key_type = KEY_TYPE_WEP40;
4797 ieee->group_key_type = KEY_TYPE_NA;
4799 if (ieee->group_key_type)
4803 ipw->u.crypt.idx, //KeyIndex
4804 ieee->group_key_type, //KeyType
4805 broadcast_addr, //MacAddr
4815 printk("@@ wrq->u pointer = ");
4816 for(i=0;i<wrq->u.data.length;i++){
4817 if(i%10==0) printk("\n");
4818 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
4822 #endif /*JOHN_DEBUG*/
4823 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
4838 static u8 HwRateToMRate90(bool bIsHT, u8 rate)
4844 case DESC90_RATE1M: ret_rate = MGN_1M; break;
4845 case DESC90_RATE2M: ret_rate = MGN_2M; break;
4846 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
4847 case DESC90_RATE11M: ret_rate = MGN_11M; break;
4848 case DESC90_RATE6M: ret_rate = MGN_6M; break;
4849 case DESC90_RATE9M: ret_rate = MGN_9M; break;
4850 case DESC90_RATE12M: ret_rate = MGN_12M; break;
4851 case DESC90_RATE18M: ret_rate = MGN_18M; break;
4852 case DESC90_RATE24M: ret_rate = MGN_24M; break;
4853 case DESC90_RATE36M: ret_rate = MGN_36M; break;
4854 case DESC90_RATE48M: ret_rate = MGN_48M; break;
4855 case DESC90_RATE54M: ret_rate = MGN_54M; break;
4858 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
4864 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
4865 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
4866 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
4867 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
4868 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
4869 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
4870 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
4871 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
4872 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
4873 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
4874 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
4875 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
4876 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
4877 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
4878 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
4879 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
4880 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
4883 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
4891 /* Record the TSF time stamp when receiving a packet */
4892 static void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
4894 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4896 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
4897 stats->mac_time[0] = priv->LastRxDescTSFLow;
4898 stats->mac_time[1] = priv->LastRxDescTSFHigh;
4900 priv->LastRxDescTSFLow = stats->mac_time[0];
4901 priv->LastRxDescTSFHigh = stats->mac_time[1];
4905 static long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
4907 long signal_power; // in dBm.
4909 // Translate to dBm (x=0.5y-95).
4910 signal_power = (long)((signal_strength_index + 1) >> 1);
4913 return signal_power;
4917 * Update Rx signal related information in the packet reeived
4918 * to RxStats. User application can query RxStats to realize
4919 * current Rx signal status.
4921 * In normal operation, user only care about the information of the BSS
4922 * and we shall invoke this function if the packet received is from the BSS.
4925 rtl819x_update_rxsignalstatistics8190pci(
4926 struct r8192_priv * priv,
4927 struct ieee80211_rx_stats * pprevious_stats
4932 //2 <ToDo> Update Rx Statistics (such as signal strength and signal quality).
4935 if(priv->stats.recv_signal_power == 0)
4936 priv->stats.recv_signal_power = pprevious_stats->RecvSignalPower;
4938 // To avoid the past result restricting the statistics sensitivity, weight the current power (5/6) to speed up the
4939 // reaction of smoothed Signal Power.
4940 if(pprevious_stats->RecvSignalPower > priv->stats.recv_signal_power)
4942 else if(pprevious_stats->RecvSignalPower < priv->stats.recv_signal_power)
4945 // We need more correct power of received packets and the "SignalStrength" of RxStats have been beautified or translated,
4946 // so we record the correct power in Dbm here. By Bruce, 2008-03-07.
4948 priv->stats.recv_signal_power = (priv->stats.recv_signal_power * 5 + pprevious_stats->RecvSignalPower + weighting) / 6;
4952 rtl8190_process_cck_rxpathsel(
4953 struct r8192_priv * priv,
4954 struct ieee80211_rx_stats * pprevious_stats
4957 #ifdef RTL8190P //Only 90P 2T4R need to check
4958 char last_cck_adc_pwdb[4]={0,0,0,0};
4960 //cosa add for Rx path selection
4961 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable)
4963 if(pprevious_stats->bIsCCK &&
4964 (pprevious_stats->bPacketToSelf ||pprevious_stats->bPacketBeacon))
4966 /* record the cck adc_pwdb to the sliding window. */
4967 if(priv->stats.cck_adc_pwdb.TotalNum++ >= PHY_RSSI_SLID_WIN_MAX)
4969 priv->stats.cck_adc_pwdb.TotalNum = PHY_RSSI_SLID_WIN_MAX;
4970 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4972 last_cck_adc_pwdb[i] = priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index];
4973 priv->stats.cck_adc_pwdb.TotalVal[i] -= last_cck_adc_pwdb[i];
4976 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4978 priv->stats.cck_adc_pwdb.TotalVal[i] += pprevious_stats->cck_adc_pwdb[i];
4979 priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index] = pprevious_stats->cck_adc_pwdb[i];
4981 priv->stats.cck_adc_pwdb.index++;
4982 if(priv->stats.cck_adc_pwdb.index >= PHY_RSSI_SLID_WIN_MAX)
4983 priv->stats.cck_adc_pwdb.index = 0;
4985 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4987 DM_RxPathSelTable.cck_pwdb_sta[i] = priv->stats.cck_adc_pwdb.TotalVal[i]/priv->stats.cck_adc_pwdb.TotalNum;
4990 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4992 if(pprevious_stats->cck_adc_pwdb[i] > (char)priv->undecorated_smoothed_cck_adc_pwdb[i])
4994 priv->undecorated_smoothed_cck_adc_pwdb[i] =
4995 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
4996 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
4997 priv->undecorated_smoothed_cck_adc_pwdb[i] = priv->undecorated_smoothed_cck_adc_pwdb[i] + 1;
5001 priv->undecorated_smoothed_cck_adc_pwdb[i] =
5002 ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
5003 (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
5012 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
5013 be a local static. Otherwise, it may increase when we return from S3/S4. The
5014 value will be kept in memory or disk. We must delcare the value in adapter
5015 and it will be reinitialized when return from S3/S4. */
5016 static void rtl8192_process_phyinfo(struct r8192_priv * priv, u8* buffer,struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
5018 bool bcheck = false;
5020 u32 nspatial_stream, tmp_val;
5022 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
5023 static u32 slide_evm_index=0, slide_evm_statistics=0;
5024 static u32 last_rssi=0, last_evm=0;
5025 //cosa add for rx path selection
5026 // static long slide_cck_adc_pwdb_index=0, slide_cck_adc_pwdb_statistics=0;
5027 // static char last_cck_adc_pwdb[4]={0,0,0,0};
5028 //cosa add for beacon rssi smoothing
5029 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
5030 static u32 last_beacon_adc_pwdb=0;
5032 struct ieee80211_hdr_3addr *hdr;
5034 unsigned int frag,seq;
5035 hdr = (struct ieee80211_hdr_3addr *)buffer;
5036 sc = le16_to_cpu(hdr->seq_ctl);
5037 frag = WLAN_GET_SEQ_FRAG(sc);
5038 seq = WLAN_GET_SEQ_SEQ(sc);
5039 //cosa add 04292008 to record the sequence number
5040 pcurrent_stats->Seq_Num = seq;
5042 // Check whether we should take the previous packet into accounting
5044 if(!pprevious_stats->bIsAMPDU)
5046 // if previous packet is not aggregated packet
5050 //remve for that we don't use AMPDU to calculate PWDB,because the reported PWDB of some AP is fault.
5052 // if previous packet is aggregated packet, and current packet
5054 // (2) is the first packet of one AMPDU
5055 // that means the previous packet is the last one aggregated packet
5056 if( !pcurrent_stats->bIsAMPDU || pcurrent_stats->bFirstMPDU)
5061 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
5063 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
5064 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
5065 priv->stats.slide_rssi_total -= last_rssi;
5067 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
5069 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
5070 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
5071 slide_rssi_index = 0;
5073 // <1> Showed on UI for user, in dbm
5074 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
5075 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
5076 pcurrent_stats->rssi = priv->stats.signal_strength;
5078 // If the previous packet does not match the criteria, neglect it
5080 if(!pprevious_stats->bPacketMatchBSSID)
5082 if(!pprevious_stats->bToSelfBA)
5089 rtl8190_process_cck_rxpathsel(priv,pprevious_stats);
5094 priv->stats.num_process_phyinfo++;
5096 /* record the general signal strength to the sliding window. */
5097 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
5099 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
5100 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
5101 priv->stats.slide_rssi_total -= last_rssi;
5103 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
5105 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
5106 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
5107 slide_rssi_index = 0;
5109 // <1> Showed on UI for user, in dbm
5110 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
5111 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
5114 // <2> Showed on UI for engineering
5115 // hardware does not provide rssi information for each rf path in CCK
5116 if(!pprevious_stats->bIsCCK && pprevious_stats->bPacketToSelf)
5118 for (rfpath = RF90_PATH_A; rfpath < RF90_PATH_C; rfpath++)
5120 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
5122 RT_TRACE(COMP_DBG,"Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d \n" ,pprevious_stats->RxMIMOSignalStrength[rfpath] );
5123 //Fixed by Jacken 2008-03-20
5124 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
5126 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
5127 //DbgPrint("MIMO RSSI initialize \n");
5129 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
5131 priv->stats.rx_rssi_percentage[rfpath] =
5132 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5133 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5134 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
5138 priv->stats.rx_rssi_percentage[rfpath] =
5139 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5140 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5142 RT_TRACE(COMP_DBG,"Jacken -> priv->RxStats.RxRSSIPercentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
5150 //cosa add for beacon rssi smoothing by average.
5151 if(pprevious_stats->bPacketBeacon)
5153 /* record the beacon pwdb to the sliding window. */
5154 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5156 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
5157 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
5158 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
5159 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
5160 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
5162 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
5163 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
5164 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
5165 slide_beacon_adc_pwdb_index++;
5166 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5167 slide_beacon_adc_pwdb_index = 0;
5168 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
5169 if(pprevious_stats->RxPWDBAll >= 3)
5170 pprevious_stats->RxPWDBAll -= 3;
5173 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
5174 pprevious_stats->bIsCCK? "CCK": "OFDM",
5175 pprevious_stats->RxPWDBAll);
5177 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5179 if(priv->undecorated_smoothed_pwdb < 0) // initialize
5181 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
5182 //DbgPrint("First pwdb initialize \n");
5185 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
5187 priv->undecorated_smoothed_pwdb =
5188 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5189 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5190 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
5194 priv->undecorated_smoothed_pwdb =
5195 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5196 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5199 //Fixed by Jacken 2008-03-20
5200 if(pPreviousRfd->Status.RxPWDBAll > (u32)pHalData->UndecoratedSmoothedPWDB)
5202 pHalData->UndecoratedSmoothedPWDB =
5203 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5204 pHalData->UndecoratedSmoothedPWDB = pHalData->UndecoratedSmoothedPWDB + 1;
5208 pHalData->UndecoratedSmoothedPWDB =
5209 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5212 rtl819x_update_rxsignalstatistics8190pci(priv,pprevious_stats);
5218 /* record the general EVM to the sliding window. */
5219 if(pprevious_stats->SignalQuality == 0)
5224 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
5225 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
5226 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
5227 last_evm = priv->stats.slide_evm[slide_evm_index];
5228 priv->stats.slide_evm_total -= last_evm;
5231 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
5233 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
5234 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
5235 slide_evm_index = 0;
5237 // <1> Showed on UI for user, in percentage.
5238 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
5239 priv->stats.signal_quality = tmp_val;
5240 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
5241 priv->stats.last_signal_strength_inpercent = tmp_val;
5244 // <2> Showed on UI for engineering
5245 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5247 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
5249 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
5251 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
5253 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
5255 priv->stats.rx_evm_percentage[nspatial_stream] =
5256 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
5257 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
5265 static u8 rtl819x_query_rxpwrpercentage(
5269 if ((antpower <= -100) || (antpower >= 20))
5273 else if (antpower >= 0)
5279 return (100+antpower);
5285 rtl819x_evm_dbtopercentage(
5297 ret_val = 0 - ret_val;
5304 /* We want good-looking for signal strength/quality */
5305 static long rtl819x_signal_scale_mapping(long currsig)
5309 // Step 1. Scale mapping.
5310 if(currsig >= 61 && currsig <= 100)
5312 retsig = 90 + ((currsig - 60) / 4);
5314 else if(currsig >= 41 && currsig <= 60)
5316 retsig = 78 + ((currsig - 40) / 2);
5318 else if(currsig >= 31 && currsig <= 40)
5320 retsig = 66 + (currsig - 30);
5322 else if(currsig >= 21 && currsig <= 30)
5324 retsig = 54 + (currsig - 20);
5326 else if(currsig >= 5 && currsig <= 20)
5328 retsig = 42 + (((currsig - 5) * 2) / 3);
5330 else if(currsig == 4)
5334 else if(currsig == 3)
5338 else if(currsig == 2)
5342 else if(currsig == 1)
5354 static void rtl8192_query_rxphystatus(
5355 struct r8192_priv * priv,
5356 struct ieee80211_rx_stats * pstats,
5357 prx_desc_819x_pci pdesc,
5358 prx_fwinfo_819x_pci pdrvinfo,
5359 struct ieee80211_rx_stats * precord_stats,
5360 bool bpacket_match_bssid,
5361 bool bpacket_toself,
5366 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
5367 phy_sts_ofdm_819xpci_t* pofdm_buf;
5368 phy_sts_cck_819xpci_t * pcck_buf;
5369 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
5371 u8 i,max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
5372 char rx_pwr[4], rx_pwr_all=0;
5373 //long rx_avg_pwr = 0;
5374 char rx_snrX, rx_evmX;
5376 u32 RSSI, total_rssi=0;//, total_evm=0;
5377 // long signal_strength_index = 0;
5381 /* 2007/07/04 MH For OFDM RSSI. For high power or not. */
5382 static u8 check_reg824 = 0;
5383 static u32 reg824_bit9 = 0;
5385 priv->stats.numqry_phystatus++;
5387 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
5389 // Record it for next packet processing
5390 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
5391 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
5392 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
5393 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
5394 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
5395 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
5396 /*2007.08.30 requested by SD3 Jerry */
5397 if(check_reg824 == 0)
5399 reg824_bit9 = rtl8192_QueryBBReg(priv->ieee80211->dev, rFPGA0_XA_HSSIParameter2, 0x200);
5404 prxpkt = (u8*)pdrvinfo;
5406 /* Move pointer to the 16th bytes. Phy status start address. */
5407 prxpkt += sizeof(rx_fwinfo_819x_pci);
5409 /* Initial the cck and ofdm buffer pointer */
5410 pcck_buf = (phy_sts_cck_819xpci_t *)prxpkt;
5411 pofdm_buf = (phy_sts_ofdm_819xpci_t *)prxpkt;
5413 pstats->RxMIMOSignalQuality[0] = -1;
5414 pstats->RxMIMOSignalQuality[1] = -1;
5415 precord_stats->RxMIMOSignalQuality[0] = -1;
5416 precord_stats->RxMIMOSignalQuality[1] = -1;
5421 // (1)Hardware does not provide RSSI for CCK
5425 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5427 u8 report;//, cck_agc_rpt;
5430 char cck_adc_pwdb[4];
5432 priv->stats.numqry_phystatusCCK++;
5434 #ifdef RTL8190P //Only 90P 2T4R need to check
5435 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable && bpacket_match_bssid)
5437 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5439 tmp_pwdb = pcck_buf->adc_pwdb_X[i];
5440 cck_adc_pwdb[i] = (char)tmp_pwdb;
5441 cck_adc_pwdb[i] /= 2;
5442 pstats->cck_adc_pwdb[i] = precord_stats->cck_adc_pwdb[i] = cck_adc_pwdb[i];
5443 //DbgPrint("RF-%d tmp_pwdb = 0x%x, cck_adc_pwdb = %d", i, tmp_pwdb, cck_adc_pwdb[i]);
5450 report = pcck_buf->cck_agc_rpt & 0xc0;
5454 //Fixed by Jacken from Bryant 2008-03-20
5455 //Original value is -38 , -26 , -14 , -2
5456 //Fixed value is -35 , -23 , -11 , 6
5458 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
5461 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
5464 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
5467 rx_pwr_all = 8 - (pcck_buf->cck_agc_rpt & 0x3e);
5473 report = pcck_buf->cck_agc_rpt & 0x60;
5478 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5481 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
5484 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5487 rx_pwr_all = -8 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5492 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5493 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5494 pstats->RecvSignalPower = rx_pwr_all;
5497 // (3) Get Signal Quality (EVM)
5499 if(bpacket_match_bssid)
5503 if(pstats->RxPWDBAll > 40)
5508 sq = pcck_buf->sq_rpt;
5510 if(pcck_buf->sq_rpt > 64)
5512 else if (pcck_buf->sq_rpt < 20)
5515 sq = ((64-sq) * 100) / 44;
5517 pstats->SignalQuality = precord_stats->SignalQuality = sq;
5518 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5519 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5524 priv->stats.numqry_phystatusHT++;
5526 // (1)Get RSSI for HT rate
5528 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5530 // 2008/01/30 MH we will judge RF RX path now.
5531 if (priv->brfpath_rxenable[i])
5536 //Fixed by Jacken from Bryant 2008-03-20
5537 //Original value is 106
5538 #ifdef RTL8190P //Modify by Jacken 2008/03/31
5539 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5541 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 110;
5544 //Get Rx snr value in DB
5545 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5546 rx_snrX = (char)(tmp_rxsnr);
5548 priv->stats.rxSNRdB[i] = (long)rx_snrX;
5550 /* Translate DBM to percentage. */
5551 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5552 if (priv->brfpath_rxenable[i])
5555 /* Record Signal Strength for next packet */
5556 if(bpacket_match_bssid)
5558 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5559 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5565 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5567 //Fixed by Jacken from Bryant 2008-03-20
5568 //Original value is 106
5569 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5570 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5572 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5573 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5574 pstats->RecvSignalPower = rx_pwr_all;
5576 // (3)EVM of HT rate
5578 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5579 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5580 max_spatial_stream = 2; //both spatial stream make sense
5582 max_spatial_stream = 1; //only spatial stream 1 makes sense
5584 for(i=0; i<max_spatial_stream; i++)
5586 tmp_rxevm = pofdm_buf->rxevm_X[i];
5587 rx_evmX = (char)(tmp_rxevm);
5589 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5590 // fill most significant bit to "zero" when doing shifting operation which may change a negative
5591 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5594 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5596 EVM = SignalScaleMapping(EVM);//make it good looking, from 0~100
5598 if(bpacket_match_bssid)
5600 if(i==0) // Fill value in RFD, Get the first spatial stream only
5601 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5602 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5607 /* record rx statistics for debug */
5608 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5609 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5610 if(pdrvinfo->BW) //40M channel
5611 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5613 priv->stats.received_bwtype[0]++;
5616 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5617 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5620 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5625 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u1Byte)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u1Byte)(total_rssi/=RF90_PATH_MAX);
5626 // We can judge RX path number now.
5628 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5633 rtl8192_record_rxdesc_forlateruse(
5634 struct ieee80211_rx_stats * psrc_stats,
5635 struct ieee80211_rx_stats * ptarget_stats
5638 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5639 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5640 //ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5645 static void TranslateRxSignalStuff819xpci(struct net_device *dev,
5646 struct sk_buff *skb,
5647 struct ieee80211_rx_stats * pstats,
5648 prx_desc_819x_pci pdesc,
5649 prx_fwinfo_819x_pci pdrvinfo)
5651 // TODO: We must only check packet for current MAC address. Not finish
5652 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5653 bool bpacket_match_bssid, bpacket_toself;
5654 bool bPacketBeacon=false, bToSelfBA=false;
5655 static struct ieee80211_rx_stats previous_stats;
5656 struct ieee80211_hdr_3addr *hdr;
5659 // Get Signal Quality for only RX data queue (but not command queue)
5664 /* Get MAC frame start address. */
5665 tmp_buf = skb->data;
5667 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5668 fc = le16_to_cpu(hdr->frame_ctl);
5669 type = WLAN_FC_GET_TYPE(fc);
5670 praddr = hdr->addr1;
5672 /* Check if the received packet is acceptabe. */
5673 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5674 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5675 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5676 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5678 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5680 bPacketBeacon = true;
5681 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5683 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5685 if((eqMacAddr(praddr,dev->dev_addr)))
5687 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5691 if(bpacket_match_bssid)
5693 priv->stats.numpacket_matchbssid++;
5696 priv->stats.numpacket_toself++;
5699 // Process PHY information for previous packet (RSSI/PWDB/EVM)
5701 // Because phy information is contained in the last packet of AMPDU only, so driver
5702 // should process phy information of previous packet
5703 rtl8192_process_phyinfo(priv, tmp_buf,&previous_stats, pstats);
5704 rtl8192_query_rxphystatus(priv, pstats, pdesc, pdrvinfo, &previous_stats, bpacket_match_bssid,
5705 bpacket_toself ,bPacketBeacon, bToSelfBA);
5706 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
5711 static void rtl8192_tx_resume(struct net_device *dev)
5713 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5714 struct ieee80211_device *ieee = priv->ieee80211;
5715 struct sk_buff *skb;
5718 for(queue_index = BK_QUEUE; queue_index < TXCMD_QUEUE;queue_index++) {
5719 while((!skb_queue_empty(&ieee->skb_waitQ[queue_index]))&&
5720 (priv->ieee80211->check_nic_enough_desc(dev,queue_index) > 0)) {
5721 /* 1. dequeue the packet from the wait queue */
5722 skb = skb_dequeue(&ieee->skb_waitQ[queue_index]);
5723 /* 2. tx the packet directly */
5724 ieee->softmac_data_hard_start_xmit(skb,dev,0/* rate useless now*/);
5726 if(queue_index!=MGNT_QUEUE) {
5727 ieee->stats.tx_packets++;
5728 ieee->stats.tx_bytes += skb->len;
5735 static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv)
5737 rtl8192_tx_resume(priv->ieee80211->dev);
5740 /* Record the received data rate */
5741 static void UpdateReceivedRateHistogramStatistics8190(
5742 struct net_device *dev,
5743 struct ieee80211_rx_stats* pstats
5746 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5747 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
5749 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
5753 else if(pstats->bICV)
5756 if(pstats->bShortPreamble)
5757 preamble_guardinterval = 1;// short
5759 preamble_guardinterval = 0;// long
5761 switch(pstats->rate)
5766 case MGN_1M: rateIndex = 0; break;
5767 case MGN_2M: rateIndex = 1; break;
5768 case MGN_5_5M: rateIndex = 2; break;
5769 case MGN_11M: rateIndex = 3; break;
5773 case MGN_6M: rateIndex = 4; break;
5774 case MGN_9M: rateIndex = 5; break;
5775 case MGN_12M: rateIndex = 6; break;
5776 case MGN_18M: rateIndex = 7; break;
5777 case MGN_24M: rateIndex = 8; break;
5778 case MGN_36M: rateIndex = 9; break;
5779 case MGN_48M: rateIndex = 10; break;
5780 case MGN_54M: rateIndex = 11; break;
5782 // 11n High throughput rate
5784 case MGN_MCS0: rateIndex = 12; break;
5785 case MGN_MCS1: rateIndex = 13; break;
5786 case MGN_MCS2: rateIndex = 14; break;
5787 case MGN_MCS3: rateIndex = 15; break;
5788 case MGN_MCS4: rateIndex = 16; break;
5789 case MGN_MCS5: rateIndex = 17; break;
5790 case MGN_MCS6: rateIndex = 18; break;
5791 case MGN_MCS7: rateIndex = 19; break;
5792 case MGN_MCS8: rateIndex = 20; break;
5793 case MGN_MCS9: rateIndex = 21; break;
5794 case MGN_MCS10: rateIndex = 22; break;
5795 case MGN_MCS11: rateIndex = 23; break;
5796 case MGN_MCS12: rateIndex = 24; break;
5797 case MGN_MCS13: rateIndex = 25; break;
5798 case MGN_MCS14: rateIndex = 26; break;
5799 case MGN_MCS15: rateIndex = 27; break;
5800 default: rateIndex = 28; break;
5802 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
5803 priv->stats.received_rate_histogram[0][rateIndex]++; //total
5804 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
5807 static void rtl8192_rx(struct net_device *dev)
5809 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5810 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
5811 bool unicast_packet = false;
5812 struct ieee80211_rx_stats stats = {
5816 .freq = IEEE80211_24GHZ_BAND,
5818 unsigned int count = priv->rxringcount;
5820 stats.nic_type = NIC_8192E;
5823 rx_desc_819x_pci *pdesc = &priv->rx_ring[priv->rx_idx];//rx descriptor
5824 struct sk_buff *skb = priv->rx_buf[priv->rx_idx];//rx pkt
5827 /* wait data to be filled by hardware */
5830 stats.bICV = pdesc->ICV;
5831 stats.bCRC = pdesc->CRC32;
5832 stats.bHwError = pdesc->CRC32 | pdesc->ICV;
5834 stats.Length = pdesc->Length;
5835 if(stats.Length < 24)
5836 stats.bHwError |= 1;
5838 if(stats.bHwError) {
5839 stats.bShift = false;
5842 if (pdesc->Length <500)
5843 priv->stats.rxcrcerrmin++;
5844 else if (pdesc->Length >1000)
5845 priv->stats.rxcrcerrmax++;
5847 priv->stats.rxcrcerrmid++;
5851 prx_fwinfo_819x_pci pDrvInfo = NULL;
5852 struct sk_buff *new_skb = dev_alloc_skb(priv->rxbuffersize);
5854 if (unlikely(!new_skb)) {
5858 stats.RxDrvInfoSize = pdesc->RxDrvInfoSize;
5859 stats.RxBufShift = ((pdesc->Shift)&0x03);
5860 stats.Decrypted = !pdesc->SWDec;
5862 pci_dma_sync_single_for_cpu(priv->pdev,
5863 *((dma_addr_t *)skb->cb),
5865 PCI_DMA_FROMDEVICE);
5866 skb_put(skb, pdesc->Length);
5867 pDrvInfo = (rx_fwinfo_819x_pci *)(skb->data + stats.RxBufShift);
5868 skb_reserve(skb, stats.RxDrvInfoSize + stats.RxBufShift);
5870 stats.rate = HwRateToMRate90((bool)pDrvInfo->RxHT, (u8)pDrvInfo->RxRate);
5871 stats.bShortPreamble = pDrvInfo->SPLCP;
5873 /* it is debug only. It should be disabled in released driver.
5874 * 2007.1.11 by Emily
5876 UpdateReceivedRateHistogramStatistics8190(dev, &stats);
5878 stats.bIsAMPDU = (pDrvInfo->PartAggr==1);
5879 stats.bFirstMPDU = (pDrvInfo->PartAggr==1) && (pDrvInfo->FirstAGGR==1);
5881 stats.TimeStampLow = pDrvInfo->TSFL;
5882 stats.TimeStampHigh = read_nic_dword(dev, TSFR+4);
5884 UpdateRxPktTimeStamp8190(dev, &stats);
5887 // Get Total offset of MPDU Frame Body
5889 if((stats.RxBufShift + stats.RxDrvInfoSize) > 0)
5892 stats.RxIs40MHzPacket = pDrvInfo->BW;
5895 TranslateRxSignalStuff819xpci(dev,skb, &stats, pdesc, pDrvInfo);
5898 if(pDrvInfo->FirstAGGR==1 || pDrvInfo->PartAggr == 1)
5899 RT_TRACE(COMP_RXDESC, "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
5900 pDrvInfo->FirstAGGR, pDrvInfo->PartAggr);
5901 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5902 /* rx packets statistics */
5903 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5904 unicast_packet = false;
5906 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5908 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5911 /* unicast packet */
5912 unicast_packet = true;
5915 stats.packetlength = stats.Length-4;
5916 stats.fraglength = stats.packetlength;
5917 stats.fragoffset = 0;
5918 stats.ntotalfrag = 1;
5920 if(!ieee80211_rtl_rx(priv->ieee80211, skb, &stats)){
5921 dev_kfree_skb_any(skb);
5924 if(unicast_packet) {
5925 priv->stats.rxbytesunicast += skb->len;
5930 priv->rx_buf[priv->rx_idx] = skb;
5931 *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev, skb_tail_pointer(skb), priv->rxbuffersize, PCI_DMA_FROMDEVICE);
5936 pdesc->BufferAddress = cpu_to_le32(*((dma_addr_t *)skb->cb));
5938 pdesc->Length = priv->rxbuffersize;
5939 if (priv->rx_idx == priv->rxringcount-1)
5941 priv->rx_idx = (priv->rx_idx + 1) % priv->rxringcount;
5946 static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
5948 rtl8192_rx(priv->ieee80211->dev);
5950 write_nic_dword(priv->ieee80211->dev, INTA_MASK,read_nic_dword(priv->ieee80211->dev, INTA_MASK) | IMR_RDU);
5953 static const struct net_device_ops rtl8192_netdev_ops = {
5954 .ndo_open = rtl8192_open,
5955 .ndo_stop = rtl8192_close,
5956 .ndo_tx_timeout = tx_timeout,
5957 .ndo_do_ioctl = rtl8192_ioctl,
5958 .ndo_set_multicast_list = r8192_set_multicast,
5959 .ndo_set_mac_address = r8192_set_mac_adr,
5960 .ndo_start_xmit = ieee80211_rtl_xmit,
5963 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
5964 const struct pci_device_id *id)
5966 unsigned long ioaddr = 0;
5967 struct net_device *dev = NULL;
5968 struct r8192_priv *priv= NULL;
5972 #ifdef CONFIG_RTL8192_IO_MAP
5973 unsigned long pio_start, pio_len, pio_flags;
5975 unsigned long pmem_start, pmem_len, pmem_flags;
5976 #endif //end #ifdef RTL_IO_MAP
5978 RT_TRACE(COMP_INIT,"Configuring chip resources");
5980 if( pci_enable_device (pdev) ){
5981 RT_TRACE(COMP_ERR,"Failed to enable PCI device");
5985 pci_set_master(pdev);
5986 //pci_set_wmi(pdev);
5987 pci_set_dma_mask(pdev, 0xffffff00ULL);
5988 pci_set_consistent_dma_mask(pdev,0xffffff00ULL);
5989 dev = alloc_ieee80211(sizeof(struct r8192_priv));
5995 pci_set_drvdata(pdev, dev);
5996 SET_NETDEV_DEV(dev, &pdev->dev);
5997 priv = ieee80211_priv(dev);
5998 priv->ieee80211 = netdev_priv(dev);
6000 if((pdev->subsystem_vendor == PCI_VENDOR_ID_DLINK)&&(pdev->subsystem_device == 0x3304)){
6001 priv->ieee80211->bSupportRemoteWakeUp = 1;
6004 priv->ieee80211->bSupportRemoteWakeUp = 0;
6007 #ifdef CONFIG_RTL8192_IO_MAP
6009 pio_start = (unsigned long)pci_resource_start (pdev, 0);
6010 pio_len = (unsigned long)pci_resource_len (pdev, 0);
6011 pio_flags = (unsigned long)pci_resource_flags (pdev, 0);
6013 if (!(pio_flags & IORESOURCE_IO)) {
6014 RT_TRACE(COMP_ERR,"region #0 not a PIO resource, aborting");
6018 //DMESG("IO space @ 0x%08lx", pio_start );
6019 if( ! request_region( pio_start, pio_len, RTL819xE_MODULE_NAME ) ){
6020 RT_TRACE(COMP_ERR,"request_region failed!");
6025 dev->base_addr = ioaddr; // device I/O address
6029 pmem_start = pci_resource_start(pdev, 1);
6030 pmem_len = pci_resource_len(pdev, 1);
6031 pmem_flags = pci_resource_flags (pdev, 1);
6033 if (!(pmem_flags & IORESOURCE_MEM)) {
6034 RT_TRACE(COMP_ERR,"region #1 not a MMIO resource, aborting");
6038 //DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
6039 if( ! request_mem_region(pmem_start, pmem_len, RTL819xE_MODULE_NAME)) {
6040 RT_TRACE(COMP_ERR,"request_mem_region failed!");
6045 ioaddr = (unsigned long)ioremap_nocache( pmem_start, pmem_len);
6046 if( ioaddr == (unsigned long)NULL ){
6047 RT_TRACE(COMP_ERR,"ioremap failed!");
6048 // release_mem_region( pmem_start, pmem_len );
6052 dev->mem_start = ioaddr; // shared mem start
6053 dev->mem_end = ioaddr + pci_resource_len(pdev, 0); // shared mem end
6055 #endif //end #ifdef RTL_IO_MAP
6057 /* We disable the RETRY_TIMEOUT register (0x41) to keep
6058 * PCI Tx retries from interfering with C3 CPU state */
6059 pci_write_config_byte(pdev, 0x41, 0x00);
6062 pci_read_config_byte(pdev, 0x05, &unit);
6063 pci_write_config_byte(pdev, 0x05, unit & (~0x04));
6065 dev->irq = pdev->irq;
6068 dev->netdev_ops = &rtl8192_netdev_ops;
6070 dev->open = rtl8192_open;
6071 dev->stop = rtl8192_close;
6072 //dev->hard_start_xmit = rtl8192_8023_hard_start_xmit;
6073 dev->tx_timeout = tx_timeout;
6074 //dev->wireless_handlers = &r8192_wx_handlers_def;
6075 dev->do_ioctl = rtl8192_ioctl;
6076 dev->set_multicast_list = r8192_set_multicast;
6077 dev->set_mac_address = r8192_set_mac_adr;
6080 //DMESG("Oops: i'm coming\n");
6081 #if WIRELESS_EXT >= 12
6082 #if WIRELESS_EXT < 17
6083 dev->get_wireless_stats = r8192_get_wireless_stats;
6085 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
6087 //dev->get_wireless_stats = r8192_get_wireless_stats;
6088 dev->type=ARPHRD_ETHER;
6090 dev->watchdog_timeo = HZ*3; //modified by john, 0805
6092 if (dev_alloc_name(dev, ifname) < 0){
6093 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
6094 strcpy(ifname, "wlan%d");
6095 dev_alloc_name(dev, ifname);
6098 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
6099 if(rtl8192_init(dev)!=0){
6100 RT_TRACE(COMP_ERR, "Initialization failed");
6104 netif_carrier_off(dev);
6105 netif_stop_queue(dev);
6107 register_netdev(dev);
6108 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
6109 rtl8192_proc_init_one(dev);
6112 RT_TRACE(COMP_INIT, "Driver probe completed\n");
6117 #ifdef CONFIG_RTL8180_IO_MAP
6119 if( dev->base_addr != 0 ){
6121 release_region(dev->base_addr,
6122 pci_resource_len(pdev, 0) );
6125 if( dev->mem_start != (unsigned long)NULL ){
6126 iounmap( (void *)dev->mem_start );
6127 release_mem_region( pci_resource_start(pdev, 1),
6128 pci_resource_len(pdev, 1) );
6130 #endif //end #ifdef RTL_IO_MAP
6136 free_irq(dev->irq, dev);
6139 free_ieee80211(dev);
6143 pci_disable_device(pdev);
6145 DMESG("wlan driver load failed\n");
6146 pci_set_drvdata(pdev, NULL);
6151 /* detach all the work and timer structure declared or inititialized
6152 * in r8192_init function.
6154 static void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
6156 /* call cancel_work_sync instead of cancel_delayed_work if and only if Linux_version_code
6157 * is or is newer than 2.6.20 and work structure is defined to be struct work_struct.
6158 * Otherwise call cancel_delayed_work is enough.
6159 * FIXME (2.6.20 should 2.6.22, work_struct should not cancel)
6161 cancel_delayed_work(&priv->watch_dog_wq);
6162 cancel_delayed_work(&priv->update_beacon_wq);
6163 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
6164 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
6166 cancel_delayed_work(&priv->gpio_change_rf_wq);
6168 cancel_work_sync(&priv->reset_wq);
6169 cancel_work_sync(&priv->qos_activate);
6170 //cancel_work_sync(&priv->SetBWModeWorkItem);
6171 //cancel_work_sync(&priv->SwChnlWorkItem);
6176 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev)
6178 struct net_device *dev = pci_get_drvdata(pdev);
6179 struct r8192_priv *priv ;
6183 unregister_netdev(dev);
6185 priv=ieee80211_priv(dev);
6187 rtl8192_proc_remove_one(dev);
6190 if (priv->pFirmware)
6192 vfree(priv->pFirmware);
6193 priv->pFirmware = NULL;
6195 // priv->rf_close(dev);
6196 // rtl8192_usb_deleteendpoints(dev);
6197 destroy_workqueue(priv->priv_wq);
6198 /* redundant with rtl8192_down */
6199 // rtl8192_irq_disable(dev);
6200 // rtl8192_reset(dev);
6204 /* free tx/rx rings */
6205 rtl8192_free_rx_ring(dev);
6206 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
6207 rtl8192_free_tx_ring(dev, i);
6212 printk("Freeing irq %d\n",dev->irq);
6213 free_irq(dev->irq, dev);
6220 // free_beacon_desc_ring(dev,priv->txbeaconcount);
6222 #ifdef CONFIG_RTL8180_IO_MAP
6224 if( dev->base_addr != 0 ){
6226 release_region(dev->base_addr,
6227 pci_resource_len(pdev, 0) );
6230 if( dev->mem_start != (unsigned long)NULL ){
6231 iounmap( (void *)dev->mem_start );
6232 release_mem_region( pci_resource_start(pdev, 1),
6233 pci_resource_len(pdev, 1) );
6235 #endif /*end #ifdef RTL_IO_MAP*/
6236 free_ieee80211(dev);
6240 pci_disable_device(pdev);
6241 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
6244 extern int ieee80211_rtl_init(void);
6245 extern void ieee80211_rtl_exit(void);
6247 static int __init rtl8192_pci_module_init(void)
6251 retval = ieee80211_rtl_init();
6255 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
6256 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
6257 RT_TRACE(COMP_INIT, "Initializing module");
6258 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
6259 rtl8192_proc_module_init();
6260 if(0!=pci_register_driver(&rtl8192_pci_driver))
6262 DMESG("No device found");
6263 /*pci_unregister_driver (&rtl8192_pci_driver);*/
6270 static void __exit rtl8192_pci_module_exit(void)
6272 pci_unregister_driver(&rtl8192_pci_driver);
6274 RT_TRACE(COMP_DOWN, "Exiting");
6275 rtl8192_proc_module_remove();
6276 ieee80211_rtl_exit();
6279 //warning message WB
6280 static irqreturn_t rtl8192_interrupt(int irq, void *netdev)
6282 struct net_device *dev = (struct net_device *) netdev;
6283 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6284 unsigned long flags;
6286 /* We should return IRQ_NONE, but for now let me keep this */
6287 if(priv->irq_enabled == 0){
6291 spin_lock_irqsave(&priv->irq_th_lock,flags);
6295 inta = read_nic_dword(dev, ISR);// & priv->IntrMask;
6296 write_nic_dword(dev,ISR,inta); // reset int situation
6298 priv->stats.shints++;
6299 //DMESG("Enter interrupt, ISR value = 0x%08x", inta);
6301 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6304 most probably we can safely return IRQ_NONE,
6305 but for now is better to avoid problems
6311 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6317 DMESG("NIC irq %x",inta);
6319 //priv->irqpending = inta;
6322 if(!netif_running(dev)) {
6323 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6327 if(inta & IMR_TIMEOUT0){
6328 // write_nic_dword(dev, TimerInt, 0);
6329 //DMESG("=================>waking up");
6330 // rtl8180_hw_wakeup(dev);
6333 if(inta & IMR_TBDOK){
6334 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6335 rtl8192_tx_isr(dev, BEACON_QUEUE);
6336 priv->stats.txbeaconokint++;
6339 if(inta & IMR_TBDER){
6340 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6341 rtl8192_tx_isr(dev, BEACON_QUEUE);
6342 priv->stats.txbeaconerr++;
6345 if(inta & IMR_MGNTDOK ) {
6346 RT_TRACE(COMP_INTR, "Manage ok interrupt!\n");
6347 priv->stats.txmanageokint++;
6348 rtl8192_tx_isr(dev,MGNT_QUEUE);
6352 if(inta & IMR_COMDOK)
6354 priv->stats.txcmdpktokint++;
6355 rtl8192_tx_isr(dev,TXCMD_QUEUE);
6360 DMESG("Frame arrived !");
6362 priv->stats.rxint++;
6363 tasklet_schedule(&priv->irq_rx_tasklet);
6366 if(inta & IMR_BcnInt) {
6367 RT_TRACE(COMP_INTR, "prepare beacon for interrupt!\n");
6368 tasklet_schedule(&priv->irq_prepare_beacon_tasklet);
6372 RT_TRACE(COMP_INTR, "rx descriptor unavailable!\n");
6373 priv->stats.rxrdu++;
6374 /* reset int situation */
6375 write_nic_dword(dev,INTA_MASK,read_nic_dword(dev, INTA_MASK) & ~IMR_RDU);
6376 tasklet_schedule(&priv->irq_rx_tasklet);
6379 if(inta & IMR_RXFOVW){
6380 RT_TRACE(COMP_INTR, "rx overflow !\n");
6381 priv->stats.rxoverflow++;
6382 tasklet_schedule(&priv->irq_rx_tasklet);
6385 if(inta & IMR_TXFOVW) priv->stats.txoverflow++;
6387 if(inta & IMR_BKDOK){
6388 RT_TRACE(COMP_INTR, "BK Tx OK interrupt!\n");
6389 priv->stats.txbkokint++;
6390 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6391 rtl8192_tx_isr(dev,BK_QUEUE);
6392 rtl8192_try_wake_queue(dev, BK_QUEUE);
6395 if(inta & IMR_BEDOK){
6396 RT_TRACE(COMP_INTR, "BE TX OK interrupt!\n");
6397 priv->stats.txbeokint++;
6398 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6399 rtl8192_tx_isr(dev,BE_QUEUE);
6400 rtl8192_try_wake_queue(dev, BE_QUEUE);
6403 if(inta & IMR_VIDOK){
6404 RT_TRACE(COMP_INTR, "VI TX OK interrupt!\n");
6405 priv->stats.txviokint++;
6406 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6407 rtl8192_tx_isr(dev,VI_QUEUE);
6408 rtl8192_try_wake_queue(dev, VI_QUEUE);
6411 if(inta & IMR_VODOK){
6412 priv->stats.txvookint++;
6413 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6414 rtl8192_tx_isr(dev,VO_QUEUE);
6415 rtl8192_try_wake_queue(dev, VO_QUEUE);
6418 spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6423 static void rtl8192_try_wake_queue(struct net_device *dev, int pri)
6428 void EnableHWSecurityConfig8192(struct net_device *dev)
6430 u8 SECR_value = 0x0;
6431 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6432 struct ieee80211_device* ieee = priv->ieee80211;
6434 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
6436 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
6438 SECR_value |= SCR_RxUseDK;
6439 SECR_value |= SCR_TxUseDK;
6441 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
6443 SECR_value |= SCR_RxUseDK;
6444 SECR_value |= SCR_TxUseDK;
6449 //add HWSec active enable here.
6450 //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
6451 ieee->hwsec_active = 1;
6453 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
6455 ieee->hwsec_active = 0;
6456 SECR_value &= ~SCR_RxDecEnable;
6459 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__,
6460 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
6462 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
6466 #define TOTAL_CAM_ENTRY 32
6467 //#define CAM_CONTENT_COUNT 8
6468 void setKey( struct net_device *dev,
6476 u32 TargetCommand = 0;
6477 u32 TargetContent = 0;
6481 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6482 RT_RF_POWER_STATE rtState;
6483 rtState = priv->ieee80211->eRFPowerState;
6484 if(priv->ieee80211->PowerSaveControl.bInactivePs){
6485 if(rtState == eRfOff){
6486 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
6488 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
6489 //up(&priv->wx_sem);
6493 down(&priv->ieee80211->ips_sem);
6495 up(&priv->ieee80211->ips_sem);
6499 priv->ieee80211->is_set_key = true;
6501 if (EntryNo >= TOTAL_CAM_ENTRY)
6502 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
6504 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
6507 usConfig |= BIT15 | (KeyType<<2);
6509 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
6510 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
6513 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
6514 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
6515 TargetCommand |= BIT31|BIT16;
6517 if(i==0){//MAC|Config
6518 TargetContent = (u32)(*(MacAddr+0)) << 16|
6519 (u32)(*(MacAddr+1)) << 24|
6522 write_nic_dword(dev, WCAMI, TargetContent);
6523 write_nic_dword(dev, RWCAM, TargetCommand);
6524 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6527 TargetContent = (u32)(*(MacAddr+2)) |
6528 (u32)(*(MacAddr+3)) << 8|
6529 (u32)(*(MacAddr+4)) << 16|
6530 (u32)(*(MacAddr+5)) << 24;
6531 write_nic_dword(dev, WCAMI, TargetContent);
6532 write_nic_dword(dev, RWCAM, TargetCommand);
6534 else { //Key Material
6535 if(KeyContent != NULL)
6537 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6538 write_nic_dword(dev, RWCAM, TargetCommand);
6542 RT_TRACE(COMP_SEC,"=========>after set key, usconfig:%x\n", usConfig);
6545 bool NicIFEnableNIC(struct net_device* dev)
6547 RT_STATUS init_status = RT_STATUS_SUCCESS;
6548 struct r8192_priv* priv = ieee80211_priv(dev);
6549 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
6553 RT_TRACE(COMP_ERR, "ERR!!! %s(): Driver is already down!\n",__FUNCTION__);
6554 priv->bdisable_nic = false; //YJ,add,091111
6557 // <1> Reset memory: descriptor, buffer,..
6558 //NicIFResetMemory(Adapter);
6560 // <2> Enable Adapter
6561 //priv->bfirst_init = true;
6562 init_status = rtl8192_adapter_start(dev);
6563 if (init_status != RT_STATUS_SUCCESS) {
6564 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
6565 priv->bdisable_nic = false; //YJ,add,091111
6568 //printk("start adapter finished\n");
6569 RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
6570 //priv->bfirst_init = false;
6572 // <3> Enable Interrupt
6573 rtl8192_irq_enable(dev);
6574 priv->bdisable_nic = false;
6576 return (init_status == RT_STATUS_SUCCESS);
6579 bool NicIFDisableNIC(struct net_device* dev)
6582 struct r8192_priv* priv = ieee80211_priv(dev);
6584 // <1> Disable Interrupt
6586 priv->bdisable_nic = true; //YJ,move,091109
6587 tmp_state = priv->ieee80211->state;
6589 ieee80211_softmac_stop_protocol(priv->ieee80211, false);
6591 priv->ieee80211->state = tmp_state;
6592 rtl8192_cancel_deferred_work(priv);
6593 rtl8192_irq_disable(dev);
6594 // <2> Stop all timer
6596 // <3> Disable Adapter
6597 rtl8192_halt_adapter(dev, false);
6598 // priv->bdisable_nic = true;
6603 module_init(rtl8192_pci_module_init);
6604 module_exit(rtl8192_pci_module_exit);