1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 * Linux device driver for RTL8190P / RTL8192E
5 * Based on the r8180 driver, which is:
6 * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 * The full GNU General Public License is included in this distribution in the
21 * file called LICENSE.
23 * Contact Information:
24 * Jerry chuang <wlanfae@realtek.com>
28 #undef RX_DONT_PASS_UL
30 #undef DEBUG_RX_VERBOSE
36 #undef DEBUG_TX_FILLDESC
41 #undef DEBUG_REGISTERS
43 #undef DEBUG_IRQ_TASKLET
47 //#define CONFIG_RTL8192_IO_MAP
48 #include <linux/vmalloc.h>
49 #include <linux/slab.h>
50 #include <asm/uaccess.h>
51 #include "r8192E_hw.h"
53 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
54 #include "r8180_93cx6.h" /* Card EEPROM */
55 #include "r8192E_wx.h"
56 #include "r819xE_phy.h" //added by WB 4.30.2008
57 #include "r819xE_phyreg.h"
58 #include "r819xE_cmdpkt.h"
59 #include "r8192E_dm.h"
66 #include "ieee80211/dot11d.h"
69 //set here to open your trace code. //WB
70 u32 rt_global_debug_component
=
88 // COMP_POWER_TRACKING |
90 COMP_ERR
; //always open err flags on
92 static DEFINE_PCI_DEVICE_TABLE(rtl8192_pci_id_tbl
) = {
96 { PCI_DEVICE(0x10ec, 0x8190) },
98 { PCI_DEVICE(0x07aa, 0x0045) },
99 { PCI_DEVICE(0x07aa, 0x0046) },
102 { PCI_DEVICE(0x10ec, 0x8192) },
105 { PCI_DEVICE(0x07aa, 0x0044) },
106 { PCI_DEVICE(0x07aa, 0x0047) },
111 static char ifname
[IFNAMSIZ
] = "wlan%d";
112 static int hwwep
= 1; //default use hw. set 0 to use software security
113 static int channels
= 0x3fff;
115 MODULE_LICENSE("GPL");
116 MODULE_VERSION("V 1.1");
117 MODULE_DEVICE_TABLE(pci
, rtl8192_pci_id_tbl
);
118 //MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
119 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
122 module_param_string(ifname
, ifname
, sizeof(ifname
), S_IRUGO
|S_IWUSR
);
123 module_param(hwwep
,int, S_IRUGO
|S_IWUSR
);
124 module_param(channels
,int, S_IRUGO
|S_IWUSR
);
126 MODULE_PARM_DESC(ifname
," Net interface name, wlan%d=default");
127 MODULE_PARM_DESC(hwwep
," Try to use hardware WEP support. Still broken and not available on all cards");
128 MODULE_PARM_DESC(channels
," Channel bitmask for specific locales. NYI");
130 static int __devinit
rtl8192_pci_probe(struct pci_dev
*pdev
,
131 const struct pci_device_id
*id
);
132 static void __devexit
rtl8192_pci_disconnect(struct pci_dev
*pdev
);
134 static struct pci_driver rtl8192_pci_driver
= {
135 .name
= RTL819xE_MODULE_NAME
, /* Driver name */
136 .id_table
= rtl8192_pci_id_tbl
, /* PCI_ID table */
137 .probe
= rtl8192_pci_probe
, /* probe fn */
138 .remove
= __devexit_p(rtl8192_pci_disconnect
), /* remove fn */
140 .suspend
= rtl8192E_suspend
, /* PM suspend fn */
141 .resume
= rtl8192E_resume
, /* PM resume fn */
143 .suspend
= NULL
, /* PM suspend fn */
144 .resume
= NULL
, /* PM resume fn */
148 static void rtl8192_start_beacon(struct net_device
*dev
);
149 static void rtl8192_stop_beacon(struct net_device
*dev
);
150 static void rtl819x_watchdog_wqcallback(struct work_struct
*work
);
151 static void rtl8192_irq_rx_tasklet(struct r8192_priv
*priv
);
152 static void rtl8192_irq_tx_tasklet(struct r8192_priv
*priv
);
153 static void rtl8192_prepare_beacon(struct r8192_priv
*priv
);
154 static irqreturn_t
rtl8192_interrupt(int irq
, void *netdev
);
155 static void rtl819xE_tx_cmd(struct net_device
*dev
, struct sk_buff
*skb
);
156 static void rtl8192_update_ratr_table(struct net_device
* dev
);
157 static void rtl8192_restart(struct work_struct
*work
);
158 static void watch_dog_timer_callback(unsigned long data
);
159 static int _rtl8192_up(struct net_device
*dev
);
160 static void rtl8192_cancel_deferred_work(struct r8192_priv
* priv
);
164 typedef struct _CHANNEL_LIST
168 }CHANNEL_LIST
, *PCHANNEL_LIST
;
170 static const CHANNEL_LIST ChannelPlan
[] = {
171 {{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
172 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
173 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
174 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
175 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
176 {{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
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
179 {{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
180 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
181 {{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
184 static void rtl819x_set_channel_map(u8 channel_plan
, struct r8192_priv
* priv
)
186 int i
, max_chan
=-1, min_chan
=-1;
187 struct ieee80211_device
* ieee
= priv
->ieee80211
;
188 switch (channel_plan
)
190 case COUNTRY_CODE_FCC
:
191 case COUNTRY_CODE_IC
:
192 case COUNTRY_CODE_ETSI
:
193 case COUNTRY_CODE_SPAIN
:
194 case COUNTRY_CODE_FRANCE
:
195 case COUNTRY_CODE_MKK
:
196 case COUNTRY_CODE_MKK1
:
197 case COUNTRY_CODE_ISRAEL
:
198 case COUNTRY_CODE_TELEC
:
199 case COUNTRY_CODE_MIC
:
202 ieee
->bGlobalDomain
= false;
203 //acturally 8225 & 8256 rf chip only support B,G,24N mode
204 if ((priv
->rf_chip
== RF_8225
) || (priv
->rf_chip
== RF_8256
))
211 RT_TRACE(COMP_ERR
, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__
);
213 if (ChannelPlan
[channel_plan
].Len
!= 0){
214 // Clear old channel map
215 memset(GET_DOT11D_INFO(ieee
)->channel_map
, 0, sizeof(GET_DOT11D_INFO(ieee
)->channel_map
));
216 // Set new channel map
217 for (i
=0;i
<ChannelPlan
[channel_plan
].Len
;i
++)
219 if (ChannelPlan
[channel_plan
].Channel
[i
] < min_chan
|| ChannelPlan
[channel_plan
].Channel
[i
] > max_chan
)
221 GET_DOT11D_INFO(ieee
)->channel_map
[ChannelPlan
[channel_plan
].Channel
[i
]] = 1;
226 case COUNTRY_CODE_GLOBAL_DOMAIN
:
228 GET_DOT11D_INFO(ieee
)->bEnabled
= 0; //this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain setting
230 ieee
->bGlobalDomain
= true;
239 static inline bool rx_hal_is_cck_rate(prx_fwinfo_819x_pci pdrvinfo
)
241 return (pdrvinfo
->RxRate
== DESC90_RATE1M
||
242 pdrvinfo
->RxRate
== DESC90_RATE2M
||
243 pdrvinfo
->RxRate
== DESC90_RATE5_5M
||
244 pdrvinfo
->RxRate
== DESC90_RATE11M
) &&
248 void CamResetAllEntry(struct net_device
*dev
)
250 write_nic_dword(dev
, RWCAM
, BIT31
|BIT30
);
254 void write_cam(struct net_device
*dev
, u8 addr
, u32 data
)
256 write_nic_dword(dev
, WCAMI
, data
);
257 write_nic_dword(dev
, RWCAM
, BIT31
|BIT16
|(addr
&0xff) );
259 u32
read_cam(struct net_device
*dev
, u8 addr
)
261 write_nic_dword(dev
, RWCAM
, 0x80000000|(addr
&0xff) );
262 return read_nic_dword(dev
, 0xa8);
265 #ifdef CONFIG_RTL8180_IO_MAP
267 u8
read_nic_byte(struct net_device
*dev
, int x
)
269 return 0xff&inb(dev
->base_addr
+x
);
272 u32
read_nic_dword(struct net_device
*dev
, int x
)
274 return inl(dev
->base_addr
+x
);
277 u16
read_nic_word(struct net_device
*dev
, int x
)
279 return inw(dev
->base_addr
+x
);
282 void write_nic_byte(struct net_device
*dev
, int x
,u8 y
)
284 outb(y
&0xff,dev
->base_addr
+x
);
287 void write_nic_word(struct net_device
*dev
, int x
,u16 y
)
289 outw(y
,dev
->base_addr
+x
);
292 void write_nic_dword(struct net_device
*dev
, int x
,u32 y
)
294 outl(y
,dev
->base_addr
+x
);
297 #else /* RTL_IO_MAP */
299 u8
read_nic_byte(struct net_device
*dev
, int x
)
301 return 0xff&readb((u8
*)dev
->mem_start
+x
);
304 u32
read_nic_dword(struct net_device
*dev
, int x
)
306 return readl((u8
*)dev
->mem_start
+x
);
309 u16
read_nic_word(struct net_device
*dev
, int x
)
311 return readw((u8
*)dev
->mem_start
+x
);
314 void write_nic_byte(struct net_device
*dev
, int x
,u8 y
)
316 writeb(y
,(u8
*)dev
->mem_start
+x
);
320 void write_nic_dword(struct net_device
*dev
, int x
,u32 y
)
322 writel(y
,(u8
*)dev
->mem_start
+x
);
326 void write_nic_word(struct net_device
*dev
, int x
,u16 y
)
328 writew(y
,(u8
*)dev
->mem_start
+x
);
332 #endif /* RTL_IO_MAP */
334 u8
rtl8192e_ap_sec_type(struct ieee80211_device
*ieee
)
336 static const u8 ccmp_ie
[4] = {0x00,0x50,0xf2,0x04};
337 static const u8 ccmp_rsn_ie
[4] = {0x00, 0x0f, 0xac, 0x04};
338 int wpa_ie_len
= ieee
->wpa_ie_len
;
339 struct ieee80211_crypt_data
* crypt
;
342 crypt
= ieee
->crypt
[ieee
->tx_keyidx
];
344 encrypt
= (ieee
->current_network
.capability
& WLAN_CAPABILITY_PRIVACY
) ||
345 (ieee
->host_encrypt
&& crypt
&& crypt
->ops
&&
346 (0 == strcmp(crypt
->ops
->name
,"WEP")));
349 if(encrypt
&& (wpa_ie_len
== 0)) {
350 // wep encryption, no N mode setting */
352 } else if((wpa_ie_len
!= 0)) {
353 // parse pairwise key type */
354 if (((ieee
->wpa_ie
[0] == 0xdd) && (!memcmp(&(ieee
->wpa_ie
[14]),ccmp_ie
,4))) ||
355 ((ieee
->wpa_ie
[0] == 0x30) && (!memcmp(&ieee
->wpa_ie
[10],ccmp_rsn_ie
, 4))))
365 rtl8192e_SetHwReg(struct net_device
*dev
,u8 variable
,u8
* val
)
367 struct r8192_priv
* priv
= ieee80211_priv(dev
);
373 write_nic_dword(dev
, BSSIDR
, ((u32
*)(val
))[0]);
374 write_nic_word(dev
, BSSIDR
+2, ((u16
*)(val
+2))[0]);
377 case HW_VAR_MEDIA_STATUS
:
379 RT_OP_MODE OpMode
= *((RT_OP_MODE
*)(val
));
380 u8 btMsr
= read_nic_byte(dev
, MSR
);
386 case RT_OP_MODE_INFRASTRUCTURE
:
390 case RT_OP_MODE_IBSS
:
403 write_nic_byte(dev
, MSR
, btMsr
);
407 case HW_VAR_CHECK_BSSID
:
411 Type
= ((u8
*)(val
))[0];
412 RegRCR
= read_nic_dword(dev
,RCR
);
413 priv
->ReceiveConfig
= RegRCR
;
416 RegRCR
|= (RCR_CBSSID
);
417 else if (Type
== false)
418 RegRCR
&= (~RCR_CBSSID
);
420 write_nic_dword(dev
, RCR
,RegRCR
);
421 priv
->ReceiveConfig
= RegRCR
;
426 case HW_VAR_SLOT_TIME
:
428 priv
->slot_time
= val
[0];
429 write_nic_byte(dev
, SLOT_TIME
, val
[0]);
434 case HW_VAR_ACK_PREAMBLE
:
437 priv
->short_preamble
= (bool)(*(u8
*)val
);
438 regTmp
= priv
->basic_rate
;
439 if (priv
->short_preamble
)
440 regTmp
|= BRSR_AckShortPmb
;
441 write_nic_dword(dev
, RRSR
, regTmp
);
446 write_nic_dword(dev
, CPU_GEN
, ((u32
*)(val
))[0]);
455 static struct proc_dir_entry
*rtl8192_proc
= NULL
;
457 static int proc_get_stats_ap(char *page
, char **start
,
458 off_t offset
, int count
,
459 int *eof
, void *data
)
461 struct net_device
*dev
= data
;
462 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
463 struct ieee80211_device
*ieee
= priv
->ieee80211
;
464 struct ieee80211_network
*target
;
467 list_for_each_entry(target
, &ieee
->network_list
, list
) {
469 len
+= snprintf(page
+ len
, count
- len
,
470 "%s ", target
->ssid
);
472 if(target
->wpa_ie_len
>0 || target
->rsn_ie_len
>0){
473 len
+= snprintf(page
+ len
, count
- len
,
477 len
+= snprintf(page
+ len
, count
- len
,
487 static int proc_get_registers(char *page
, char **start
,
488 off_t offset
, int count
,
489 int *eof
, void *data
)
491 struct net_device
*dev
= data
;
496 /* This dump the current register page */
497 len
+= snprintf(page
+ len
, count
- len
,
498 "\n####################page 0##################\n ");
502 len
+= snprintf(page
+ len
, count
- len
,
505 for(i
=0;i
<16 && n
<=max
;i
++,n
++)
506 len
+= snprintf(page
+ len
, count
- len
,
507 "%2x ",read_nic_byte(dev
,n
));
509 len
+= snprintf(page
+ len
, count
- len
,"\n");
510 len
+= snprintf(page
+ len
, count
- len
,
511 "\n####################page 1##################\n ");
514 len
+= snprintf(page
+ len
, count
- len
,
517 for(i
=0;i
<16 && n
<=max
;i
++,n
++)
518 len
+= snprintf(page
+ len
, count
- len
,
519 "%2x ",read_nic_byte(dev
,0x100|n
));
522 len
+= snprintf(page
+ len
, count
- len
,
523 "\n####################page 3##################\n ");
526 len
+= snprintf(page
+ len
, count
- len
,
529 for(i
=0;i
<16 && n
<=max
;i
++,n
++)
530 len
+= snprintf(page
+ len
, count
- len
,
531 "%2x ",read_nic_byte(dev
,0x300|n
));
539 static int proc_get_stats_tx(char *page
, char **start
,
540 off_t offset
, int count
,
541 int *eof
, void *data
)
543 struct net_device
*dev
= data
;
544 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
548 len
+= snprintf(page
+ len
, count
- len
,
549 "TX VI priority ok int: %lu\n"
550 "TX VO priority ok int: %lu\n"
551 "TX BE priority ok int: %lu\n"
552 "TX BK priority ok int: %lu\n"
553 "TX MANAGE priority ok int: %lu\n"
554 "TX BEACON priority ok int: %lu\n"
555 "TX BEACON priority error int: %lu\n"
556 "TX CMDPKT priority ok int: %lu\n"
557 "TX queue stopped?: %d\n"
558 "TX fifo overflow: %lu\n"
559 "TX total data packets %lu\n"
560 "TX total data bytes :%lu\n",
561 priv
->stats
.txviokint
,
562 priv
->stats
.txvookint
,
563 priv
->stats
.txbeokint
,
564 priv
->stats
.txbkokint
,
565 priv
->stats
.txmanageokint
,
566 priv
->stats
.txbeaconokint
,
567 priv
->stats
.txbeaconerr
,
568 priv
->stats
.txcmdpktokint
,
569 netif_queue_stopped(dev
),
570 priv
->stats
.txoverflow
,
571 priv
->ieee80211
->stats
.tx_packets
,
572 priv
->ieee80211
->stats
.tx_bytes
);
580 static int proc_get_stats_rx(char *page
, char **start
,
581 off_t offset
, int count
,
582 int *eof
, void *data
)
584 struct net_device
*dev
= data
;
585 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
589 len
+= snprintf(page
+ len
, count
- len
,
592 "RX rx overflow error: %lu\n",
595 priv
->stats
.rxoverflow
);
601 static void rtl8192_proc_module_init(void)
603 RT_TRACE(COMP_INIT
, "Initializing proc filesystem");
604 rtl8192_proc
=create_proc_entry(RTL819xE_MODULE_NAME
, S_IFDIR
, init_net
.proc_net
);
608 static void rtl8192_proc_module_remove(void)
610 remove_proc_entry(RTL819xE_MODULE_NAME
, init_net
.proc_net
);
614 static void rtl8192_proc_remove_one(struct net_device
*dev
)
616 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
618 printk("dev name=======> %s\n",dev
->name
);
621 // remove_proc_entry("stats-hw", priv->dir_dev);
622 remove_proc_entry("stats-tx", priv
->dir_dev
);
623 remove_proc_entry("stats-rx", priv
->dir_dev
);
624 // remove_proc_entry("stats-ieee", priv->dir_dev);
625 remove_proc_entry("stats-ap", priv
->dir_dev
);
626 remove_proc_entry("registers", priv
->dir_dev
);
627 // remove_proc_entry("cck-registers",priv->dir_dev);
628 // remove_proc_entry("ofdm-registers",priv->dir_dev);
629 //remove_proc_entry(dev->name, rtl8192_proc);
630 remove_proc_entry("wlan0", rtl8192_proc
);
631 priv
->dir_dev
= NULL
;
636 static void rtl8192_proc_init_one(struct net_device
*dev
)
638 struct proc_dir_entry
*e
;
639 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
640 priv
->dir_dev
= create_proc_entry(dev
->name
,
641 S_IFDIR
| S_IRUGO
| S_IXUGO
,
643 if (!priv
->dir_dev
) {
644 RT_TRACE(COMP_ERR
, "Unable to initialize /proc/net/rtl8192/%s\n",
648 e
= create_proc_read_entry("stats-rx", S_IFREG
| S_IRUGO
,
649 priv
->dir_dev
, proc_get_stats_rx
, dev
);
652 RT_TRACE(COMP_ERR
,"Unable to initialize "
653 "/proc/net/rtl8192/%s/stats-rx\n",
658 e
= create_proc_read_entry("stats-tx", S_IFREG
| S_IRUGO
,
659 priv
->dir_dev
, proc_get_stats_tx
, dev
);
662 RT_TRACE(COMP_ERR
, "Unable to initialize "
663 "/proc/net/rtl8192/%s/stats-tx\n",
667 e
= create_proc_read_entry("stats-ap", S_IFREG
| S_IRUGO
,
668 priv
->dir_dev
, proc_get_stats_ap
, dev
);
671 RT_TRACE(COMP_ERR
, "Unable to initialize "
672 "/proc/net/rtl8192/%s/stats-ap\n",
676 e
= create_proc_read_entry("registers", S_IFREG
| S_IRUGO
,
677 priv
->dir_dev
, proc_get_registers
, dev
);
679 RT_TRACE(COMP_ERR
, "Unable to initialize "
680 "/proc/net/rtl8192/%s/registers\n",
685 short check_nic_enough_desc(struct net_device
*dev
, int prio
)
687 struct r8192_priv
*priv
= ieee80211_priv(dev
);
688 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
690 /* for now we reserve two free descriptor as a safety boundary
691 * between the tail and the head
693 return (ring
->entries
- skb_queue_len(&ring
->queue
) >= 2);
696 static void tx_timeout(struct net_device
*dev
)
698 struct r8192_priv
*priv
= ieee80211_priv(dev
);
700 schedule_work(&priv
->reset_wq
);
704 static void rtl8192_irq_enable(struct net_device
*dev
)
706 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
707 priv
->irq_enabled
= 1;
708 write_nic_dword(dev
,INTA_MASK
, priv
->irq_mask
);
711 void rtl8192_irq_disable(struct net_device
*dev
)
713 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
715 write_nic_dword(dev
,INTA_MASK
,0);
716 priv
->irq_enabled
= 0;
719 void rtl8192_update_msr(struct net_device
*dev
)
721 struct r8192_priv
*priv
= ieee80211_priv(dev
);
724 msr
= read_nic_byte(dev
, MSR
);
725 msr
&= ~ MSR_LINK_MASK
;
727 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
728 * msr must be updated if the state is ASSOCIATING.
729 * this is intentional and make sense for ad-hoc and
730 * master (see the create BSS/IBSS func)
732 if (priv
->ieee80211
->state
== IEEE80211_LINKED
){
734 if (priv
->ieee80211
->iw_mode
== IW_MODE_INFRA
)
735 msr
|= (MSR_LINK_MANAGED
<<MSR_LINK_SHIFT
);
736 else if (priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
737 msr
|= (MSR_LINK_ADHOC
<<MSR_LINK_SHIFT
);
738 else if (priv
->ieee80211
->iw_mode
== IW_MODE_MASTER
)
739 msr
|= (MSR_LINK_MASTER
<<MSR_LINK_SHIFT
);
742 msr
|= (MSR_LINK_NONE
<<MSR_LINK_SHIFT
);
744 write_nic_byte(dev
, MSR
, msr
);
747 void rtl8192_set_chan(struct net_device
*dev
,short ch
)
749 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
753 /* need to implement rf set channel here WB */
755 if (priv
->rf_set_chan
)
756 priv
->rf_set_chan(dev
, priv
->chan
);
759 void rtl8192_rx_enable(struct net_device
*dev
)
761 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
763 write_nic_dword(dev
, RDQDA
,priv
->rx_ring_dma
);
766 /* the TX_DESC_BASE setting is according to the following queue index
775 * BEACON_QUEUE ===> 8
777 static const u32 TX_DESC_BASE
[] = {BKQDA
, BEQDA
, VIQDA
, VOQDA
, HCCAQDA
, CQDA
, MQDA
, HQDA
, BQDA
};
778 void rtl8192_tx_enable(struct net_device
*dev
)
780 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
783 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
784 write_nic_dword(dev
, TX_DESC_BASE
[i
], priv
->tx_ring
[i
].dma
);
786 ieee80211_reset_queue(priv
->ieee80211
);
790 static void rtl8192_free_rx_ring(struct net_device
*dev
)
792 struct r8192_priv
*priv
= ieee80211_priv(dev
);
795 for (i
= 0; i
< priv
->rxringcount
; i
++) {
796 struct sk_buff
*skb
= priv
->rx_buf
[i
];
800 pci_unmap_single(priv
->pdev
,
801 *((dma_addr_t
*)skb
->cb
),
802 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
806 pci_free_consistent(priv
->pdev
, sizeof(*priv
->rx_ring
) * priv
->rxringcount
,
807 priv
->rx_ring
, priv
->rx_ring_dma
);
808 priv
->rx_ring
= NULL
;
811 static void rtl8192_free_tx_ring(struct net_device
*dev
, unsigned int prio
)
813 struct r8192_priv
*priv
= ieee80211_priv(dev
);
814 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
816 while (skb_queue_len(&ring
->queue
)) {
817 tx_desc_819x_pci
*entry
= &ring
->desc
[ring
->idx
];
818 struct sk_buff
*skb
= __skb_dequeue(&ring
->queue
);
820 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
821 skb
->len
, PCI_DMA_TODEVICE
);
823 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
826 pci_free_consistent(priv
->pdev
, sizeof(*ring
->desc
)*ring
->entries
,
827 ring
->desc
, ring
->dma
);
831 void PHY_SetRtl8192eRfOff(struct net_device
* dev
)
833 //disable RF-Chip A/B
834 rtl8192_setBBreg(dev
, rFPGA0_XA_RFInterfaceOE
, BIT4
, 0x0);
835 //analog to digital off, for power save
836 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter4
, 0x300, 0x0);
837 //digital to analog off, for power save
838 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter1
, 0x18, 0x0);
840 rtl8192_setBBreg(dev
, rOFDM0_TRxPathEnable
, 0xf, 0x0);
842 rtl8192_setBBreg(dev
, rOFDM1_TRxPathEnable
, 0xf, 0x0);
843 //analog to digital part2 off, for power save
844 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter1
, 0x60, 0x0);
845 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter1
, 0x4, 0x0);
846 // Analog parameter!!Change bias and Lbus control.
847 write_nic_byte(dev
, ANAPAR_FOR_8192PciE
, 0x07);
851 void rtl8192_halt_adapter(struct net_device
*dev
, bool reset
)
853 struct r8192_priv
*priv
= ieee80211_priv(dev
);
858 OpMode
= RT_OP_MODE_NO_LINK
;
859 priv
->ieee80211
->SetHwRegHandler(dev
, HW_VAR_MEDIA_STATUS
, &OpMode
);
861 if (!priv
->ieee80211
->bSupportRemoteWakeUp
) {
863 * disable tx/rx. In 8185 we write 0x10 (Reset bit),
864 * but here we make reference to WMAC and wirte 0x0
866 write_nic_byte(dev
, CMDR
, 0);
875 priv
->bHwRfOffAction
= 2;
879 * Call MgntActSet_RF_State instead to
880 * prevent RF config race condition.
882 if (!priv
->ieee80211
->bSupportRemoteWakeUp
) {
883 PHY_SetRtl8192eRfOff(dev
);
884 ulRegRead
= read_nic_dword(dev
,CPU_GEN
);
885 ulRegRead
|= CPU_GEN_SYSTEM_RESET
;
886 write_nic_dword(dev
,CPU_GEN
, ulRegRead
);
889 write_nic_dword(dev
, WFCRC0
, 0xffffffff);
890 write_nic_dword(dev
, WFCRC1
, 0xffffffff);
891 write_nic_dword(dev
, WFCRC2
, 0xffffffff);
893 /* Write PMR register */
894 write_nic_byte(dev
, PMR
, 0x5);
895 /* Disable tx, enanble rx */
896 write_nic_byte(dev
, MacBlkCtrl
, 0xa);
900 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
901 skb_queue_purge(&priv
->ieee80211
->skb_waitQ
[i
]);
903 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
904 skb_queue_purge(&priv
->ieee80211
->skb_aggQ
[i
]);
907 skb_queue_purge(&priv
->skb_queue
);
910 static const u16 rtl_rate
[] = {10,20,55,110,60,90,120,180,240,360,480,540};
911 inline u16
rtl8192_rate2rate(short rate
)
913 if (rate
>11) return 0;
914 return rtl_rate
[rate
];
917 static void rtl8192_data_hard_stop(struct net_device
*dev
)
921 static void rtl8192_data_hard_resume(struct net_device
*dev
)
926 * this function TX data frames when the ieee80211 stack requires this.
927 * It checks also if we need to stop the ieee tx queue, eventually do it
929 static void rtl8192_hard_data_xmit(struct sk_buff
*skb
, struct net_device
*dev
, int rate
)
931 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
933 cb_desc
*tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
934 u8 queue_index
= tcb_desc
->queue_index
;
936 /* shall not be referred by command packet */
937 BUG_ON(queue_index
== TXCMD_QUEUE
);
939 if (priv
->bHwRadioOff
|| (!priv
->up
))
945 memcpy(skb
->cb
, &dev
, sizeof(dev
));
947 skb_push(skb
, priv
->ieee80211
->tx_headroom
);
948 ret
= rtl8192_tx(dev
, skb
);
953 if (queue_index
!= MGNT_QUEUE
) {
954 priv
->ieee80211
->stats
.tx_bytes
+= (skb
->len
- priv
->ieee80211
->tx_headroom
);
955 priv
->ieee80211
->stats
.tx_packets
++;
960 * This is a rough attempt to TX a frame
961 * This is called by the ieee 80211 stack to TX management frames.
962 * If the ring is full packet are dropped (for data frame the queue
963 * is stopped before this can happen).
965 static int rtl8192_hard_start_xmit(struct sk_buff
*skb
,struct net_device
*dev
)
967 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
969 cb_desc
*tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
970 u8 queue_index
= tcb_desc
->queue_index
;
972 if (queue_index
!= TXCMD_QUEUE
) {
973 if (priv
->bHwRadioOff
|| (!priv
->up
))
980 memcpy(skb
->cb
, &dev
, sizeof(dev
));
981 if (queue_index
== TXCMD_QUEUE
) {
982 rtl819xE_tx_cmd(dev
, skb
);
986 tcb_desc
->RATRIndex
= 7;
987 tcb_desc
->bTxDisableRateFallBack
= 1;
988 tcb_desc
->bTxUseDriverAssingedRate
= 1;
989 tcb_desc
->bTxEnableFwCalcDur
= 1;
990 skb_push(skb
, priv
->ieee80211
->tx_headroom
);
991 ret
= rtl8192_tx(dev
, skb
);
1001 static void rtl8192_tx_isr(struct net_device
*dev
, int prio
)
1003 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
1004 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
1006 while (skb_queue_len(&ring
->queue
)) {
1007 tx_desc_819x_pci
*entry
= &ring
->desc
[ring
->idx
];
1008 struct sk_buff
*skb
;
1011 * beacon packet will only use the first descriptor defaultly,
1012 * and the OWN may not be cleared by the hardware
1014 if (prio
!= BEACON_QUEUE
) {
1017 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
1020 skb
= __skb_dequeue(&ring
->queue
);
1021 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
1022 skb
->len
, PCI_DMA_TODEVICE
);
1026 if (prio
== MGNT_QUEUE
) {
1027 if (priv
->ieee80211
->ack_tx_to_ieee
) {
1028 if (rtl8192_is_tx_queue_empty(dev
)) {
1029 priv
->ieee80211
->ack_tx_to_ieee
= 0;
1030 ieee80211_ps_tx_ack(priv
->ieee80211
, 1);
1035 if (prio
!= BEACON_QUEUE
) {
1036 /* try to deal with the pending packets */
1037 tasklet_schedule(&priv
->irq_tx_tasklet
);
1041 static void rtl8192_stop_beacon(struct net_device
*dev
)
1045 static void rtl8192_config_rate(struct net_device
* dev
, u16
* rate_config
)
1047 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1048 struct ieee80211_network
*net
;
1049 u8 i
=0, basic_rate
= 0;
1050 net
= & priv
->ieee80211
->current_network
;
1052 for (i
=0; i
<net
->rates_len
; i
++)
1054 basic_rate
= net
->rates
[i
]&0x7f;
1057 case MGN_1M
: *rate_config
|= RRSR_1M
; break;
1058 case MGN_2M
: *rate_config
|= RRSR_2M
; break;
1059 case MGN_5_5M
: *rate_config
|= RRSR_5_5M
; break;
1060 case MGN_11M
: *rate_config
|= RRSR_11M
; break;
1061 case MGN_6M
: *rate_config
|= RRSR_6M
; break;
1062 case MGN_9M
: *rate_config
|= RRSR_9M
; break;
1063 case MGN_12M
: *rate_config
|= RRSR_12M
; break;
1064 case MGN_18M
: *rate_config
|= RRSR_18M
; break;
1065 case MGN_24M
: *rate_config
|= RRSR_24M
; break;
1066 case MGN_36M
: *rate_config
|= RRSR_36M
; break;
1067 case MGN_48M
: *rate_config
|= RRSR_48M
; break;
1068 case MGN_54M
: *rate_config
|= RRSR_54M
; break;
1071 for (i
=0; i
<net
->rates_ex_len
; i
++)
1073 basic_rate
= net
->rates_ex
[i
]&0x7f;
1076 case MGN_1M
: *rate_config
|= RRSR_1M
; break;
1077 case MGN_2M
: *rate_config
|= RRSR_2M
; break;
1078 case MGN_5_5M
: *rate_config
|= RRSR_5_5M
; break;
1079 case MGN_11M
: *rate_config
|= RRSR_11M
; break;
1080 case MGN_6M
: *rate_config
|= RRSR_6M
; break;
1081 case MGN_9M
: *rate_config
|= RRSR_9M
; break;
1082 case MGN_12M
: *rate_config
|= RRSR_12M
; break;
1083 case MGN_18M
: *rate_config
|= RRSR_18M
; break;
1084 case MGN_24M
: *rate_config
|= RRSR_24M
; break;
1085 case MGN_36M
: *rate_config
|= RRSR_36M
; break;
1086 case MGN_48M
: *rate_config
|= RRSR_48M
; break;
1087 case MGN_54M
: *rate_config
|= RRSR_54M
; break;
1093 #define SHORT_SLOT_TIME 9
1094 #define NON_SHORT_SLOT_TIME 20
1096 static void rtl8192_update_cap(struct net_device
* dev
, u16 cap
)
1099 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1100 struct ieee80211_network
*net
= &priv
->ieee80211
->current_network
;
1101 priv
->short_preamble
= cap
& WLAN_CAPABILITY_SHORT_PREAMBLE
;
1102 tmp
= priv
->basic_rate
;
1103 if (priv
->short_preamble
)
1104 tmp
|= BRSR_AckShortPmb
;
1105 write_nic_dword(dev
, RRSR
, tmp
);
1107 if (net
->mode
& (IEEE_G
|IEEE_N_24G
))
1110 if ((cap
& WLAN_CAPABILITY_SHORT_SLOT
)&&(!priv
->ieee80211
->pHTInfo
->bCurrentRT2RTLongSlotTime
))
1112 slot_time
= SHORT_SLOT_TIME
;
1114 else //long slot time
1115 slot_time
= NON_SHORT_SLOT_TIME
;
1116 priv
->slot_time
= slot_time
;
1117 write_nic_byte(dev
, SLOT_TIME
, slot_time
);
1122 static void rtl8192_net_update(struct net_device
*dev
)
1124 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1125 struct ieee80211_network
*net
;
1126 u16 BcnTimeCfg
= 0, BcnCW
= 6, BcnIFS
= 0xf;
1127 u16 rate_config
= 0;
1128 net
= &priv
->ieee80211
->current_network
;
1130 /* update Basic rate: RR, BRSR */
1131 rtl8192_config_rate(dev
, &rate_config
);
1134 * Select RRSR (in Legacy-OFDM and CCK)
1135 * For 8190, we select only 24M, 12M, 6M, 11M, 5.5M,
1136 * 2M, and 1M from the Basic rate.
1137 * We do not use other rates.
1139 priv
->basic_rate
= rate_config
&= 0x15f;
1142 write_nic_dword(dev
, BSSIDR
, ((u32
*)net
->bssid
)[0]);
1143 write_nic_word(dev
, BSSIDR
+4, ((u16
*)net
->bssid
)[2]);
1145 if (priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
1147 write_nic_word(dev
, ATIMWND
, 2);
1148 write_nic_word(dev
, BCN_DMATIME
, 256);
1149 write_nic_word(dev
, BCN_INTERVAL
, net
->beacon_interval
);
1151 * BIT15 of BCN_DRV_EARLY_INT will indicate
1152 * whether software beacon or hw beacon is applied.
1154 write_nic_word(dev
, BCN_DRV_EARLY_INT
, 10);
1155 write_nic_byte(dev
, BCN_ERR_THRESH
, 100);
1157 BcnTimeCfg
|= (BcnCW
<<BCN_TCFG_CW_SHIFT
);
1158 /* TODO: BcnIFS may required to be changed on ASIC */
1159 BcnTimeCfg
|= BcnIFS
<<BCN_TCFG_IFS
;
1160 write_nic_word(dev
, BCN_TCFG
, BcnTimeCfg
);
1164 void rtl819xE_tx_cmd(struct net_device
*dev
, struct sk_buff
*skb
)
1166 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1167 struct rtl8192_tx_ring
*ring
;
1168 tx_desc_819x_pci
*entry
;
1172 unsigned long flags
;
1174 ring
= &priv
->tx_ring
[TXCMD_QUEUE
];
1175 mapping
= pci_map_single(priv
->pdev
, skb
->data
, skb
->len
, PCI_DMA_TODEVICE
);
1177 spin_lock_irqsave(&priv
->irq_th_lock
,flags
);
1178 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
1179 entry
= &ring
->desc
[idx
];
1181 tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
1183 entry
->LINIP
= tcb_desc
->bLastIniPkt
;
1184 entry
->FirstSeg
= 1;//first segment
1185 entry
->LastSeg
= 1; //last segment
1186 if(tcb_desc
->bCmdOrInit
== DESC_PACKET_TYPE_INIT
) {
1187 entry
->CmdInit
= DESC_PACKET_TYPE_INIT
;
1189 entry
->CmdInit
= DESC_PACKET_TYPE_NORMAL
;
1190 entry
->Offset
= sizeof(TX_FWINFO_8190PCI
) + 8;
1191 entry
->PktSize
= (u16
)(tcb_desc
->pkt_size
+ entry
->Offset
);
1192 entry
->QueueSelect
= QSLT_CMD
;
1193 entry
->TxFWInfoSize
= 0x08;
1194 entry
->RATid
= (u8
)DESC_PACKET_TYPE_INIT
;
1196 entry
->TxBufferSize
= skb
->len
;
1197 entry
->TxBuffAddr
= cpu_to_le32(mapping
);
1200 __skb_queue_tail(&ring
->queue
, skb
);
1201 spin_unlock_irqrestore(&priv
->irq_th_lock
,flags
);
1203 write_nic_byte(dev
, TPPoll
, TPPoll_CQ
);
1209 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1210 * in TxFwInfo data structure
1212 static u8
MapHwQueueToFirmwareQueue(u8 QueueID
)
1218 QueueSelect
= QSLT_BE
;
1222 QueueSelect
= QSLT_BK
;
1226 QueueSelect
= QSLT_VO
;
1230 QueueSelect
= QSLT_VI
;
1234 QueueSelect
= QSLT_MGNT
;
1238 QueueSelect
= QSLT_BEACON
;
1242 QueueSelect
= QSLT_CMD
;
1247 RT_TRACE(COMP_ERR
, "Impossible Queue Selection: %d\n", QueueID
);
1253 static u8
MRateToHwRate8190Pci(u8 rate
)
1255 u8 ret
= DESC90_RATE1M
;
1258 case MGN_1M
: ret
= DESC90_RATE1M
; break;
1259 case MGN_2M
: ret
= DESC90_RATE2M
; break;
1260 case MGN_5_5M
: ret
= DESC90_RATE5_5M
; break;
1261 case MGN_11M
: ret
= DESC90_RATE11M
; break;
1262 case MGN_6M
: ret
= DESC90_RATE6M
; break;
1263 case MGN_9M
: ret
= DESC90_RATE9M
; break;
1264 case MGN_12M
: ret
= DESC90_RATE12M
; break;
1265 case MGN_18M
: ret
= DESC90_RATE18M
; break;
1266 case MGN_24M
: ret
= DESC90_RATE24M
; break;
1267 case MGN_36M
: ret
= DESC90_RATE36M
; break;
1268 case MGN_48M
: ret
= DESC90_RATE48M
; break;
1269 case MGN_54M
: ret
= DESC90_RATE54M
; break;
1271 // HT rate since here
1272 case MGN_MCS0
: ret
= DESC90_RATEMCS0
; break;
1273 case MGN_MCS1
: ret
= DESC90_RATEMCS1
; break;
1274 case MGN_MCS2
: ret
= DESC90_RATEMCS2
; break;
1275 case MGN_MCS3
: ret
= DESC90_RATEMCS3
; break;
1276 case MGN_MCS4
: ret
= DESC90_RATEMCS4
; break;
1277 case MGN_MCS5
: ret
= DESC90_RATEMCS5
; break;
1278 case MGN_MCS6
: ret
= DESC90_RATEMCS6
; break;
1279 case MGN_MCS7
: ret
= DESC90_RATEMCS7
; break;
1280 case MGN_MCS8
: ret
= DESC90_RATEMCS8
; break;
1281 case MGN_MCS9
: ret
= DESC90_RATEMCS9
; break;
1282 case MGN_MCS10
: ret
= DESC90_RATEMCS10
; break;
1283 case MGN_MCS11
: ret
= DESC90_RATEMCS11
; break;
1284 case MGN_MCS12
: ret
= DESC90_RATEMCS12
; break;
1285 case MGN_MCS13
: ret
= DESC90_RATEMCS13
; break;
1286 case MGN_MCS14
: ret
= DESC90_RATEMCS14
; break;
1287 case MGN_MCS15
: ret
= DESC90_RATEMCS15
; break;
1288 case (0x80|0x20): ret
= DESC90_RATEMCS32
; break;
1296 static u8
QueryIsShort(u8 TxHT
, u8 TxRate
, cb_desc
*tcb_desc
)
1300 tmp_Short
= (TxHT
==1)?((tcb_desc
->bUseShortGI
)?1:0):((tcb_desc
->bUseShortPreamble
)?1:0);
1302 if(TxHT
==1 && TxRate
!= DESC90_RATEMCS15
)
1309 * The tx procedure is just as following,
1310 * skb->cb will contain all the following information,
1311 * priority, morefrag, rate, &dev.
1313 short rtl8192_tx(struct net_device
*dev
, struct sk_buff
* skb
)
1315 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1316 struct rtl8192_tx_ring
*ring
;
1317 unsigned long flags
;
1318 cb_desc
*tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
1319 tx_desc_819x_pci
*pdesc
= NULL
;
1320 TX_FWINFO_8190PCI
*pTxFwInfo
= NULL
;
1322 bool multi_addr
= false, broad_addr
= false, uni_addr
= false;
1323 u8
*pda_addr
= NULL
;
1326 if (priv
->bdisable_nic
) {
1327 RT_TRACE(COMP_ERR
, "Nic is disabled! Can't tx packet len=%d qidx=%d!!!\n",
1328 skb
->len
, tcb_desc
->queue_index
);
1333 priv
->ieee80211
->bAwakePktSent
= true;
1336 mapping
= pci_map_single(priv
->pdev
, skb
->data
, skb
->len
, PCI_DMA_TODEVICE
);
1338 /* collect the tx packets statitcs */
1339 pda_addr
= ((u8
*)skb
->data
) + sizeof(TX_FWINFO_8190PCI
);
1340 if (is_multicast_ether_addr(pda_addr
))
1342 else if (is_broadcast_ether_addr(pda_addr
))
1348 priv
->stats
.txbytesunicast
+= (u8
)(skb
->len
) - sizeof(TX_FWINFO_8190PCI
);
1350 /* fill tx firmware */
1351 pTxFwInfo
= (PTX_FWINFO_8190PCI
)skb
->data
;
1352 memset(pTxFwInfo
, 0, sizeof(TX_FWINFO_8190PCI
));
1353 pTxFwInfo
->TxHT
= (tcb_desc
->data_rate
&0x80) ? 1 : 0;
1354 pTxFwInfo
->TxRate
= MRateToHwRate8190Pci((u8
)tcb_desc
->data_rate
);
1355 pTxFwInfo
->EnableCPUDur
= tcb_desc
->bTxEnableFwCalcDur
;
1356 pTxFwInfo
->Short
= QueryIsShort(pTxFwInfo
->TxHT
, pTxFwInfo
->TxRate
, tcb_desc
);
1358 /* Aggregation related */
1359 if (tcb_desc
->bAMPDUEnable
) {
1360 pTxFwInfo
->AllowAggregation
= 1;
1361 pTxFwInfo
->RxMF
= tcb_desc
->ampdu_factor
;
1362 pTxFwInfo
->RxAMD
= tcb_desc
->ampdu_density
;
1364 pTxFwInfo
->AllowAggregation
= 0;
1365 pTxFwInfo
->RxMF
= 0;
1366 pTxFwInfo
->RxAMD
= 0;
1369 /* Protection mode related */
1370 pTxFwInfo
->RtsEnable
= (tcb_desc
->bRTSEnable
) ? 1 : 0;
1371 pTxFwInfo
->CtsEnable
= (tcb_desc
->bCTSEnable
) ? 1 : 0;
1372 pTxFwInfo
->RtsSTBC
= (tcb_desc
->bRTSSTBC
) ? 1 : 0;
1373 pTxFwInfo
->RtsHT
= (tcb_desc
->rts_rate
&0x80) ? 1 : 0;
1374 pTxFwInfo
->RtsRate
= MRateToHwRate8190Pci((u8
)tcb_desc
->rts_rate
);
1375 pTxFwInfo
->RtsBandwidth
= 0;
1376 pTxFwInfo
->RtsSubcarrier
= tcb_desc
->RTSSC
;
1377 pTxFwInfo
->RtsShort
= (pTxFwInfo
->RtsHT
== 0) ? (tcb_desc
->bRTSUseShortPreamble
? 1 : 0) : (tcb_desc
->bRTSUseShortGI
? 1 : 0);
1379 /* Set Bandwidth and sub-channel settings. */
1380 if (priv
->CurrentChannelBW
== HT_CHANNEL_WIDTH_20_40
) {
1381 if (tcb_desc
->bPacketBW
) {
1382 pTxFwInfo
->TxBandwidth
= 1;
1384 pTxFwInfo
->TxSubCarrier
= 3;
1386 /* use duplicated mode */
1387 pTxFwInfo
->TxSubCarrier
= 0;
1390 pTxFwInfo
->TxBandwidth
= 0;
1391 pTxFwInfo
->TxSubCarrier
= priv
->nCur40MhzPrimeSC
;
1394 pTxFwInfo
->TxBandwidth
= 0;
1395 pTxFwInfo
->TxSubCarrier
= 0;
1398 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
1399 ring
= &priv
->tx_ring
[tcb_desc
->queue_index
];
1400 if (tcb_desc
->queue_index
!= BEACON_QUEUE
)
1401 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
1405 pdesc
= &ring
->desc
[idx
];
1406 if ((pdesc
->OWN
== 1) && (tcb_desc
->queue_index
!= BEACON_QUEUE
)) {
1407 RT_TRACE(COMP_ERR
, "No more TX desc@%d, ring->idx = %d,idx = %d,%x",
1408 tcb_desc
->queue_index
, ring
->idx
, idx
, skb
->len
);
1409 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
1413 /* fill tx descriptor */
1414 memset(pdesc
, 0, 12);
1419 pdesc
->Offset
= sizeof(TX_FWINFO_8190PCI
) + 8; /* We must add 8!! */
1420 pdesc
->PktSize
= (u16
)skb
->len
-sizeof(TX_FWINFO_8190PCI
);
1423 pdesc
->SecCAMID
= 0;
1424 pdesc
->RATid
= tcb_desc
->RATRIndex
;
1427 pdesc
->SecType
= 0x0;
1428 if (tcb_desc
->bHwSec
) {
1429 switch (priv
->ieee80211
->pairwise_key_type
) {
1430 case KEY_TYPE_WEP40
:
1431 case KEY_TYPE_WEP104
:
1432 pdesc
->SecType
= 0x1;
1436 pdesc
->SecType
= 0x2;
1440 pdesc
->SecType
= 0x3;
1444 pdesc
->SecType
= 0x0;
1453 pdesc
->QueueSelect
= MapHwQueueToFirmwareQueue(tcb_desc
->queue_index
);
1454 pdesc
->TxFWInfoSize
= sizeof(TX_FWINFO_8190PCI
);
1456 pdesc
->DISFB
= tcb_desc
->bTxDisableRateFallBack
;
1457 pdesc
->USERATE
= tcb_desc
->bTxUseDriverAssingedRate
;
1459 pdesc
->FirstSeg
= 1;
1461 pdesc
->TxBufferSize
= skb
->len
;
1463 pdesc
->TxBuffAddr
= cpu_to_le32(mapping
);
1464 __skb_queue_tail(&ring
->queue
, skb
);
1466 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
1467 dev
->trans_start
= jiffies
;
1468 write_nic_word(dev
, TPPoll
, 0x01<<tcb_desc
->queue_index
);
1472 static short rtl8192_alloc_rx_desc_ring(struct net_device
*dev
)
1474 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1475 rx_desc_819x_pci
*entry
= NULL
;
1478 priv
->rx_ring
= pci_alloc_consistent(priv
->pdev
,
1479 sizeof(*priv
->rx_ring
) * priv
->rxringcount
, &priv
->rx_ring_dma
);
1481 if (!priv
->rx_ring
|| (unsigned long)priv
->rx_ring
& 0xFF) {
1482 RT_TRACE(COMP_ERR
,"Cannot allocate RX ring\n");
1486 memset(priv
->rx_ring
, 0, sizeof(*priv
->rx_ring
) * priv
->rxringcount
);
1489 for (i
= 0; i
< priv
->rxringcount
; i
++) {
1490 struct sk_buff
*skb
= dev_alloc_skb(priv
->rxbuffersize
);
1491 dma_addr_t
*mapping
;
1492 entry
= &priv
->rx_ring
[i
];
1495 priv
->rx_buf
[i
] = skb
;
1496 mapping
= (dma_addr_t
*)skb
->cb
;
1497 *mapping
= pci_map_single(priv
->pdev
, skb_tail_pointer(skb
),
1498 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
1500 entry
->BufferAddress
= cpu_to_le32(*mapping
);
1502 entry
->Length
= priv
->rxbuffersize
;
1510 static int rtl8192_alloc_tx_desc_ring(struct net_device
*dev
,
1511 unsigned int prio
, unsigned int entries
)
1513 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
1514 tx_desc_819x_pci
*ring
;
1518 ring
= pci_alloc_consistent(priv
->pdev
, sizeof(*ring
) * entries
, &dma
);
1519 if (!ring
|| (unsigned long)ring
& 0xFF) {
1520 RT_TRACE(COMP_ERR
, "Cannot allocate TX ring (prio = %d)\n", prio
);
1524 memset(ring
, 0, sizeof(*ring
)*entries
);
1525 priv
->tx_ring
[prio
].desc
= ring
;
1526 priv
->tx_ring
[prio
].dma
= dma
;
1527 priv
->tx_ring
[prio
].idx
= 0;
1528 priv
->tx_ring
[prio
].entries
= entries
;
1529 skb_queue_head_init(&priv
->tx_ring
[prio
].queue
);
1531 for (i
= 0; i
< entries
; i
++)
1532 ring
[i
].NextDescAddress
=
1533 cpu_to_le32((u32
)dma
+ ((i
+ 1) % entries
) * sizeof(*ring
));
1538 static short rtl8192_pci_initdescring(struct net_device
*dev
)
1542 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1544 ret
= rtl8192_alloc_rx_desc_ring(dev
);
1548 /* general process for other queue */
1549 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
1550 ret
= rtl8192_alloc_tx_desc_ring(dev
, i
, priv
->txringcount
);
1552 goto err_free_rings
;
1558 rtl8192_free_rx_ring(dev
);
1559 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
1560 if (priv
->tx_ring
[i
].desc
)
1561 rtl8192_free_tx_ring(dev
, i
);
1565 static void rtl8192_pci_resetdescring(struct net_device
*dev
)
1567 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1570 /* force the rx_idx to the first one */
1572 rx_desc_819x_pci
*entry
= NULL
;
1573 for (i
= 0; i
< priv
->rxringcount
; i
++) {
1574 entry
= &priv
->rx_ring
[i
];
1580 /* after reset, release previous pending packet, and force the
1581 * tx idx to the first one */
1582 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
1583 if (priv
->tx_ring
[i
].desc
) {
1584 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[i
];
1586 while (skb_queue_len(&ring
->queue
)) {
1587 tx_desc_819x_pci
*entry
= &ring
->desc
[ring
->idx
];
1588 struct sk_buff
*skb
= __skb_dequeue(&ring
->queue
);
1590 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
1591 skb
->len
, PCI_DMA_TODEVICE
);
1593 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
1600 static void rtl8192_link_change(struct net_device
*dev
)
1602 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1603 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1604 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
1605 if (ieee
->state
== IEEE80211_LINKED
)
1607 rtl8192_net_update(dev
);
1608 rtl8192_update_ratr_table(dev
);
1610 //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
1611 if ((KEY_TYPE_WEP40
== ieee
->pairwise_key_type
) || (KEY_TYPE_WEP104
== ieee
->pairwise_key_type
))
1612 EnableHWSecurityConfig8192(dev
);
1616 write_nic_byte(dev
, 0x173, 0);
1618 /*update timing params*/
1619 //rtl8192_set_chan(dev, priv->chan);
1621 rtl8192_update_msr(dev
);
1623 // 2007/10/16 MH MAC Will update TSF according to all received beacon, so we have
1624 // // To set CBSSID bit when link with any AP or STA.
1625 if (ieee
->iw_mode
== IW_MODE_INFRA
|| ieee
->iw_mode
== IW_MODE_ADHOC
)
1628 reg
= read_nic_dword(dev
, RCR
);
1629 if (priv
->ieee80211
->state
== IEEE80211_LINKED
)
1630 priv
->ReceiveConfig
= reg
|= RCR_CBSSID
;
1632 priv
->ReceiveConfig
= reg
&= ~RCR_CBSSID
;
1633 write_nic_dword(dev
, RCR
, reg
);
1638 static const struct ieee80211_qos_parameters def_qos_parameters
= {
1639 {3,3,3,3},/* cw_min */
1640 {7,7,7,7},/* cw_max */
1641 {2,2,2,2},/* aifs */
1642 {0,0,0,0},/* flags */
1643 {0,0,0,0} /* tx_op_limit */
1646 static void rtl8192_update_beacon(struct work_struct
* work
)
1648 struct r8192_priv
*priv
= container_of(work
, struct r8192_priv
, update_beacon_wq
.work
);
1649 struct net_device
*dev
= priv
->ieee80211
->dev
;
1650 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1651 struct ieee80211_network
* net
= &ieee
->current_network
;
1653 if (ieee
->pHTInfo
->bCurrentHTSupport
)
1654 HTUpdateSelfAndPeerSetting(ieee
, net
);
1655 ieee
->pHTInfo
->bCurrentRT2RTLongSlotTime
= net
->bssht
.bdRT2RTLongSlotTime
;
1656 rtl8192_update_cap(dev
, net
->capability
);
1660 * background support to run QoS activate functionality
1662 static const int WDCAPARA_ADD
[] = {EDCAPARA_BE
,EDCAPARA_BK
,EDCAPARA_VI
,EDCAPARA_VO
};
1663 static void rtl8192_qos_activate(struct work_struct
* work
)
1665 struct r8192_priv
*priv
= container_of(work
, struct r8192_priv
, qos_activate
);
1666 struct net_device
*dev
= priv
->ieee80211
->dev
;
1667 struct ieee80211_qos_parameters
*qos_parameters
= &priv
->ieee80211
->current_network
.qos_data
.parameters
;
1668 u8 mode
= priv
->ieee80211
->current_network
.mode
;
1673 mutex_lock(&priv
->mutex
);
1674 if(priv
->ieee80211
->state
!= IEEE80211_LINKED
)
1676 RT_TRACE(COMP_QOS
,"qos active process with associate response received\n");
1677 /* It better set slot time at first */
1678 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
1679 /* update the ac parameter to related registers */
1680 for(i
= 0; i
< QOS_QUEUE_NUM
; i
++) {
1681 //Mode G/A: slotTimeTimer = 9; Mode B: 20
1682 u1bAIFS
= qos_parameters
->aifs
[i
] * ((mode
&(IEEE_G
|IEEE_N_24G
)) ?9:20) + aSifsTime
;
1683 u4bAcParam
= ((((u32
)(qos_parameters
->tx_op_limit
[i
]))<< AC_PARAM_TXOP_LIMIT_OFFSET
)|
1684 (((u32
)(qos_parameters
->cw_max
[i
]))<< AC_PARAM_ECW_MAX_OFFSET
)|
1685 (((u32
)(qos_parameters
->cw_min
[i
]))<< AC_PARAM_ECW_MIN_OFFSET
)|
1686 ((u32
)u1bAIFS
<< AC_PARAM_AIFS_OFFSET
));
1687 write_nic_dword(dev
, WDCAPARA_ADD
[i
], u4bAcParam
);
1688 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
1692 mutex_unlock(&priv
->mutex
);
1695 static int rtl8192_qos_handle_probe_response(struct r8192_priv
*priv
,
1697 struct ieee80211_network
*network
)
1700 u32 size
= sizeof(struct ieee80211_qos_parameters
);
1702 if(priv
->ieee80211
->state
!=IEEE80211_LINKED
)
1705 if ((priv
->ieee80211
->iw_mode
!= IW_MODE_INFRA
))
1708 if (network
->flags
& NETWORK_HAS_QOS_MASK
) {
1709 if (active_network
&&
1710 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
))
1711 network
->qos_data
.active
= network
->qos_data
.supported
;
1713 if ((network
->qos_data
.active
== 1) && (active_network
== 1) &&
1714 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) &&
1715 (network
->qos_data
.old_param_count
!=
1716 network
->qos_data
.param_count
)) {
1717 network
->qos_data
.old_param_count
=
1718 network
->qos_data
.param_count
;
1719 queue_work(priv
->priv_wq
, &priv
->qos_activate
);
1720 RT_TRACE (COMP_QOS
, "QoS parameters change call "
1724 memcpy(&priv
->ieee80211
->current_network
.qos_data
.parameters
,
1725 &def_qos_parameters
, size
);
1727 if ((network
->qos_data
.active
== 1) && (active_network
== 1)) {
1728 queue_work(priv
->priv_wq
, &priv
->qos_activate
);
1729 RT_TRACE(COMP_QOS
, "QoS was disabled call qos_activate \n");
1731 network
->qos_data
.active
= 0;
1732 network
->qos_data
.supported
= 0;
1738 /* handle manage frame frame beacon and probe response */
1739 static int rtl8192_handle_beacon(struct net_device
* dev
,
1740 struct ieee80211_beacon
* beacon
,
1741 struct ieee80211_network
* network
)
1743 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1745 rtl8192_qos_handle_probe_response(priv
,1,network
);
1747 queue_delayed_work(priv
->priv_wq
, &priv
->update_beacon_wq
, 0);
1753 * handling the beaconing responses. if we get different QoS setting
1754 * off the network from the associated setting, adjust the QoS setting
1756 static int rtl8192_qos_association_resp(struct r8192_priv
*priv
,
1757 struct ieee80211_network
*network
)
1760 unsigned long flags
;
1761 u32 size
= sizeof(struct ieee80211_qos_parameters
);
1762 int set_qos_param
= 0;
1764 if ((priv
== NULL
) || (network
== NULL
))
1767 if (priv
->ieee80211
->state
!= IEEE80211_LINKED
)
1770 if ((priv
->ieee80211
->iw_mode
!= IW_MODE_INFRA
))
1773 spin_lock_irqsave(&priv
->ieee80211
->lock
, flags
);
1774 if (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) {
1775 memcpy(&priv
->ieee80211
->current_network
.qos_data
.parameters
,
1776 &network
->qos_data
.parameters
,
1777 sizeof(struct ieee80211_qos_parameters
));
1778 priv
->ieee80211
->current_network
.qos_data
.active
= 1;
1780 /* update qos parameter for current network */
1781 priv
->ieee80211
->current_network
.qos_data
.old_param_count
=
1782 priv
->ieee80211
->current_network
.qos_data
.param_count
;
1783 priv
->ieee80211
->current_network
.qos_data
.param_count
=
1784 network
->qos_data
.param_count
;
1787 memcpy(&priv
->ieee80211
->current_network
.qos_data
.parameters
,
1788 &def_qos_parameters
, size
);
1789 priv
->ieee80211
->current_network
.qos_data
.active
= 0;
1790 priv
->ieee80211
->current_network
.qos_data
.supported
= 0;
1794 spin_unlock_irqrestore(&priv
->ieee80211
->lock
, flags
);
1796 RT_TRACE(COMP_QOS
, "%s: network->flags = %d,%d\n", __FUNCTION__
,
1797 network
->flags
, priv
->ieee80211
->current_network
.qos_data
.active
);
1798 if (set_qos_param
== 1)
1799 queue_work(priv
->priv_wq
, &priv
->qos_activate
);
1805 static int rtl8192_handle_assoc_response(struct net_device
*dev
,
1806 struct ieee80211_assoc_response_frame
*resp
,
1807 struct ieee80211_network
*network
)
1809 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1810 rtl8192_qos_association_resp(priv
, network
);
1815 /* updateRATRTabel for MCS only. Basic rate is not implemented. */
1816 static void rtl8192_update_ratr_table(struct net_device
* dev
)
1818 struct r8192_priv
* priv
= ieee80211_priv(dev
);
1819 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1820 u8
* pMcsRate
= ieee
->dot11HTOperationalRateSet
;
1824 rtl8192_config_rate(dev
, (u16
*)(&ratr_value
));
1825 ratr_value
|= (*(u16
*)(pMcsRate
)) << 12;
1830 ratr_value
&= 0x00000FF0;
1833 ratr_value
&= 0x0000000F;
1836 ratr_value
&= 0x00000FF7;
1840 if (ieee
->pHTInfo
->PeerMimoPs
== 0) //MIMO_PS_STATIC
1841 ratr_value
&= 0x0007F007;
1843 if (priv
->rf_type
== RF_1T2R
)
1844 ratr_value
&= 0x000FF007;
1846 ratr_value
&= 0x0F81F007;
1852 ratr_value
&= 0x0FFFFFFF;
1853 if(ieee
->pHTInfo
->bCurTxBW40MHz
&& ieee
->pHTInfo
->bCurShortGI40MHz
){
1854 ratr_value
|= 0x80000000;
1855 }else if(!ieee
->pHTInfo
->bCurTxBW40MHz
&& ieee
->pHTInfo
->bCurShortGI20MHz
){
1856 ratr_value
|= 0x80000000;
1858 write_nic_dword(dev
, RATR0
+rate_index
*4, ratr_value
);
1859 write_nic_byte(dev
, UFWP
, 1);
1862 static bool GetNmodeSupportBySecCfg8190Pci(struct net_device
*dev
)
1864 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1865 struct ieee80211_device
*ieee
= priv
->ieee80211
;
1867 return !(ieee
->rtllib_ap_sec_type
&&
1868 (ieee
->rtllib_ap_sec_type(ieee
)&(SEC_ALG_WEP
|SEC_ALG_TKIP
)));
1871 static void rtl8192_refresh_supportrate(struct r8192_priv
* priv
)
1873 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1874 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
1875 if (ieee
->mode
== WIRELESS_MODE_N_24G
|| ieee
->mode
== WIRELESS_MODE_N_5G
)
1877 memcpy(ieee
->Regdot11HTOperationalRateSet
, ieee
->RegHTSuppRateSet
, 16);
1880 memset(ieee
->Regdot11HTOperationalRateSet
, 0, 16);
1883 static u8
rtl8192_getSupportedWireleeMode(struct net_device
*dev
)
1885 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1887 switch(priv
->rf_chip
)
1892 ret
= (WIRELESS_MODE_N_24G
|WIRELESS_MODE_G
|WIRELESS_MODE_B
);
1895 ret
= (WIRELESS_MODE_A
|WIRELESS_MODE_N_5G
);
1898 ret
= WIRELESS_MODE_B
;
1904 static void rtl8192_SetWirelessMode(struct net_device
* dev
, u8 wireless_mode
)
1906 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1907 u8 bSupportMode
= rtl8192_getSupportedWireleeMode(dev
);
1909 if ((wireless_mode
== WIRELESS_MODE_AUTO
) || ((wireless_mode
&bSupportMode
)==0))
1911 if(bSupportMode
& WIRELESS_MODE_N_24G
)
1913 wireless_mode
= WIRELESS_MODE_N_24G
;
1915 else if(bSupportMode
& WIRELESS_MODE_N_5G
)
1917 wireless_mode
= WIRELESS_MODE_N_5G
;
1919 else if((bSupportMode
& WIRELESS_MODE_A
))
1921 wireless_mode
= WIRELESS_MODE_A
;
1923 else if((bSupportMode
& WIRELESS_MODE_G
))
1925 wireless_mode
= WIRELESS_MODE_G
;
1927 else if((bSupportMode
& WIRELESS_MODE_B
))
1929 wireless_mode
= WIRELESS_MODE_B
;
1932 RT_TRACE(COMP_ERR
, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__
,bSupportMode
);
1933 wireless_mode
= WIRELESS_MODE_B
;
1936 priv
->ieee80211
->mode
= wireless_mode
;
1938 if ((wireless_mode
== WIRELESS_MODE_N_24G
) || (wireless_mode
== WIRELESS_MODE_N_5G
))
1939 priv
->ieee80211
->pHTInfo
->bEnableHT
= 1;
1941 priv
->ieee80211
->pHTInfo
->bEnableHT
= 0;
1942 RT_TRACE(COMP_INIT
, "Current Wireless Mode is %x\n", wireless_mode
);
1943 rtl8192_refresh_supportrate(priv
);
1946 static bool GetHalfNmodeSupportByAPs819xPci(struct net_device
* dev
)
1948 struct r8192_priv
* priv
= ieee80211_priv(dev
);
1949 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1951 return ieee
->bHalfWirelessN24GMode
;
1954 short rtl8192_is_tx_queue_empty(struct net_device
*dev
)
1957 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1958 for (i
=0; i
<=MGNT_QUEUE
; i
++)
1960 if ((i
== TXCMD_QUEUE
) || (i
== HCCA_QUEUE
) )
1962 if (skb_queue_len(&(&priv
->tx_ring
[i
])->queue
) > 0){
1963 printk("===>tx queue is not empty:%d, %d\n", i
, skb_queue_len(&(&priv
->tx_ring
[i
])->queue
));
1970 static void rtl8192_hw_sleep_down(struct net_device
*dev
)
1972 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1973 unsigned long flags
= 0;
1975 spin_lock_irqsave(&priv
->rf_ps_lock
,flags
);
1976 if (priv
->RFChangeInProgress
) {
1977 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
1978 RT_TRACE(COMP_RF
, "rtl8192_hw_sleep_down(): RF Change in progress! \n");
1979 printk("rtl8192_hw_sleep_down(): RF Change in progress!\n");
1982 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
1984 MgntActSet_RF_State(dev
, eRfSleep
, RF_CHANGE_BY_PS
);
1987 static void rtl8192_hw_sleep_wq (struct work_struct
*work
)
1989 struct delayed_work
*dwork
= container_of(work
,struct delayed_work
,work
);
1990 struct ieee80211_device
*ieee
= container_of(dwork
,struct ieee80211_device
,hw_sleep_wq
);
1991 struct net_device
*dev
= ieee
->dev
;
1993 rtl8192_hw_sleep_down(dev
);
1996 static void rtl8192_hw_wakeup(struct net_device
* dev
)
1998 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1999 unsigned long flags
= 0;
2001 spin_lock_irqsave(&priv
->rf_ps_lock
,flags
);
2002 if (priv
->RFChangeInProgress
) {
2003 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
2004 RT_TRACE(COMP_RF
, "rtl8192_hw_wakeup(): RF Change in progress! \n");
2005 printk("rtl8192_hw_wakeup(): RF Change in progress! schedule wake up task again\n");
2006 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
2009 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
2011 MgntActSet_RF_State(dev
, eRfOn
, RF_CHANGE_BY_PS
);
2014 void rtl8192_hw_wakeup_wq (struct work_struct
*work
)
2016 struct delayed_work
*dwork
= container_of(work
,struct delayed_work
,work
);
2017 struct ieee80211_device
*ieee
= container_of(dwork
,struct ieee80211_device
,hw_wakeup_wq
);
2018 struct net_device
*dev
= ieee
->dev
;
2019 rtl8192_hw_wakeup(dev
);
2023 #define MIN_SLEEP_TIME 50
2024 #define MAX_SLEEP_TIME 10000
2025 static void rtl8192_hw_to_sleep(struct net_device
*dev
, u32 th
, u32 tl
)
2027 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2030 unsigned long flags
;
2032 spin_lock_irqsave(&priv
->ps_lock
,flags
);
2034 // Writing HW register with 0 equals to disable
2035 // the timer, that is not really what we want
2037 tl
-= MSECS(8+16+7);
2039 // If the interval in witch we are requested to sleep is too
2040 // short then give up and remain awake
2041 // when we sleep after send null frame, the timer will be too short to sleep.
2043 if(((tl
>=rb
)&& (tl
-rb
) <= MSECS(MIN_SLEEP_TIME
))
2044 ||((rb
>tl
)&& (rb
-tl
) < MSECS(MIN_SLEEP_TIME
))) {
2045 spin_unlock_irqrestore(&priv
->ps_lock
,flags
);
2046 printk("too short to sleep::%x, %x, %lx\n",tl
, rb
, MSECS(MIN_SLEEP_TIME
));
2050 if(((tl
> rb
) && ((tl
-rb
) > MSECS(MAX_SLEEP_TIME
)))||
2051 ((tl
< rb
) && (tl
>MSECS(69)) && ((rb
-tl
) > MSECS(MAX_SLEEP_TIME
)))||
2052 ((tl
<rb
)&&(tl
<MSECS(69))&&((tl
+0xffffffff-rb
)>MSECS(MAX_SLEEP_TIME
)))) {
2053 printk("========>too long to sleep:%x, %x, %lx\n", tl
, rb
, MSECS(MAX_SLEEP_TIME
));
2054 spin_unlock_irqrestore(&priv
->ps_lock
,flags
);
2058 u32 tmp
= (tl
>rb
)?(tl
-rb
):(rb
-tl
);
2059 queue_delayed_work(priv
->ieee80211
->wq
,
2060 &priv
->ieee80211
->hw_wakeup_wq
,tmp
);
2061 //PowerSave not supported when kernel version less 2.6.20
2063 queue_delayed_work(priv
->ieee80211
->wq
,
2064 (void *)&priv
->ieee80211
->hw_sleep_wq
,0);
2065 spin_unlock_irqrestore(&priv
->ps_lock
,flags
);
2069 static void rtl8192_init_priv_variable(struct net_device
* dev
)
2071 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2073 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
2075 // Default Halt the NIC if RF is OFF.
2076 pPSC
->RegRfPsLevel
|= RT_RF_OFF_LEVL_HALT_NIC
;
2077 pPSC
->RegRfPsLevel
|= RT_RF_OFF_LEVL_CLK_REQ
;
2078 pPSC
->RegRfPsLevel
|= RT_RF_OFF_LEVL_ASPM
;
2079 pPSC
->RegRfPsLevel
|= RT_RF_LPS_LEVEL_ASPM
;
2080 pPSC
->bLeisurePs
= true;
2081 pPSC
->RegMaxLPSAwakeIntvl
= 5;
2082 priv
->bHwRadioOff
= false;
2084 priv
->being_init_adapter
= false;
2085 priv
->txringcount
= 64;//32;
2086 priv
->rxbuffersize
= 9100;//2048;//1024;
2087 priv
->rxringcount
= MAX_RX_COUNT
;//64;
2088 priv
->irq_enabled
=0;
2089 priv
->rx_skb_complete
= 1;
2090 priv
->chan
= 1; //set to channel 1
2091 priv
->RegWirelessMode
= WIRELESS_MODE_AUTO
;
2092 priv
->RegChannelPlan
= 0xf;
2093 priv
->ieee80211
->mode
= WIRELESS_MODE_AUTO
; //SET AUTO
2094 priv
->ieee80211
->iw_mode
= IW_MODE_INFRA
;
2095 priv
->ieee80211
->ieee_up
=0;
2096 priv
->retry_rts
= DEFAULT_RETRY_RTS
;
2097 priv
->retry_data
= DEFAULT_RETRY_DATA
;
2098 priv
->ieee80211
->rts
= DEFAULT_RTS_THRESHOLD
;
2099 priv
->ieee80211
->rate
= 110; //11 mbps
2100 priv
->ieee80211
->short_slot
= 1;
2101 priv
->promisc
= (dev
->flags
& IFF_PROMISC
) ? 1:0;
2102 priv
->bcck_in_ch14
= false;
2103 priv
->CCKPresentAttentuation
= 0;
2104 priv
->rfa_txpowertrackingindex
= 0;
2105 priv
->rfc_txpowertrackingindex
= 0;
2107 //added by amy for silent reset
2108 priv
->ResetProgress
= RESET_TYPE_NORESET
;
2109 priv
->bForcedSilentReset
= 0;
2110 priv
->bDisableNormalResetCheck
= false;
2111 priv
->force_reset
= false;
2112 //added by amy for power save
2113 priv
->ieee80211
->RfOffReason
= 0;
2114 priv
->RFChangeInProgress
= false;
2115 priv
->bHwRfOffAction
= 0;
2116 priv
->SetRFPowerStateInProgress
= false;
2117 priv
->ieee80211
->PowerSaveControl
.bInactivePs
= true;
2118 priv
->ieee80211
->PowerSaveControl
.bIPSModeBackup
= false;
2120 priv
->ieee80211
->current_network
.beacon_interval
= DEFAULT_BEACONINTERVAL
;
2121 priv
->ieee80211
->iw_mode
= IW_MODE_INFRA
;
2122 priv
->ieee80211
->softmac_features
= IEEE_SOFTMAC_SCAN
|
2123 IEEE_SOFTMAC_ASSOCIATE
| IEEE_SOFTMAC_PROBERQ
|
2124 IEEE_SOFTMAC_PROBERS
| IEEE_SOFTMAC_TX_QUEUE
;/* |
2125 IEEE_SOFTMAC_BEACONS;*///added by amy
080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2127 priv
->ieee80211
->active_scan
= 1;
2128 priv
->ieee80211
->modulation
= IEEE80211_CCK_MODULATION
| IEEE80211_OFDM_MODULATION
;
2129 priv
->ieee80211
->host_encrypt
= 1;
2130 priv
->ieee80211
->host_decrypt
= 1;
2131 //priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2132 //priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2133 priv
->ieee80211
->start_send_beacons
= rtl8192_start_beacon
;//+by david 081107
2134 priv
->ieee80211
->stop_send_beacons
= rtl8192_stop_beacon
;//+by david 081107
2135 priv
->ieee80211
->softmac_hard_start_xmit
= rtl8192_hard_start_xmit
;
2136 priv
->ieee80211
->set_chan
= rtl8192_set_chan
;
2137 priv
->ieee80211
->link_change
= rtl8192_link_change
;
2138 priv
->ieee80211
->softmac_data_hard_start_xmit
= rtl8192_hard_data_xmit
;
2139 priv
->ieee80211
->data_hard_stop
= rtl8192_data_hard_stop
;
2140 priv
->ieee80211
->data_hard_resume
= rtl8192_data_hard_resume
;
2141 priv
->ieee80211
->init_wmmparam_flag
= 0;
2142 priv
->ieee80211
->fts
= DEFAULT_FRAG_THRESHOLD
;
2143 priv
->ieee80211
->check_nic_enough_desc
= check_nic_enough_desc
;
2144 priv
->ieee80211
->tx_headroom
= sizeof(TX_FWINFO_8190PCI
);
2145 priv
->ieee80211
->qos_support
= 1;
2146 priv
->ieee80211
->dot11PowerSaveMode
= 0;
2148 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2149 priv
->ieee80211
->SetBWModeHandler
= rtl8192_SetBWMode
;
2150 priv
->ieee80211
->handle_assoc_response
= rtl8192_handle_assoc_response
;
2151 priv
->ieee80211
->handle_beacon
= rtl8192_handle_beacon
;
2153 priv
->ieee80211
->sta_wake_up
= rtl8192_hw_wakeup
;
2154 // priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
2155 priv
->ieee80211
->enter_sleep_state
= rtl8192_hw_to_sleep
;
2156 priv
->ieee80211
->ps_is_queue_empty
= rtl8192_is_tx_queue_empty
;
2158 priv
->ieee80211
->GetNmodeSupportBySecCfg
= GetNmodeSupportBySecCfg8190Pci
;
2159 priv
->ieee80211
->SetWirelessMode
= rtl8192_SetWirelessMode
;
2160 priv
->ieee80211
->GetHalfNmodeSupportByAPsHandler
= GetHalfNmodeSupportByAPs819xPci
;
2163 priv
->ieee80211
->InitialGainHandler
= InitialGain819xPci
;
2166 priv
->ieee80211
->ieee80211_ips_leave_wq
= ieee80211_ips_leave_wq
;
2167 priv
->ieee80211
->ieee80211_ips_leave
= ieee80211_ips_leave
;
2170 priv
->ieee80211
->LeisurePSLeave
= LeisurePSLeave
;
2173 priv
->ieee80211
->SetHwRegHandler
= rtl8192e_SetHwReg
;
2174 priv
->ieee80211
->rtllib_ap_sec_type
= rtl8192e_ap_sec_type
;
2176 priv
->ShortRetryLimit
= 0x30;
2177 priv
->LongRetryLimit
= 0x30;
2179 priv
->ReceiveConfig
= RCR_ADD3
|
2180 RCR_AMF
| RCR_ADF
| //accept management/data
2181 RCR_AICV
| //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2182 RCR_AB
| RCR_AM
| RCR_APM
| //accept BC/MC/UC
2183 RCR_AAP
| ((u32
)7<<RCR_MXDMA_OFFSET
) |
2184 ((u32
)7 << RCR_FIFO_OFFSET
) | RCR_ONLYERLPKT
;
2186 priv
->irq_mask
= (u32
)(IMR_ROK
| IMR_VODOK
| IMR_VIDOK
| IMR_BEDOK
| IMR_BKDOK
|
2187 IMR_HCCADOK
| IMR_MGNTDOK
| IMR_COMDOK
| IMR_HIGHDOK
|
2188 IMR_BDOK
| IMR_RXCMDOK
| IMR_TIMEOUT0
| IMR_RDU
| IMR_RXFOVW
|
2189 IMR_TXFOVW
| IMR_BcnInt
| IMR_TBDOK
| IMR_TBDER
);
2191 priv
->pFirmware
= vzalloc(sizeof(rt_firmware
));
2193 /* rx related queue */
2194 skb_queue_head_init(&priv
->skb_queue
);
2196 /* Tx related queue */
2197 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
2198 skb_queue_head_init(&priv
->ieee80211
->skb_waitQ
[i
]);
2200 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
2201 skb_queue_head_init(&priv
->ieee80211
->skb_aggQ
[i
]);
2203 priv
->rf_set_chan
= rtl8192_phy_SwChnl
;
2206 static void rtl8192_init_priv_lock(struct r8192_priv
* priv
)
2208 spin_lock_init(&priv
->tx_lock
);
2209 spin_lock_init(&priv
->irq_th_lock
);
2210 spin_lock_init(&priv
->rf_ps_lock
);
2211 spin_lock_init(&priv
->ps_lock
);
2212 sema_init(&priv
->wx_sem
,1);
2213 sema_init(&priv
->rf_sem
,1);
2214 mutex_init(&priv
->mutex
);
2217 /* init tasklet and wait_queue here */
2218 #define DRV_NAME "wlan0"
2219 static void rtl8192_init_priv_task(struct net_device
* dev
)
2221 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2223 priv
->priv_wq
= create_workqueue(DRV_NAME
);
2226 INIT_WORK(&priv
->ieee80211
->ips_leave_wq
, (void*)IPSLeave_wq
);
2229 // INIT_WORK(&priv->reset_wq, (void(*)(void*)) rtl8192_restart);
2230 INIT_WORK(&priv
->reset_wq
, rtl8192_restart
);
2231 // INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2232 INIT_DELAYED_WORK(&priv
->watch_dog_wq
, rtl819x_watchdog_wqcallback
);
2233 INIT_DELAYED_WORK(&priv
->txpower_tracking_wq
, dm_txpower_trackingcallback
);
2234 INIT_DELAYED_WORK(&priv
->rfpath_check_wq
, dm_rf_pathcheck_workitemcallback
);
2235 INIT_DELAYED_WORK(&priv
->update_beacon_wq
, rtl8192_update_beacon
);
2236 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2237 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2238 INIT_WORK(&priv
->qos_activate
, rtl8192_qos_activate
);
2239 INIT_DELAYED_WORK(&priv
->ieee80211
->hw_wakeup_wq
,(void*) rtl8192_hw_wakeup_wq
);
2240 INIT_DELAYED_WORK(&priv
->ieee80211
->hw_sleep_wq
,(void*) rtl8192_hw_sleep_wq
);
2242 tasklet_init(&priv
->irq_rx_tasklet
,
2243 (void(*)(unsigned long))rtl8192_irq_rx_tasklet
,
2244 (unsigned long)priv
);
2245 tasklet_init(&priv
->irq_tx_tasklet
,
2246 (void(*)(unsigned long))rtl8192_irq_tx_tasklet
,
2247 (unsigned long)priv
);
2248 tasklet_init(&priv
->irq_prepare_beacon_tasklet
,
2249 (void(*)(unsigned long))rtl8192_prepare_beacon
,
2250 (unsigned long)priv
);
2253 static void rtl8192_get_eeprom_size(struct net_device
* dev
)
2256 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2257 RT_TRACE(COMP_INIT
, "===========>%s()\n", __FUNCTION__
);
2258 curCR
= read_nic_dword(dev
, EPROM_CMD
);
2259 RT_TRACE(COMP_INIT
, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD
, curCR
);
2260 //whether need I consider BIT5?
2261 priv
->epromtype
= (curCR
& EPROM_CMD_9356SEL
) ? EPROM_93c56
: EPROM_93c46
;
2262 RT_TRACE(COMP_INIT
, "<===========%s(), epromtype:%d\n", __FUNCTION__
, priv
->epromtype
);
2266 * Adapter->EEPROMAddressSize should be set before this function call.
2267 * EEPROM address size can be got through GetEEPROMSize8185()
2269 static void rtl8192_read_eeprom_info(struct net_device
* dev
)
2271 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2275 u8 ICVer8192
, ICVer8256
;
2277 u16 i
,usValue
, IC_Version
;
2281 u8 EepromTxPower
[100];
2283 u8 bMac_Tmp_Addr
[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01};
2284 RT_TRACE(COMP_INIT
, "====> rtl8192_read_eeprom_info\n");
2287 // TODO: I don't know if we need to apply EF function to EEPROM read function
2289 //2 Read EEPROM ID to make sure autoload is success
2290 EEPROMId
= eprom_read(dev
, 0);
2291 if( EEPROMId
!= RTL8190_EEPROM_ID
)
2293 RT_TRACE(COMP_ERR
, "EEPROM ID is invalid:%x, %x\n", EEPROMId
, RTL8190_EEPROM_ID
);
2294 priv
->AutoloadFailFlag
=true;
2298 priv
->AutoloadFailFlag
=false;
2302 // Assign Chip Version ID
2304 // Read IC Version && Channel Plan
2305 if(!priv
->AutoloadFailFlag
)
2308 priv
->eeprom_vid
= eprom_read(dev
, (EEPROM_VID
>> 1));
2309 priv
->eeprom_did
= eprom_read(dev
, (EEPROM_DID
>> 1));
2311 usValue
= eprom_read(dev
, (u16
)(EEPROM_Customer_ID
>>1)) >> 8 ;
2312 priv
->eeprom_CustomerID
= (u8
)( usValue
& 0xff);
2313 usValue
= eprom_read(dev
, (EEPROM_ICVersion_ChannelPlan
>>1));
2314 priv
->eeprom_ChannelPlan
= usValue
&0xff;
2315 IC_Version
= ((usValue
&0xff00)>>8);
2318 priv
->card_8192_version
= (VERSION_8190
)(IC_Version
);
2321 ICVer8192
= (IC_Version
&0xf); //bit0~3; 1:A cut, 2:B cut, 3:C cut...
2322 ICVer8256
= ((IC_Version
&0xf0)>>4);//bit4~6, bit7 reserved for other RF chip; 1:A cut, 2:B cut, 3:C cut...
2323 RT_TRACE(COMP_INIT
, "\nICVer8192 = 0x%x\n", ICVer8192
);
2324 RT_TRACE(COMP_INIT
, "\nICVer8256 = 0x%x\n", ICVer8256
);
2325 if(ICVer8192
== 0x2) //B-cut
2327 if(ICVer8256
== 0x5) //E-cut
2328 priv
->card_8192_version
= VERSION_8190_BE
;
2332 switch(priv
->card_8192_version
)
2334 case VERSION_8190_BD
:
2335 case VERSION_8190_BE
:
2338 priv
->card_8192_version
= VERSION_8190_BD
;
2341 RT_TRACE(COMP_INIT
, "\nIC Version = 0x%x\n", priv
->card_8192_version
);
2345 priv
->card_8192_version
= VERSION_8190_BD
;
2346 priv
->eeprom_vid
= 0;
2347 priv
->eeprom_did
= 0;
2348 priv
->eeprom_CustomerID
= 0;
2349 priv
->eeprom_ChannelPlan
= 0;
2350 RT_TRACE(COMP_INIT
, "\nIC Version = 0x%x\n", 0xff);
2353 RT_TRACE(COMP_INIT
, "EEPROM VID = 0x%4x\n", priv
->eeprom_vid
);
2354 RT_TRACE(COMP_INIT
, "EEPROM DID = 0x%4x\n", priv
->eeprom_did
);
2355 RT_TRACE(COMP_INIT
,"EEPROM Customer ID: 0x%2x\n", priv
->eeprom_CustomerID
);
2357 //2 Read Permanent MAC address
2358 if(!priv
->AutoloadFailFlag
)
2360 for(i
= 0; i
< 6; i
+= 2)
2362 usValue
= eprom_read(dev
, (u16
) ((EEPROM_NODE_ADDRESS_BYTE_0
+i
)>>1));
2363 *(u16
*)(&dev
->dev_addr
[i
]) = usValue
;
2366 // when auto load failed, the last address byte set to be a random one.
2367 // added by david woo.2007/11/7
2368 memcpy(dev
->dev_addr
, bMac_Tmp_Addr
, 6);
2371 RT_TRACE(COMP_INIT
, "Permanent Address = %pM\n", dev
->dev_addr
);
2373 //2 TX Power Check EEPROM Fail or not
2374 if(priv
->card_8192_version
> VERSION_8190_BD
) {
2375 priv
->bTXPowerDataReadFromEEPORM
= true;
2377 priv
->bTXPowerDataReadFromEEPORM
= false;
2380 // 2007/11/15 MH 8190PCI Default=2T4R, 8192PCIE default=1T2R
2381 priv
->rf_type
= RTL819X_DEFAULT_RF_TYPE
;
2383 if(priv
->card_8192_version
> VERSION_8190_BD
)
2385 // Read RF-indication and Tx Power gain index diff of legacy to HT OFDM rate.
2386 if(!priv
->AutoloadFailFlag
)
2388 tempval
= (eprom_read(dev
, (EEPROM_RFInd_PowerDiff
>>1))) & 0xff;
2389 priv
->EEPROMLegacyHTTxPowerDiff
= tempval
& 0xf; // bit[3:0]
2391 if (tempval
&0x80) //RF-indication, bit[7]
2392 priv
->rf_type
= RF_1T2R
;
2394 priv
->rf_type
= RF_2T4R
;
2398 priv
->EEPROMLegacyHTTxPowerDiff
= EEPROM_Default_LegacyHTTxPowerDiff
;
2400 RT_TRACE(COMP_INIT
, "EEPROMLegacyHTTxPowerDiff = %d\n",
2401 priv
->EEPROMLegacyHTTxPowerDiff
);
2403 // Read ThermalMeter from EEPROM
2404 if(!priv
->AutoloadFailFlag
)
2406 priv
->EEPROMThermalMeter
= (u8
)(((eprom_read(dev
, (EEPROM_ThermalMeter
>>1))) & 0xff00)>>8);
2410 priv
->EEPROMThermalMeter
= EEPROM_Default_ThermalMeter
;
2412 RT_TRACE(COMP_INIT
, "ThermalMeter = %d\n", priv
->EEPROMThermalMeter
);
2413 //vivi, for tx power track
2414 priv
->TSSI_13dBm
= priv
->EEPROMThermalMeter
*100;
2416 if(priv
->epromtype
== EPROM_93c46
)
2418 // Read antenna tx power offset of B/C/D to A and CrystalCap from EEPROM
2419 if(!priv
->AutoloadFailFlag
)
2421 usValue
= eprom_read(dev
, (EEPROM_TxPwDiff_CrystalCap
>>1));
2422 priv
->EEPROMAntPwDiff
= (usValue
&0x0fff);
2423 priv
->EEPROMCrystalCap
= (u8
)((usValue
&0xf000)>>12);
2427 priv
->EEPROMAntPwDiff
= EEPROM_Default_AntTxPowerDiff
;
2428 priv
->EEPROMCrystalCap
= EEPROM_Default_TxPwDiff_CrystalCap
;
2430 RT_TRACE(COMP_INIT
, "EEPROMAntPwDiff = %d\n", priv
->EEPROMAntPwDiff
);
2431 RT_TRACE(COMP_INIT
, "EEPROMCrystalCap = %d\n", priv
->EEPROMCrystalCap
);
2434 // Get per-channel Tx Power Level
2436 for(i
=0; i
<14; i
+=2)
2438 if(!priv
->AutoloadFailFlag
)
2440 usValue
= eprom_read(dev
, (u16
) ((EEPROM_TxPwIndex_CCK
+i
)>>1) );
2444 usValue
= EEPROM_Default_TxPower
;
2446 *((u16
*)(&priv
->EEPROMTxPowerLevelCCK
[i
])) = usValue
;
2447 RT_TRACE(COMP_INIT
,"CCK Tx Power Level, Index %d = 0x%02x\n", i
, priv
->EEPROMTxPowerLevelCCK
[i
]);
2448 RT_TRACE(COMP_INIT
, "CCK Tx Power Level, Index %d = 0x%02x\n", i
+1, priv
->EEPROMTxPowerLevelCCK
[i
+1]);
2450 for(i
=0; i
<14; i
+=2)
2452 if(!priv
->AutoloadFailFlag
)
2454 usValue
= eprom_read(dev
, (u16
) ((EEPROM_TxPwIndex_OFDM_24G
+i
)>>1) );
2458 usValue
= EEPROM_Default_TxPower
;
2460 *((u16
*)(&priv
->EEPROMTxPowerLevelOFDM24G
[i
])) = usValue
;
2461 RT_TRACE(COMP_INIT
, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i
, priv
->EEPROMTxPowerLevelOFDM24G
[i
]);
2462 RT_TRACE(COMP_INIT
, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i
+1, priv
->EEPROMTxPowerLevelOFDM24G
[i
+1]);
2465 else if(priv
->epromtype
== EPROM_93c56
)
2468 // Read CrystalCap from EEPROM
2469 if(!priv
->AutoloadFailFlag
)
2471 priv
->EEPROMAntPwDiff
= EEPROM_Default_AntTxPowerDiff
;
2472 priv
->EEPROMCrystalCap
= (u8
)(((eprom_read(dev
, (EEPROM_C56_CrystalCap
>>1))) & 0xf000)>>12);
2476 priv
->EEPROMAntPwDiff
= EEPROM_Default_AntTxPowerDiff
;
2477 priv
->EEPROMCrystalCap
= EEPROM_Default_TxPwDiff_CrystalCap
;
2479 RT_TRACE(COMP_INIT
,"EEPROMAntPwDiff = %d\n", priv
->EEPROMAntPwDiff
);
2480 RT_TRACE(COMP_INIT
, "EEPROMCrystalCap = %d\n", priv
->EEPROMCrystalCap
);
2482 // Get Tx Power Level by Channel
2483 if(!priv
->AutoloadFailFlag
)
2485 // Read Tx power of Channel 1 ~ 14 from EEPROM.
2486 for(i
= 0; i
< 12; i
+=2)
2489 offset
= EEPROM_C56_RfA_CCK_Chnl1_TxPwIndex
+ i
;
2491 offset
= EEPROM_C56_RfC_CCK_Chnl1_TxPwIndex
+ i
- 6;
2492 usValue
= eprom_read(dev
, (offset
>>1));
2493 *((u16
*)(&EepromTxPower
[i
])) = usValue
;
2496 for(i
= 0; i
< 12; i
++)
2499 priv
->EEPROMRfACCKChnl1TxPwLevel
[i
] = EepromTxPower
[i
];
2500 else if ((i
>=3 )&&(i
<= 5))
2501 priv
->EEPROMRfAOfdmChnlTxPwLevel
[i
-3] = EepromTxPower
[i
];
2502 else if ((i
>=6 )&&(i
<= 8))
2503 priv
->EEPROMRfCCCKChnl1TxPwLevel
[i
-6] = EepromTxPower
[i
];
2505 priv
->EEPROMRfCOfdmChnlTxPwLevel
[i
-9] = EepromTxPower
[i
];
2510 priv
->EEPROMRfACCKChnl1TxPwLevel
[0] = EEPROM_Default_TxPowerLevel
;
2511 priv
->EEPROMRfACCKChnl1TxPwLevel
[1] = EEPROM_Default_TxPowerLevel
;
2512 priv
->EEPROMRfACCKChnl1TxPwLevel
[2] = EEPROM_Default_TxPowerLevel
;
2514 priv
->EEPROMRfAOfdmChnlTxPwLevel
[0] = EEPROM_Default_TxPowerLevel
;
2515 priv
->EEPROMRfAOfdmChnlTxPwLevel
[1] = EEPROM_Default_TxPowerLevel
;
2516 priv
->EEPROMRfAOfdmChnlTxPwLevel
[2] = EEPROM_Default_TxPowerLevel
;
2518 priv
->EEPROMRfCCCKChnl1TxPwLevel
[0] = EEPROM_Default_TxPowerLevel
;
2519 priv
->EEPROMRfCCCKChnl1TxPwLevel
[1] = EEPROM_Default_TxPowerLevel
;
2520 priv
->EEPROMRfCCCKChnl1TxPwLevel
[2] = EEPROM_Default_TxPowerLevel
;
2522 priv
->EEPROMRfCOfdmChnlTxPwLevel
[0] = EEPROM_Default_TxPowerLevel
;
2523 priv
->EEPROMRfCOfdmChnlTxPwLevel
[1] = EEPROM_Default_TxPowerLevel
;
2524 priv
->EEPROMRfCOfdmChnlTxPwLevel
[2] = EEPROM_Default_TxPowerLevel
;
2526 RT_TRACE(COMP_INIT
, "priv->EEPROMRfACCKChnl1TxPwLevel[0] = 0x%x\n", priv
->EEPROMRfACCKChnl1TxPwLevel
[0]);
2527 RT_TRACE(COMP_INIT
, "priv->EEPROMRfACCKChnl1TxPwLevel[1] = 0x%x\n", priv
->EEPROMRfACCKChnl1TxPwLevel
[1]);
2528 RT_TRACE(COMP_INIT
, "priv->EEPROMRfACCKChnl1TxPwLevel[2] = 0x%x\n", priv
->EEPROMRfACCKChnl1TxPwLevel
[2]);
2529 RT_TRACE(COMP_INIT
, "priv->EEPROMRfAOfdmChnlTxPwLevel[0] = 0x%x\n", priv
->EEPROMRfAOfdmChnlTxPwLevel
[0]);
2530 RT_TRACE(COMP_INIT
, "priv->EEPROMRfAOfdmChnlTxPwLevel[1] = 0x%x\n", priv
->EEPROMRfAOfdmChnlTxPwLevel
[1]);
2531 RT_TRACE(COMP_INIT
, "priv->EEPROMRfAOfdmChnlTxPwLevel[2] = 0x%x\n", priv
->EEPROMRfAOfdmChnlTxPwLevel
[2]);
2532 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCCCKChnl1TxPwLevel[0] = 0x%x\n", priv
->EEPROMRfCCCKChnl1TxPwLevel
[0]);
2533 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCCCKChnl1TxPwLevel[1] = 0x%x\n", priv
->EEPROMRfCCCKChnl1TxPwLevel
[1]);
2534 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCCCKChnl1TxPwLevel[2] = 0x%x\n", priv
->EEPROMRfCCCKChnl1TxPwLevel
[2]);
2535 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCOfdmChnlTxPwLevel[0] = 0x%x\n", priv
->EEPROMRfCOfdmChnlTxPwLevel
[0]);
2536 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCOfdmChnlTxPwLevel[1] = 0x%x\n", priv
->EEPROMRfCOfdmChnlTxPwLevel
[1]);
2537 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCOfdmChnlTxPwLevel[2] = 0x%x\n", priv
->EEPROMRfCOfdmChnlTxPwLevel
[2]);
2542 // Update HAL variables.
2544 if(priv
->epromtype
== EPROM_93c46
)
2548 priv
->TxPowerLevelCCK
[i
] = priv
->EEPROMTxPowerLevelCCK
[i
];
2549 priv
->TxPowerLevelOFDM24G
[i
] = priv
->EEPROMTxPowerLevelOFDM24G
[i
];
2551 priv
->LegacyHTTxPowerDiff
= priv
->EEPROMLegacyHTTxPowerDiff
;
2552 // Antenna B gain offset to antenna A, bit0~3
2553 priv
->AntennaTxPwDiff
[0] = (priv
->EEPROMAntPwDiff
& 0xf);
2554 // Antenna C gain offset to antenna A, bit4~7
2555 priv
->AntennaTxPwDiff
[1] = ((priv
->EEPROMAntPwDiff
& 0xf0)>>4);
2556 // Antenna D gain offset to antenna A, bit8~11
2557 priv
->AntennaTxPwDiff
[2] = ((priv
->EEPROMAntPwDiff
& 0xf00)>>8);
2558 // CrystalCap, bit12~15
2559 priv
->CrystalCap
= priv
->EEPROMCrystalCap
;
2560 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2561 priv
->ThermalMeter
[0] = (priv
->EEPROMThermalMeter
& 0xf);
2562 priv
->ThermalMeter
[1] = ((priv
->EEPROMThermalMeter
& 0xf0)>>4);
2564 else if(priv
->epromtype
== EPROM_93c56
)
2566 //char cck_pwr_diff_a=0, cck_pwr_diff_c=0;
2568 //cck_pwr_diff_a = pHalData->EEPROMRfACCKChnl7TxPwLevel - pHalData->EEPROMRfAOfdmChnlTxPwLevel[1];
2569 //cck_pwr_diff_c = pHalData->EEPROMRfCCCKChnl7TxPwLevel - pHalData->EEPROMRfCOfdmChnlTxPwLevel[1];
2570 for(i
=0; i
<3; i
++) // channel 1~3 use the same Tx Power Level.
2572 priv
->TxPowerLevelCCK_A
[i
] = priv
->EEPROMRfACCKChnl1TxPwLevel
[0];
2573 priv
->TxPowerLevelOFDM24G_A
[i
] = priv
->EEPROMRfAOfdmChnlTxPwLevel
[0];
2574 priv
->TxPowerLevelCCK_C
[i
] = priv
->EEPROMRfCCCKChnl1TxPwLevel
[0];
2575 priv
->TxPowerLevelOFDM24G_C
[i
] = priv
->EEPROMRfCOfdmChnlTxPwLevel
[0];
2577 for(i
=3; i
<9; i
++) // channel 4~9 use the same Tx Power Level
2579 priv
->TxPowerLevelCCK_A
[i
] = priv
->EEPROMRfACCKChnl1TxPwLevel
[1];
2580 priv
->TxPowerLevelOFDM24G_A
[i
] = priv
->EEPROMRfAOfdmChnlTxPwLevel
[1];
2581 priv
->TxPowerLevelCCK_C
[i
] = priv
->EEPROMRfCCCKChnl1TxPwLevel
[1];
2582 priv
->TxPowerLevelOFDM24G_C
[i
] = priv
->EEPROMRfCOfdmChnlTxPwLevel
[1];
2584 for(i
=9; i
<14; i
++) // channel 10~14 use the same Tx Power Level
2586 priv
->TxPowerLevelCCK_A
[i
] = priv
->EEPROMRfACCKChnl1TxPwLevel
[2];
2587 priv
->TxPowerLevelOFDM24G_A
[i
] = priv
->EEPROMRfAOfdmChnlTxPwLevel
[2];
2588 priv
->TxPowerLevelCCK_C
[i
] = priv
->EEPROMRfCCCKChnl1TxPwLevel
[2];
2589 priv
->TxPowerLevelOFDM24G_C
[i
] = priv
->EEPROMRfCOfdmChnlTxPwLevel
[2];
2592 RT_TRACE(COMP_INIT
, "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", i
, priv
->TxPowerLevelCCK_A
[i
]);
2594 RT_TRACE(COMP_INIT
,"priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", i
, priv
->TxPowerLevelOFDM24G_A
[i
]);
2596 RT_TRACE(COMP_INIT
, "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", i
, priv
->TxPowerLevelCCK_C
[i
]);
2598 RT_TRACE(COMP_INIT
, "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", i
, priv
->TxPowerLevelOFDM24G_C
[i
]);
2599 priv
->LegacyHTTxPowerDiff
= priv
->EEPROMLegacyHTTxPowerDiff
;
2600 priv
->AntennaTxPwDiff
[0] = 0;
2601 priv
->AntennaTxPwDiff
[1] = 0;
2602 priv
->AntennaTxPwDiff
[2] = 0;
2603 priv
->CrystalCap
= priv
->EEPROMCrystalCap
;
2604 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2605 priv
->ThermalMeter
[0] = (priv
->EEPROMThermalMeter
& 0xf);
2606 priv
->ThermalMeter
[1] = ((priv
->EEPROMThermalMeter
& 0xf0)>>4);
2610 if(priv
->rf_type
== RF_1T2R
)
2612 RT_TRACE(COMP_INIT
, "\n1T2R config\n");
2614 else if (priv
->rf_type
== RF_2T4R
)
2616 RT_TRACE(COMP_INIT
, "\n2T4R config\n");
2619 // 2008/01/16 MH We can only know RF type in the function. So we have to init
2620 // DIG RATR table again.
2621 init_rate_adaptive(dev
);
2623 //1 Make a copy for following variables and we can change them if we want
2625 priv
->rf_chip
= RF_8256
;
2627 if(priv
->RegChannelPlan
== 0xf)
2629 priv
->ChannelPlan
= priv
->eeprom_ChannelPlan
;
2633 priv
->ChannelPlan
= priv
->RegChannelPlan
;
2637 // Used PID and DID to Set CustomerID
2639 if( priv
->eeprom_vid
== 0x1186 && priv
->eeprom_did
== 0x3304 )
2641 priv
->CustomerID
= RT_CID_DLINK
;
2644 switch(priv
->eeprom_CustomerID
)
2646 case EEPROM_CID_DEFAULT
:
2647 priv
->CustomerID
= RT_CID_DEFAULT
;
2649 case EEPROM_CID_CAMEO
:
2650 priv
->CustomerID
= RT_CID_819x_CAMEO
;
2652 case EEPROM_CID_RUNTOP
:
2653 priv
->CustomerID
= RT_CID_819x_RUNTOP
;
2655 case EEPROM_CID_NetCore
:
2656 priv
->CustomerID
= RT_CID_819x_Netcore
;
2658 case EEPROM_CID_TOSHIBA
: // Merge by Jacken, 2008/01/31
2659 priv
->CustomerID
= RT_CID_TOSHIBA
;
2660 if(priv
->eeprom_ChannelPlan
&0x80)
2661 priv
->ChannelPlan
= priv
->eeprom_ChannelPlan
&0x7f;
2663 priv
->ChannelPlan
= 0x0;
2664 RT_TRACE(COMP_INIT
, "Toshiba ChannelPlan = 0x%x\n",
2667 case EEPROM_CID_Nettronix
:
2668 priv
->CustomerID
= RT_CID_Nettronix
;
2670 case EEPROM_CID_Pronet
:
2671 priv
->CustomerID
= RT_CID_PRONET
;
2673 case EEPROM_CID_DLINK
:
2674 priv
->CustomerID
= RT_CID_DLINK
;
2677 case EEPROM_CID_WHQL
:
2678 //Adapter->bInHctTest = TRUE;//do not supported
2680 //priv->bSupportTurboMode = FALSE;
2681 //priv->bAutoTurboBy8186 = FALSE;
2683 //pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
2684 //pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
2685 //pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
2689 // value from RegCustomerID
2693 //Avoid the channel plan array overflow, by Bruce, 2007-08-27.
2694 if(priv
->ChannelPlan
> CHANNEL_PLAN_LEN
- 1)
2695 priv
->ChannelPlan
= 0; //FCC
2697 switch(priv
->CustomerID
)
2699 case RT_CID_DEFAULT
:
2701 priv
->LedStrategy
= HW_LED
;
2704 priv
->LedStrategy
= SW_LED_MODE1
;
2709 case RT_CID_819x_CAMEO
:
2710 priv
->LedStrategy
= SW_LED_MODE2
;
2713 case RT_CID_819x_RUNTOP
:
2714 priv
->LedStrategy
= SW_LED_MODE3
;
2717 case RT_CID_819x_Netcore
:
2718 priv
->LedStrategy
= SW_LED_MODE4
;
2721 case RT_CID_Nettronix
:
2722 priv
->LedStrategy
= SW_LED_MODE5
;
2726 priv
->LedStrategy
= SW_LED_MODE6
;
2729 case RT_CID_TOSHIBA
: //Modify by Jacken 2008/01/31
2735 priv
->LedStrategy
= HW_LED
;
2738 priv
->LedStrategy
= SW_LED_MODE1
;
2745 if( priv
->eeprom_vid
== 0x1186 && priv
->eeprom_did
== 0x3304)
2746 priv
->ieee80211
->bSupportRemoteWakeUp
= true;
2748 priv
->ieee80211
->bSupportRemoteWakeUp
= false;
2751 RT_TRACE(COMP_INIT
, "RegChannelPlan(%d)\n", priv
->RegChannelPlan
);
2752 RT_TRACE(COMP_INIT
, "ChannelPlan = %d \n", priv
->ChannelPlan
);
2753 RT_TRACE(COMP_INIT
, "LedStrategy = %d \n", priv
->LedStrategy
);
2754 RT_TRACE(COMP_TRACE
, "<==== ReadAdapterInfo\n");
2760 static short rtl8192_get_channel_map(struct net_device
* dev
)
2762 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2763 #ifdef ENABLE_DOT11D
2764 if(priv
->ChannelPlan
> COUNTRY_CODE_GLOBAL_DOMAIN
){
2765 printk("rtl8180_init:Error channel plan! Set to default.\n");
2766 priv
->ChannelPlan
= 0;
2768 RT_TRACE(COMP_INIT
, "Channel plan is %d\n",priv
->ChannelPlan
);
2770 rtl819x_set_channel_map(priv
->ChannelPlan
, priv
);
2773 //Set Default Channel Plan
2775 DMESG("No channels, aborting");
2779 priv
->ChannelPlan
= 0;//hikaru
2780 // set channels 1..14 allowed in given locale
2781 for (i
=1; i
<=14; i
++) {
2782 (priv
->ieee80211
->channel_map
)[i
] = (u8
)(ch
& 0x01);
2789 static short rtl8192_init(struct net_device
*dev
)
2791 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2792 memset(&(priv
->stats
),0,sizeof(struct Stats
));
2793 rtl8192_init_priv_variable(dev
);
2794 rtl8192_init_priv_lock(priv
);
2795 rtl8192_init_priv_task(dev
);
2796 rtl8192_get_eeprom_size(dev
);
2797 rtl8192_read_eeprom_info(dev
);
2798 rtl8192_get_channel_map(dev
);
2800 init_timer(&priv
->watch_dog_timer
);
2801 priv
->watch_dog_timer
.data
= (unsigned long)dev
;
2802 priv
->watch_dog_timer
.function
= watch_dog_timer_callback
;
2803 if (request_irq(dev
->irq
, rtl8192_interrupt
, IRQF_SHARED
, dev
->name
, dev
)) {
2804 printk("Error allocating IRQ %d",dev
->irq
);
2808 printk("IRQ %d",dev
->irq
);
2810 if(rtl8192_pci_initdescring(dev
)!=0){
2811 printk("Endopoints initialization failed");
2815 //rtl8192_rx_enable(dev);
2816 //rtl8192_adapter_start(dev);
2821 * Actually only set RRSR, RATR and BW_OPMODE registers
2822 * not to do all the hw config as its name says
2823 * This part need to modified according to the rate set we filtered
2825 static void rtl8192_hwconfig(struct net_device
* dev
)
2827 u32 regRATR
= 0, regRRSR
= 0;
2828 u8 regBwOpMode
= 0, regTmp
= 0;
2829 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2831 // Set RRSR, RATR, and BW_OPMODE registers
2833 switch(priv
->ieee80211
->mode
)
2835 case WIRELESS_MODE_B
:
2836 regBwOpMode
= BW_OPMODE_20MHZ
;
2837 regRATR
= RATE_ALL_CCK
;
2838 regRRSR
= RATE_ALL_CCK
;
2840 case WIRELESS_MODE_A
:
2841 regBwOpMode
= BW_OPMODE_5G
|BW_OPMODE_20MHZ
;
2842 regRATR
= RATE_ALL_OFDM_AG
;
2843 regRRSR
= RATE_ALL_OFDM_AG
;
2845 case WIRELESS_MODE_G
:
2846 regBwOpMode
= BW_OPMODE_20MHZ
;
2847 regRATR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
2848 regRRSR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
2850 case WIRELESS_MODE_AUTO
:
2851 case WIRELESS_MODE_N_24G
:
2852 // It support CCK rate by default.
2853 // CCK rate will be filtered out only when associated AP does not support it.
2854 regBwOpMode
= BW_OPMODE_20MHZ
;
2855 regRATR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
| RATE_ALL_OFDM_1SS
| RATE_ALL_OFDM_2SS
;
2856 regRRSR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
2858 case WIRELESS_MODE_N_5G
:
2859 regBwOpMode
= BW_OPMODE_5G
;
2860 regRATR
= RATE_ALL_OFDM_AG
| RATE_ALL_OFDM_1SS
| RATE_ALL_OFDM_2SS
;
2861 regRRSR
= RATE_ALL_OFDM_AG
;
2865 write_nic_byte(dev
, BW_OPMODE
, regBwOpMode
);
2868 ratr_value
= regRATR
;
2869 if (priv
->rf_type
== RF_1T2R
)
2871 ratr_value
&= ~(RATE_ALL_OFDM_2SS
);
2873 write_nic_dword(dev
, RATR0
, ratr_value
);
2874 write_nic_byte(dev
, UFWP
, 1);
2876 regTmp
= read_nic_byte(dev
, 0x313);
2877 regRRSR
= ((regTmp
) << 24) | (regRRSR
& 0x00ffffff);
2878 write_nic_dword(dev
, RRSR
, regRRSR
);
2881 // Set Retry Limit here
2883 write_nic_word(dev
, RETRY_LIMIT
,
2884 priv
->ShortRetryLimit
<< RETRY_LIMIT_SHORT_SHIFT
|
2885 priv
->LongRetryLimit
<< RETRY_LIMIT_LONG_SHIFT
);
2886 // Set Contention Window here
2890 // Set Tx Antenna including Feedback control
2892 // Set Auto Rate fallback control
2898 static RT_STATUS
rtl8192_adapter_start(struct net_device
*dev
)
2900 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2901 // struct ieee80211_device *ieee = priv->ieee80211;
2903 RT_STATUS rtStatus
= RT_STATUS_SUCCESS
;
2907 u8 ICVersion
,SwitchingRegulatorOutput
;
2909 bool bfirmwareok
= true;
2913 u32 tmpRegA
, tmpRegC
, TempCCk
;
2916 RT_TRACE(COMP_INIT
, "====>%s()\n", __FUNCTION__
);
2917 priv
->being_init_adapter
= true;
2918 rtl8192_pci_resetdescring(dev
);
2919 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
2920 priv
->Rf_Mode
= RF_OP_By_SW_3wire
;
2923 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
2925 write_nic_byte(dev
, ANAPAR
, 0x37);
2926 // Accordign to designer's explain, LBUS active will never > 10ms. We delay 10ms
2927 // Joseph increae the time to prevent firmware download fail
2931 //PlatformSleepUs(10000);
2932 // For any kind of InitializeAdapter process, we shall use system now!!
2933 priv
->pFirmware
->firmware_status
= FW_STATUS_0_INIT
;
2936 //3 //Config CPUReset Register
2938 //3 Firmware Reset Or Not
2939 ulRegRead
= read_nic_dword(dev
, CPU_GEN
);
2940 if(priv
->pFirmware
->firmware_status
== FW_STATUS_0_INIT
)
2941 { //called from MPInitialized. do nothing
2942 ulRegRead
|= CPU_GEN_SYSTEM_RESET
;
2943 }else if(priv
->pFirmware
->firmware_status
== FW_STATUS_5_READY
)
2944 ulRegRead
|= CPU_GEN_FIRMWARE_RESET
; // Called from MPReset
2946 RT_TRACE(COMP_ERR
, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__
, priv
->pFirmware
->firmware_status
);
2949 //2008.06.03, for WOL 90 hw bug
2950 ulRegRead
&= (~(CPU_GEN_GPIO_UART
));
2953 write_nic_dword(dev
, CPU_GEN
, ulRegRead
);
2959 //3 //Fix the issue of E-cut high temperature issue
2962 ICVersion
= read_nic_byte(dev
, IC_VERRSION
);
2963 if(ICVersion
>= 0x4) //E-cut only
2965 // HW SD suggest that we should not wirte this register too often, so driver
2966 // should readback this register. This register will be modified only when
2968 SwitchingRegulatorOutput
= read_nic_byte(dev
, SWREGULATOR
);
2969 if(SwitchingRegulatorOutput
!= 0xb8)
2971 write_nic_byte(dev
, SWREGULATOR
, 0xa8);
2973 write_nic_byte(dev
, SWREGULATOR
, 0xb8);
2980 //3// Initialize BB before MAC
2982 RT_TRACE(COMP_INIT
, "BB Config Start!\n");
2983 rtStatus
= rtl8192_BBConfig(dev
);
2984 if(rtStatus
!= RT_STATUS_SUCCESS
)
2986 RT_TRACE(COMP_ERR
, "BB Config failed\n");
2989 RT_TRACE(COMP_INIT
,"BB Config Finished!\n");
2991 //3//Set Loopback mode or Normal mode
2993 //2006.12.13 by emily. Note!We should not merge these two CPU_GEN register writings
2994 // because setting of System_Reset bit reset MAC to default transmission mode.
2995 //Loopback mode or not
2996 priv
->LoopbackMode
= RTL819X_NO_LOOPBACK
;
2997 //priv->LoopbackMode = RTL819X_MAC_LOOPBACK;
2998 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3000 ulRegRead
= read_nic_dword(dev
, CPU_GEN
);
3001 if(priv
->LoopbackMode
== RTL819X_NO_LOOPBACK
)
3003 ulRegRead
= ((ulRegRead
& CPU_GEN_NO_LOOPBACK_MSK
) | CPU_GEN_NO_LOOPBACK_SET
);
3005 else if (priv
->LoopbackMode
== RTL819X_MAC_LOOPBACK
)
3007 ulRegRead
|= CPU_CCK_LOOPBACK
;
3011 RT_TRACE(COMP_ERR
,"Serious error: wrong loopback mode setting\n");
3014 //2008.06.03, for WOL
3015 //ulRegRead &= (~(CPU_GEN_GPIO_UART));
3016 write_nic_dword(dev
, CPU_GEN
, ulRegRead
);
3018 // 2006.11.29. After reset cpu, we sholud wait for a second, otherwise, it may fail to write registers. Emily
3021 //3Set Hardware(Do nothing now)
3022 rtl8192_hwconfig(dev
);
3023 //2=======================================================
3024 // Common Setting for all of the FPGA platform. (part 1)
3025 //2=======================================================
3026 // If there is changes, please make sure it applies to all of the FPGA version
3028 write_nic_byte(dev
, CMDR
, CR_RE
|CR_TE
);
3032 write_nic_byte(dev
, PCIF
, ((MXDMA2_NoLimit
<<MXDMA2_RX_SHIFT
) |
3033 (MXDMA2_NoLimit
<<MXDMA2_TX_SHIFT
) |
3037 write_nic_byte(dev
, PCIF
, ((MXDMA2_NoLimit
<<MXDMA2_RX_SHIFT
) |
3038 (MXDMA2_NoLimit
<<MXDMA2_TX_SHIFT
) ));
3042 write_nic_dword(dev
, MAC0
, ((u32
*)dev
->dev_addr
)[0]);
3043 write_nic_word(dev
, MAC4
, ((u16
*)(dev
->dev_addr
+ 4))[0]);
3045 write_nic_dword(dev
, RCR
, priv
->ReceiveConfig
);
3047 //3 Initialize Number of Reserved Pages in Firmware Queue
3049 if(priv
->bInHctTest
)
3051 PlatformEFIOWrite4Byte(Adapter
, RQPN1
, NUM_OF_PAGE_IN_FW_QUEUE_BK_DTM
<< RSVD_FW_QUEUE_PAGE_BK_SHIFT
|
3052 NUM_OF_PAGE_IN_FW_QUEUE_BE_DTM
<< RSVD_FW_QUEUE_PAGE_BE_SHIFT
|
3053 NUM_OF_PAGE_IN_FW_QUEUE_VI_DTM
<< RSVD_FW_QUEUE_PAGE_VI_SHIFT
|
3054 NUM_OF_PAGE_IN_FW_QUEUE_VO_DTM
<<RSVD_FW_QUEUE_PAGE_VO_SHIFT
);
3055 PlatformEFIOWrite4Byte(Adapter
, RQPN2
, NUM_OF_PAGE_IN_FW_QUEUE_MGNT
<< RSVD_FW_QUEUE_PAGE_MGNT_SHIFT
);
3056 PlatformEFIOWrite4Byte(Adapter
, RQPN3
, APPLIED_RESERVED_QUEUE_IN_FW
|
3057 NUM_OF_PAGE_IN_FW_QUEUE_BCN
<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
|
3058 NUM_OF_PAGE_IN_FW_QUEUE_PUB_DTM
<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
);
3063 write_nic_dword(dev
, RQPN1
, NUM_OF_PAGE_IN_FW_QUEUE_BK
<< RSVD_FW_QUEUE_PAGE_BK_SHIFT
|
3064 NUM_OF_PAGE_IN_FW_QUEUE_BE
<< RSVD_FW_QUEUE_PAGE_BE_SHIFT
|
3065 NUM_OF_PAGE_IN_FW_QUEUE_VI
<< RSVD_FW_QUEUE_PAGE_VI_SHIFT
|
3066 NUM_OF_PAGE_IN_FW_QUEUE_VO
<<RSVD_FW_QUEUE_PAGE_VO_SHIFT
);
3067 write_nic_dword(dev
, RQPN2
, NUM_OF_PAGE_IN_FW_QUEUE_MGNT
<< RSVD_FW_QUEUE_PAGE_MGNT_SHIFT
);
3068 write_nic_dword(dev
, RQPN3
, APPLIED_RESERVED_QUEUE_IN_FW
|
3069 NUM_OF_PAGE_IN_FW_QUEUE_BCN
<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
|
3070 NUM_OF_PAGE_IN_FW_QUEUE_PUB
<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
);
3073 rtl8192_tx_enable(dev
);
3074 rtl8192_rx_enable(dev
);
3075 //3Set Response Rate Setting Register
3076 // CCK rate is supported by default.
3077 // CCK rate will be filtered out only when associated AP does not support it.
3078 ulRegRead
= (0xFFF00000 & read_nic_dword(dev
, RRSR
)) | RATE_ALL_OFDM_AG
| RATE_ALL_CCK
;
3079 write_nic_dword(dev
, RRSR
, ulRegRead
);
3080 write_nic_dword(dev
, RATR0
+4*7, (RATE_ALL_OFDM_AG
| RATE_ALL_CCK
));
3083 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3084 write_nic_byte(dev
, ACK_TIMEOUT
, 0x30);
3086 //rtl8192_actset_wirelessmode(dev,priv->RegWirelessMode);
3087 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3088 rtl8192_SetWirelessMode(dev
, priv
->ieee80211
->mode
);
3089 //-----------------------------------------------------------------------------
3090 // Set up security related. 070106, by rcnjko:
3091 // 1. Clear all H/W keys.
3092 // 2. Enable H/W encryption/decryption.
3093 //-----------------------------------------------------------------------------
3094 CamResetAllEntry(dev
);
3096 u8 SECR_value
= 0x0;
3097 SECR_value
|= SCR_TxEncEnable
;
3098 SECR_value
|= SCR_RxDecEnable
;
3099 SECR_value
|= SCR_NoSKMC
;
3100 write_nic_byte(dev
, SECR
, SECR_value
);
3103 write_nic_word(dev
, ATIMWND
, 2);
3104 write_nic_word(dev
, BCN_INTERVAL
, 100);
3105 for (i
=0; i
<QOS_QUEUE_NUM
; i
++)
3106 write_nic_dword(dev
, WDCAPARA_ADD
[i
], 0x005e4332);
3108 // Switching regulator controller: This is set temporarily.
3109 // It's not sure if this can be removed in the future.
3110 // PJ advised to leave it by default.
3112 write_nic_byte(dev
, 0xbe, 0xc0);
3114 //2=======================================================
3115 // Set PHY related configuration defined in MAC register bank
3116 //2=======================================================
3117 rtl8192_phy_configmac(dev
);
3119 if (priv
->card_8192_version
> (u8
) VERSION_8190_BD
) {
3120 rtl8192_phy_getTxPower(dev
);
3121 rtl8192_phy_setTxPower(dev
, priv
->chan
);
3125 tmpvalue
= read_nic_byte(dev
, IC_VERRSION
);
3126 priv
->IC_Cut
= tmpvalue
;
3127 RT_TRACE(COMP_INIT
, "priv->IC_Cut = 0x%x\n", priv
->IC_Cut
);
3128 if(priv
->IC_Cut
>= IC_VersionCut_D
)
3130 //pHalData->bDcut = TRUE;
3131 if(priv
->IC_Cut
== IC_VersionCut_D
)
3132 RT_TRACE(COMP_INIT
, "D-cut\n");
3133 if(priv
->IC_Cut
== IC_VersionCut_E
)
3135 RT_TRACE(COMP_INIT
, "E-cut\n");
3136 // HW SD suggest that we should not wirte this register too often, so driver
3137 // should readback this register. This register will be modified only when
3143 //pHalData->bDcut = FALSE;
3144 RT_TRACE(COMP_INIT
, "Before C-cut\n");
3148 RT_TRACE(COMP_INIT
, "Load Firmware!\n");
3149 bfirmwareok
= init_firmware(dev
);
3150 if(bfirmwareok
!= true) {
3151 rtStatus
= RT_STATUS_FAILURE
;
3154 RT_TRACE(COMP_INIT
, "Load Firmware finished!\n");
3157 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3159 RT_TRACE(COMP_INIT
, "RF Config Started!\n");
3160 rtStatus
= rtl8192_phy_RFConfig(dev
);
3161 if(rtStatus
!= RT_STATUS_SUCCESS
)
3163 RT_TRACE(COMP_ERR
, "RF Config failed\n");
3166 RT_TRACE(COMP_INIT
, "RF Config Finished!\n");
3168 rtl8192_phy_updateInitGain(dev
);
3170 /*---- Set CCK and OFDM Block "ON"----*/
3171 rtl8192_setBBreg(dev
, rFPGA0_RFMOD
, bCCKEn
, 0x1);
3172 rtl8192_setBBreg(dev
, rFPGA0_RFMOD
, bOFDMEn
, 0x1);
3176 write_nic_byte(dev
, 0x87, 0x0);
3179 //2008.06.03, for WOL
3180 ucRegRead
= read_nic_byte(dev
, GPE
);
3182 write_nic_byte(dev
, GPE
, ucRegRead
);
3184 ucRegRead
= read_nic_byte(dev
, GPO
);
3186 write_nic_byte(dev
, GPO
, ucRegRead
);
3189 //2=======================================================
3191 //2=======================================================
3195 if(priv
->ieee80211
->RfOffReason
> RF_CHANGE_BY_PS
)
3196 { // H/W or S/W RF OFF before sleep.
3197 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__
,priv
->ieee80211
->RfOffReason
);
3198 MgntActSet_RF_State(dev
, eRfOff
, priv
->ieee80211
->RfOffReason
);
3200 else if(priv
->ieee80211
->RfOffReason
>= RF_CHANGE_BY_IPS
)
3201 { // H/W or S/W RF OFF before sleep.
3202 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__
,priv
->ieee80211
->RfOffReason
);
3203 MgntActSet_RF_State(dev
, eRfOff
, priv
->ieee80211
->RfOffReason
);
3207 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): RF-ON \n",__FUNCTION__
);
3208 priv
->ieee80211
->eRFPowerState
= eRfOn
;
3209 priv
->ieee80211
->RfOffReason
= 0;
3210 //DrvIFIndicateCurrentPhyStatus(Adapter);
3212 //Adapter->HalFunc.LedControlHandler(Adapter, LED_CTL_POWER_ON);
3215 // If inactive power mode is enabled, disable rf while in disconnected state.
3216 // But we should still tell upper layer we are in rf on state.
3217 // 2007.07.16, by shien chang.
3219 //if(!Adapter->bInHctTest)
3220 //IPSEnter(Adapter);
3227 // We can force firmware to do RF-R/W
3228 if(priv
->ieee80211
->FwRWRF
)
3229 priv
->Rf_Mode
= RF_OP_By_FW
;
3231 priv
->Rf_Mode
= RF_OP_By_SW_3wire
;
3233 priv
->Rf_Mode
= RF_OP_By_SW_3wire
;
3237 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3239 dm_initialize_txpower_tracking(dev
);
3241 tmpRegA
= rtl8192_QueryBBReg(dev
,rOFDM0_XATxIQImbalance
,bMaskDWord
);
3242 tmpRegC
= rtl8192_QueryBBReg(dev
,rOFDM0_XCTxIQImbalance
,bMaskDWord
);
3244 if(priv
->rf_type
== RF_2T4R
){
3245 for(i
= 0; i
<TxBBGainTableLength
; i
++)
3247 if(tmpRegA
== priv
->txbbgain_table
[i
].txbbgain_value
)
3249 priv
->rfa_txpowertrackingindex
= (u8
)i
;
3250 priv
->rfa_txpowertrackingindex_real
= (u8
)i
;
3251 priv
->rfa_txpowertracking_default
= priv
->rfa_txpowertrackingindex
;
3256 for(i
= 0; i
<TxBBGainTableLength
; i
++)
3258 if(tmpRegC
== priv
->txbbgain_table
[i
].txbbgain_value
)
3260 priv
->rfc_txpowertrackingindex
= (u8
)i
;
3261 priv
->rfc_txpowertrackingindex_real
= (u8
)i
;
3262 priv
->rfc_txpowertracking_default
= priv
->rfc_txpowertrackingindex
;
3266 TempCCk
= rtl8192_QueryBBReg(dev
, rCCK0_TxFilter1
, bMaskByte2
);
3268 for(i
=0 ; i
<CCKTxBBGainTableLength
; i
++)
3270 if(TempCCk
== priv
->cck_txbbgain_table
[i
].ccktxbb_valuearray
[0])
3272 priv
->CCKPresentAttentuation_20Mdefault
=(u8
) i
;
3276 priv
->CCKPresentAttentuation_40Mdefault
= 0;
3277 priv
->CCKPresentAttentuation_difference
= 0;
3278 priv
->CCKPresentAttentuation
= priv
->CCKPresentAttentuation_20Mdefault
;
3279 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_initial = %d\n", priv
->rfa_txpowertrackingindex
);
3280 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv
->rfa_txpowertrackingindex_real
);
3281 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfc_txpowertrackingindex_initial = %d\n", priv
->rfc_txpowertrackingindex
);
3282 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfc_txpowertrackingindex_real_initial = %d\n", priv
->rfc_txpowertrackingindex_real
);
3283 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv
->CCKPresentAttentuation_difference
);
3284 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_initial = %d\n", priv
->CCKPresentAttentuation
);
3288 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3290 dm_initialize_txpower_tracking(dev
);
3292 if(priv
->IC_Cut
>= IC_VersionCut_D
)
3294 tmpRegA
= rtl8192_QueryBBReg(dev
,rOFDM0_XATxIQImbalance
,bMaskDWord
);
3295 tmpRegC
= rtl8192_QueryBBReg(dev
,rOFDM0_XCTxIQImbalance
,bMaskDWord
);
3296 for(i
= 0; i
<TxBBGainTableLength
; i
++)
3298 if(tmpRegA
== priv
->txbbgain_table
[i
].txbbgain_value
)
3300 priv
->rfa_txpowertrackingindex
= (u8
)i
;
3301 priv
->rfa_txpowertrackingindex_real
= (u8
)i
;
3302 priv
->rfa_txpowertracking_default
= priv
->rfa_txpowertrackingindex
;
3307 TempCCk
= rtl8192_QueryBBReg(dev
, rCCK0_TxFilter1
, bMaskByte2
);
3309 for(i
=0 ; i
<CCKTxBBGainTableLength
; i
++)
3311 if(TempCCk
== priv
->cck_txbbgain_table
[i
].ccktxbb_valuearray
[0])
3313 priv
->CCKPresentAttentuation_20Mdefault
=(u8
) i
;
3317 priv
->CCKPresentAttentuation_40Mdefault
= 0;
3318 priv
->CCKPresentAttentuation_difference
= 0;
3319 priv
->CCKPresentAttentuation
= priv
->CCKPresentAttentuation_20Mdefault
;
3320 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_initial = %d\n", priv
->rfa_txpowertrackingindex
);
3321 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv
->rfa_txpowertrackingindex_real
);
3322 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv
->CCKPresentAttentuation_difference
);
3323 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_initial = %d\n", priv
->CCKPresentAttentuation
);
3324 priv
->btxpower_tracking
= FALSE
;//TEMPLY DISABLE
3329 rtl8192_irq_enable(dev
);
3330 priv
->being_init_adapter
= false;
3335 static void rtl8192_prepare_beacon(struct r8192_priv
*priv
)
3337 struct sk_buff
*skb
;
3338 //unsigned long flags;
3341 skb
= ieee80211_get_beacon(priv
->ieee80211
);
3342 tcb_desc
= (cb_desc
*)(skb
->cb
+ 8);
3343 //spin_lock_irqsave(&priv->tx_lock,flags);
3344 /* prepare misc info for the beacon xmit */
3345 tcb_desc
->queue_index
= BEACON_QUEUE
;
3346 /* IBSS does not support HT yet, use 1M defaultly */
3347 tcb_desc
->data_rate
= 2;
3348 tcb_desc
->RATRIndex
= 7;
3349 tcb_desc
->bTxDisableRateFallBack
= 1;
3350 tcb_desc
->bTxUseDriverAssingedRate
= 1;
3352 skb_push(skb
, priv
->ieee80211
->tx_headroom
);
3354 rtl8192_tx(priv
->ieee80211
->dev
,skb
);
3356 //spin_unlock_irqrestore (&priv->tx_lock, flags);
3361 * configure registers for beacon tx and enables it via
3362 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3363 * be used to stop beacon transmission
3365 static void rtl8192_start_beacon(struct net_device
*dev
)
3367 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
3368 struct ieee80211_network
*net
= &priv
->ieee80211
->current_network
;
3373 DMESG("Enabling beacon TX");
3374 //rtl8192_prepare_beacon(dev);
3375 rtl8192_irq_disable(dev
);
3376 //rtl8192_beacon_tx_enable(dev);
3379 write_nic_word(dev
, ATIMWND
, 2);
3381 /* Beacon interval (in unit of TU) */
3382 write_nic_word(dev
, BCN_INTERVAL
, net
->beacon_interval
);
3385 * DrvErlyInt (in unit of TU).
3386 * (Time to send interrupt to notify driver to c
3387 * hange beacon content)
3389 write_nic_word(dev
, BCN_DRV_EARLY_INT
, 10);
3392 * BcnDMATIM(in unit of us).
3393 * Indicates the time before TBTT to perform beacon queue DMA
3395 write_nic_word(dev
, BCN_DMATIME
, 256);
3398 * Force beacon frame transmission even after receiving
3399 * beacon frame from other ad hoc STA
3401 write_nic_byte(dev
, BCN_ERR_THRESH
, 100);
3403 /* Set CW and IFS */
3404 BcnTimeCfg
|= BcnCW
<<BCN_TCFG_CW_SHIFT
;
3405 BcnTimeCfg
|= BcnIFS
<<BCN_TCFG_IFS
;
3406 write_nic_word(dev
, BCN_TCFG
, BcnTimeCfg
);
3409 /* enable the interrupt for ad-hoc process */
3410 rtl8192_irq_enable(dev
);
3413 static bool HalTxCheckStuck8190Pci(struct net_device
*dev
)
3415 u16 RegTxCounter
= read_nic_word(dev
, 0x128);
3416 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3417 bool bStuck
= FALSE
;
3418 RT_TRACE(COMP_RESET
,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__
,RegTxCounter
,priv
->TxCounter
);
3419 if(priv
->TxCounter
==RegTxCounter
)
3422 priv
->TxCounter
= RegTxCounter
;
3428 * Assumption: RT_TX_SPINLOCK is acquired.
3431 TxCheckStuck(struct net_device
*dev
)
3433 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3434 u8 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
3435 bool bCheckFwTxCnt
= false;
3438 // Decide Stuch threshold according to current power save mode
3440 switch (priv
->ieee80211
->dot11PowerSaveMode
)
3442 // The threshold value may required to be adjusted .
3443 case eActive
: // Active/Continuous access.
3444 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_NORMAL
;
3446 case eMaxPs
: // Max power save mode.
3447 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
3449 case eFastPs
: // Fast power save mode.
3450 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
3456 if(HalTxCheckStuck8190Pci(dev
))
3458 RT_TRACE(COMP_RESET
, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3459 return RESET_TYPE_SILENT
;
3463 return RESET_TYPE_NORESET
;
3467 static bool HalRxCheckStuck8190Pci(struct net_device
*dev
)
3469 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3470 u16 RegRxCounter
= read_nic_word(dev
, 0x130);
3471 bool bStuck
= FALSE
;
3473 RT_TRACE(COMP_RESET
,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__
,RegRxCounter
,priv
->RxCounter
);
3474 // If rssi is small, we should check rx for long time because of bad rx.
3475 // or maybe it will continuous silent reset every 2 seconds.
3477 if(priv
->undecorated_smoothed_pwdb
>= (RateAdaptiveTH_High
+5))
3479 priv
->rx_chk_cnt
= 0; /* high rssi, check rx stuck right now. */
3481 else if(priv
->undecorated_smoothed_pwdb
< (RateAdaptiveTH_High
+5) &&
3482 ((priv
->CurrentChannelBW
!=HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
>=RateAdaptiveTH_Low_40M
) ||
3483 (priv
->CurrentChannelBW
==HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
>=RateAdaptiveTH_Low_20M
)) )
3486 if(priv
->rx_chk_cnt
< 2)
3492 priv
->rx_chk_cnt
= 0;
3495 else if(((priv
->CurrentChannelBW
!=HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
<RateAdaptiveTH_Low_40M
) ||
3496 (priv
->CurrentChannelBW
==HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
<RateAdaptiveTH_Low_20M
)) &&
3497 priv
->undecorated_smoothed_pwdb
>= VeryLowRSSI
)
3499 if(priv
->rx_chk_cnt
< 4)
3505 priv
->rx_chk_cnt
= 0;
3510 if(priv
->rx_chk_cnt
< 8)
3516 priv
->rx_chk_cnt
= 0;
3519 if(priv
->RxCounter
==RegRxCounter
)
3522 priv
->RxCounter
= RegRxCounter
;
3527 static RESET_TYPE
RxCheckStuck(struct net_device
*dev
)
3530 if(HalRxCheckStuck8190Pci(dev
))
3532 RT_TRACE(COMP_RESET
, "RxStuck Condition\n");
3533 return RESET_TYPE_SILENT
;
3536 return RESET_TYPE_NORESET
;
3540 rtl819x_ifcheck_resetornot(struct net_device
*dev
)
3542 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3543 RESET_TYPE TxResetType
= RESET_TYPE_NORESET
;
3544 RESET_TYPE RxResetType
= RESET_TYPE_NORESET
;
3545 RT_RF_POWER_STATE rfState
;
3547 rfState
= priv
->ieee80211
->eRFPowerState
;
3549 TxResetType
= TxCheckStuck(dev
);
3551 if( rfState
!= eRfOff
&&
3552 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3553 (priv
->ieee80211
->iw_mode
!= IW_MODE_ADHOC
))
3555 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3556 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3557 // if driver is in firmware download failure status, driver should initialize RF in the following
3558 // silent reset procedure Emily, 2008.01.21
3560 // Driver should not check RX stuck in IBSS mode because it is required to
3561 // set Check BSSID in order to send beacon, however, if check BSSID is
3562 // set, STA cannot hear any packet a all. Emily, 2008.04.12
3563 RxResetType
= RxCheckStuck(dev
);
3566 RT_TRACE(COMP_RESET
,"%s(): TxResetType is %d, RxResetType is %d\n",__FUNCTION__
,TxResetType
,RxResetType
);
3567 if(TxResetType
==RESET_TYPE_NORMAL
|| RxResetType
==RESET_TYPE_NORMAL
)
3568 return RESET_TYPE_NORMAL
;
3569 else if(TxResetType
==RESET_TYPE_SILENT
|| RxResetType
==RESET_TYPE_SILENT
)
3570 return RESET_TYPE_SILENT
;
3572 return RESET_TYPE_NORESET
;
3577 static void CamRestoreAllEntry(struct net_device
*dev
)
3580 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3581 const u8
* MacAddr
= priv
->ieee80211
->current_network
.bssid
;
3583 static const u8 CAM_CONST_ADDR
[4][6] = {
3584 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3585 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3586 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3587 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3588 static const u8 CAM_CONST_BROAD
[] =
3589 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3591 RT_TRACE(COMP_SEC
, "CamRestoreAllEntry: \n");
3594 if ((priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_WEP40
)||
3595 (priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_WEP104
))
3598 for(EntryId
=0; EntryId
<4; EntryId
++)
3601 MacAddr
= CAM_CONST_ADDR
[EntryId
];
3605 priv
->ieee80211
->pairwise_key_type
,
3613 else if(priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_TKIP
)
3617 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3621 priv
->ieee80211
->pairwise_key_type
,
3629 priv
->ieee80211
->pairwise_key_type
,
3635 else if(priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_CCMP
)
3639 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3643 priv
->ieee80211
->pairwise_key_type
,
3651 priv
->ieee80211
->pairwise_key_type
,
3660 if(priv
->ieee80211
->group_key_type
== KEY_TYPE_TKIP
)
3662 MacAddr
= CAM_CONST_BROAD
;
3663 for(EntryId
=1 ; EntryId
<4 ; EntryId
++)
3669 priv
->ieee80211
->group_key_type
,
3675 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3679 priv
->ieee80211
->group_key_type
,
3684 else if(priv
->ieee80211
->group_key_type
== KEY_TYPE_CCMP
)
3686 MacAddr
= CAM_CONST_BROAD
;
3687 for(EntryId
=1; EntryId
<4 ; EntryId
++)
3693 priv
->ieee80211
->group_key_type
,
3700 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3704 priv
->ieee80211
->group_key_type
,
3712 * This function is used to fix Tx/Rx stop bug temporarily.
3713 * This function will do "system reset" to NIC when Tx or Rx is stuck.
3714 * The method checking Tx/Rx stuck of this function is supported by FW,
3715 * which reports Tx and Rx counter to register 0x128 and 0x130.
3717 static void rtl819x_ifsilentreset(struct net_device
*dev
)
3719 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3721 int reset_status
= 0;
3722 struct ieee80211_device
*ieee
= priv
->ieee80211
;
3727 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3728 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3730 if(priv
->ResetProgress
==RESET_TYPE_NORESET
)
3734 //LZM for PS-Poll AID issue. 090429
3735 if(priv
->ieee80211
->state
== IEEE80211_LINKED
)
3736 LeisurePSLeave(dev
);
3739 RT_TRACE(COMP_RESET
,"=========>Reset progress!! \n");
3741 // Set the variable for reset.
3742 priv
->ResetProgress
= RESET_TYPE_SILENT
;
3743 // rtl8192_close(dev);
3745 down(&priv
->wx_sem
);
3748 RT_TRACE(COMP_ERR
,"%s():the driver is not up! return\n",__FUNCTION__
);
3753 RT_TRACE(COMP_RESET
,"%s():======>start to down the driver\n",__FUNCTION__
);
3754 if(!netif_queue_stopped(dev
))
3755 netif_stop_queue(dev
);
3757 dm_backup_dynamic_mechanism_state(dev
);
3759 rtl8192_irq_disable(dev
);
3760 rtl8192_cancel_deferred_work(priv
);
3762 del_timer_sync(&priv
->watch_dog_timer
);
3763 ieee
->sync_scan_hurryup
= 1;
3764 if(ieee
->state
== IEEE80211_LINKED
)
3766 down(&ieee
->wx_sem
);
3767 printk("ieee->state is IEEE80211_LINKED\n");
3768 ieee80211_stop_send_beacons(priv
->ieee80211
);
3769 del_timer_sync(&ieee
->associate_timer
);
3770 cancel_delayed_work(&ieee
->associate_retry_wq
);
3771 ieee80211_stop_scan(ieee
);
3775 printk("ieee->state is NOT LINKED\n");
3776 ieee80211_softmac_stop_protocol(priv
->ieee80211
,true);
3778 rtl8192_halt_adapter(dev
, true);
3780 RT_TRACE(COMP_RESET
,"%s():<==========down process is finished\n",__FUNCTION__
);
3781 RT_TRACE(COMP_RESET
,"%s():===========>start to up the driver\n",__FUNCTION__
);
3782 reset_status
= _rtl8192_up(dev
);
3784 RT_TRACE(COMP_RESET
,"%s():<===========up process is finished\n",__FUNCTION__
);
3785 if(reset_status
== -1)
3794 RT_TRACE(COMP_ERR
," ERR!!! %s(): Reset Failed!!\n",__FUNCTION__
);
3797 ieee
->is_silent_reset
= 1;
3798 EnableHWSecurityConfig8192(dev
);
3799 if(ieee
->state
== IEEE80211_LINKED
&& ieee
->iw_mode
== IW_MODE_INFRA
)
3801 ieee
->set_chan(ieee
->dev
, ieee
->current_network
.channel
);
3803 queue_work(ieee
->wq
, &ieee
->associate_complete_wq
);
3806 else if(ieee
->state
== IEEE80211_LINKED
&& ieee
->iw_mode
== IW_MODE_ADHOC
)
3808 ieee
->set_chan(ieee
->dev
, ieee
->current_network
.channel
);
3809 ieee
->link_change(ieee
->dev
);
3811 // notify_wx_assoc_event(ieee);
3813 ieee80211_start_send_beacons(ieee
);
3815 if (ieee
->data_hard_resume
)
3816 ieee
->data_hard_resume(ieee
->dev
);
3817 netif_carrier_on(ieee
->dev
);
3820 CamRestoreAllEntry(dev
);
3822 // Restore the previous setting for all dynamic mechanism
3823 dm_restore_dynamic_mechanism_state(dev
);
3825 priv
->ResetProgress
= RESET_TYPE_NORESET
;
3826 priv
->reset_count
++;
3828 priv
->bForcedSilentReset
=false;
3829 priv
->bResetInProgress
= false;
3831 // For test --> force write UFWP.
3832 write_nic_byte(dev
, UFWP
, 1);
3833 RT_TRACE(COMP_RESET
, "Reset finished!! ====>[%d]\n", priv
->reset_count
);
3838 void InactivePsWorkItemCallback(struct net_device
*dev
)
3840 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3841 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
3843 RT_TRACE(COMP_POWER
, "InactivePsWorkItemCallback() ---------> \n");
3845 // This flag "bSwRfProcessing", indicates the status of IPS procedure, should be set if the IPS workitem
3846 // is really scheduled.
3847 // The old code, sets this flag before scheduling the IPS workitem and however, at the same time the
3848 // previous IPS workitem did not end yet, fails to schedule the current workitem. Thus, bSwRfProcessing
3849 // blocks the IPS procedure of switching RF.
3850 // By Bruce, 2007-12-25.
3852 pPSC
->bSwRfProcessing
= TRUE
;
3854 RT_TRACE(COMP_RF
, "InactivePsWorkItemCallback(): Set RF to %s.\n",
3855 pPSC
->eInactivePowerState
== eRfOff
?"OFF":"ON");
3858 MgntActSet_RF_State(dev
, pPSC
->eInactivePowerState
, RF_CHANGE_BY_IPS
);
3861 // To solve CAM values miss in RF OFF, rewrite CAM values after RF ON. By Bruce, 2007-09-20.
3863 pPSC
->bSwRfProcessing
= FALSE
;
3864 RT_TRACE(COMP_POWER
, "InactivePsWorkItemCallback() <--------- \n");
3868 /* Change current and default preamble mode. */
3869 bool MgntActSet_802_11_PowerSaveMode(struct net_device
*dev
, u8 rtPsMode
)
3871 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3873 // Currently, we do not change power save mode on IBSS mode.
3874 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3880 // <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
3881 // some AP will not response to our mgnt frames with PwrMgt bit set,
3882 // e.g. cannot associate the AP.
3883 // So I commented out it. 2005.02.16, by rcnjko.
3885 // // Change device's power save mode.
3886 // Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
3888 // Update power save mode configured.
3889 //RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__FUNCTION__,rtPsMode);
3890 if(!priv
->ps_force
) {
3891 priv
->ieee80211
->ps
= rtPsMode
;
3894 // Awake immediately
3895 if(priv
->ieee80211
->sta_sleep
!= 0 && rtPsMode
== IEEE80211_PS_DISABLED
)
3897 unsigned long flags
;
3899 //PlatformSetTimer(Adapter, &(pMgntInfo->AwakeTimer), 0);
3900 // Notify the AP we awke.
3901 rtl8192_hw_wakeup(dev
);
3902 priv
->ieee80211
->sta_sleep
= 0;
3904 spin_lock_irqsave(&(priv
->ieee80211
->mgmt_tx_lock
), flags
);
3905 printk("LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
3906 ieee80211_sta_ps_send_null_frame(priv
->ieee80211
, 0);
3907 spin_unlock_irqrestore(&(priv
->ieee80211
->mgmt_tx_lock
), flags
);
3913 /* Enter the leisure power save mode. */
3914 void LeisurePSEnter(struct net_device
*dev
)
3916 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3917 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
3919 //RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
3920 //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
3921 // pPSC->bLeisurePs, priv->ieee80211->ps,pPSC->LpsIdleCount,RT_CHECK_FOR_HANG_PERIOD);
3923 if(!((priv
->ieee80211
->iw_mode
== IW_MODE_INFRA
) &&
3924 (priv
->ieee80211
->state
== IEEE80211_LINKED
)) ||
3925 (priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
) ||
3926 (priv
->ieee80211
->iw_mode
== IW_MODE_MASTER
))
3929 if (pPSC
->bLeisurePs
)
3931 // Idle for a while if we connect to AP a while ago.
3932 if(pPSC
->LpsIdleCount
>= RT_CHECK_FOR_HANG_PERIOD
) // 4 Sec
3935 if(priv
->ieee80211
->ps
== IEEE80211_PS_DISABLED
)
3938 //RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter 802.11 power save mode...\n");
3939 MgntActSet_802_11_PowerSaveMode(dev
, IEEE80211_PS_MBCAST
|IEEE80211_PS_UNICAST
);
3944 pPSC
->LpsIdleCount
++;
3949 /* Leave leisure power save mode. */
3950 void LeisurePSLeave(struct net_device
*dev
)
3952 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3953 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
3955 if (pPSC
->bLeisurePs
)
3957 if(priv
->ieee80211
->ps
!= IEEE80211_PS_DISABLED
)
3959 // move to lps_wakecomplete()
3960 //RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n");
3961 MgntActSet_802_11_PowerSaveMode(dev
, IEEE80211_PS_DISABLED
);
3969 /* Enter the inactive power save mode. RF will be off */
3971 IPSEnter(struct net_device
*dev
)
3973 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3974 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
3975 RT_RF_POWER_STATE rtState
;
3977 if (pPSC
->bInactivePs
)
3979 rtState
= priv
->ieee80211
->eRFPowerState
;
3981 // Added by Bruce, 2007-12-25.
3982 // Do not enter IPS in the following conditions:
3983 // (1) RF is already OFF or Sleep
3984 // (2) bSwRfProcessing (indicates the IPS is still under going)
3985 // (3) Connectted (only disconnected can trigger IPS)
3986 // (4) IBSS (send Beacon)
3987 // (5) AP mode (send Beacon)
3989 if (rtState
== eRfOn
&& !pPSC
->bSwRfProcessing
3990 && (priv
->ieee80211
->state
!= IEEE80211_LINKED
) )
3992 RT_TRACE(COMP_RF
,"IPSEnter(): Turn off RF.\n");
3993 pPSC
->eInactivePowerState
= eRfOff
;
3994 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
3995 InactivePsWorkItemCallback(dev
);
4002 // Leave the inactive power save mode, RF will be on.
4003 // 2007.08.17, by shien chang.
4006 IPSLeave(struct net_device
*dev
)
4008 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4009 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
4010 RT_RF_POWER_STATE rtState
;
4012 if (pPSC
->bInactivePs
)
4014 rtState
= priv
->ieee80211
->eRFPowerState
;
4015 if (rtState
!= eRfOn
&& !pPSC
->bSwRfProcessing
&& priv
->ieee80211
->RfOffReason
<= RF_CHANGE_BY_IPS
)
4017 RT_TRACE(COMP_POWER
, "IPSLeave(): Turn on RF.\n");
4018 pPSC
->eInactivePowerState
= eRfOn
;
4019 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4020 InactivePsWorkItemCallback(dev
);
4025 void IPSLeave_wq(void *data
)
4027 struct ieee80211_device
*ieee
= container_of(data
,struct ieee80211_device
,ips_leave_wq
);
4028 struct net_device
*dev
= ieee
->dev
;
4030 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4031 down(&priv
->ieee80211
->ips_sem
);
4033 up(&priv
->ieee80211
->ips_sem
);
4036 void ieee80211_ips_leave_wq(struct net_device
*dev
)
4038 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4039 RT_RF_POWER_STATE rtState
;
4040 rtState
= priv
->ieee80211
->eRFPowerState
;
4042 if(priv
->ieee80211
->PowerSaveControl
.bInactivePs
){
4043 if(rtState
== eRfOff
){
4044 if(priv
->ieee80211
->RfOffReason
> RF_CHANGE_BY_IPS
)
4046 RT_TRACE(COMP_ERR
, "%s(): RF is OFF.\n",__FUNCTION__
);
4050 printk("=========>%s(): IPSLeave\n",__FUNCTION__
);
4051 queue_work(priv
->ieee80211
->wq
,&priv
->ieee80211
->ips_leave_wq
);
4056 //added by amy 090331 end
4057 void ieee80211_ips_leave(struct net_device
*dev
)
4059 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4060 down(&priv
->ieee80211
->ips_sem
);
4062 up(&priv
->ieee80211
->ips_sem
);
4066 static void rtl819x_update_rxcounts(
4067 struct r8192_priv
*priv
,
4076 *TotalRxDataNum
= 0;
4078 SlotIndex
= (priv
->ieee80211
->LinkDetectInfo
.SlotIndex
++)%(priv
->ieee80211
->LinkDetectInfo
.SlotNum
);
4079 priv
->ieee80211
->LinkDetectInfo
.RxBcnNum
[SlotIndex
] = priv
->ieee80211
->LinkDetectInfo
.NumRecvBcnInPeriod
;
4080 priv
->ieee80211
->LinkDetectInfo
.RxDataNum
[SlotIndex
] = priv
->ieee80211
->LinkDetectInfo
.NumRecvDataInPeriod
;
4081 for( i
=0; i
<priv
->ieee80211
->LinkDetectInfo
.SlotNum
; i
++ ){
4082 *TotalRxBcnNum
+= priv
->ieee80211
->LinkDetectInfo
.RxBcnNum
[i
];
4083 *TotalRxDataNum
+= priv
->ieee80211
->LinkDetectInfo
.RxDataNum
[i
];
4088 static void rtl819x_watchdog_wqcallback(struct work_struct
*work
)
4090 struct delayed_work
*dwork
= container_of(work
,struct delayed_work
,work
);
4091 struct r8192_priv
*priv
= container_of(dwork
,struct r8192_priv
,watch_dog_wq
);
4092 struct net_device
*dev
= priv
->ieee80211
->dev
;
4093 struct ieee80211_device
* ieee
= priv
->ieee80211
;
4094 RESET_TYPE ResetType
= RESET_TYPE_NORESET
;
4095 unsigned long flags
;
4096 bool bBusyTraffic
= false;
4097 bool bEnterPS
= false;
4099 if ((!priv
->up
) || priv
->bHwRadioOff
)
4104 hal_dm_watchdog(dev
);
4106 if(ieee
->actscanning
== false){
4107 if((ieee
->iw_mode
== IW_MODE_INFRA
) && (ieee
->state
== IEEE80211_NOLINK
) &&
4108 (ieee
->eRFPowerState
== eRfOn
)&&!ieee
->is_set_key
&&
4109 (!ieee
->proto_stoppping
) && !ieee
->wx_set_enc
){
4110 if(ieee
->PowerSaveControl
.ReturnPoint
== IPS_CALLBACK_NONE
){
4112 //ieee80211_stop_scan(priv->ieee80211);
4117 {//to get busy traffic condition
4118 if(ieee
->state
== IEEE80211_LINKED
)
4120 if( ieee
->LinkDetectInfo
.NumRxOkInPeriod
> 100 ||
4121 ieee
->LinkDetectInfo
.NumTxOkInPeriod
> 100 ) {
4122 bBusyTraffic
= true;
4126 //added by amy for Leisure PS
4127 if( ((ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
+ ieee
->LinkDetectInfo
.NumTxOkInPeriod
) > 8 ) ||
4128 (ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
> 2) )
4137 // LeisurePS only work in infra mode.
4140 LeisurePSEnter(dev
);
4144 LeisurePSLeave(dev
);
4152 //RT_TRACE(COMP_LPS,"====>no link LPS leave\n");
4153 LeisurePSLeave(dev
);
4157 ieee
->LinkDetectInfo
.NumRxOkInPeriod
= 0;
4158 ieee
->LinkDetectInfo
.NumTxOkInPeriod
= 0;
4159 ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
= 0;
4160 ieee
->LinkDetectInfo
.bBusyTraffic
= bBusyTraffic
;
4164 //added by amy for AP roaming
4167 if(ieee
->state
== IEEE80211_LINKED
&& ieee
->iw_mode
== IW_MODE_INFRA
)
4169 u32 TotalRxBcnNum
= 0;
4170 u32 TotalRxDataNum
= 0;
4172 rtl819x_update_rxcounts(priv
, &TotalRxBcnNum
, &TotalRxDataNum
);
4173 if((TotalRxBcnNum
+TotalRxDataNum
) == 0)
4175 if( ieee
->eRFPowerState
== eRfOff
)
4176 RT_TRACE(COMP_ERR
,"========>%s()\n",__FUNCTION__
);
4177 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__
);
4178 // Dot11d_Reset(dev);
4179 ieee
->state
= IEEE80211_ASSOCIATING
;
4180 notify_wx_assoc_event(priv
->ieee80211
);
4181 RemovePeerTS(priv
->ieee80211
,priv
->ieee80211
->current_network
.bssid
);
4182 ieee
->is_roaming
= true;
4183 ieee
->is_set_key
= false;
4184 ieee
->link_change(dev
);
4185 queue_work(ieee
->wq
, &ieee
->associate_procedure_wq
);
4188 ieee
->LinkDetectInfo
.NumRecvBcnInPeriod
=0;
4189 ieee
->LinkDetectInfo
.NumRecvDataInPeriod
=0;
4192 //check if reset the driver
4193 spin_lock_irqsave(&priv
->tx_lock
,flags
);
4194 if (priv
->watchdog_check_reset_cnt
++ >= 3 && !ieee
->is_roaming
&&
4195 priv
->watchdog_last_time
!= 1)
4197 ResetType
= rtl819x_ifcheck_resetornot(dev
);
4198 priv
->watchdog_check_reset_cnt
= 3;
4200 spin_unlock_irqrestore(&priv
->tx_lock
,flags
);
4201 if(!priv
->bDisableNormalResetCheck
&& ResetType
== RESET_TYPE_NORMAL
)
4203 priv
->ResetProgress
= RESET_TYPE_NORMAL
;
4204 RT_TRACE(COMP_RESET
,"%s(): NOMAL RESET\n",__FUNCTION__
);
4207 /* disable silent reset temply 2008.9.11*/
4209 if( ((priv
->force_reset
) || (!priv
->bDisableNormalResetCheck
&& ResetType
==RESET_TYPE_SILENT
))) // This is control by OID set in Pomelo
4211 priv
->watchdog_last_time
= 1;
4212 rtl819x_ifsilentreset(dev
);
4215 priv
->watchdog_last_time
= 0;
4217 priv
->force_reset
= false;
4218 priv
->bForcedSilentReset
= false;
4219 priv
->bResetInProgress
= false;
4220 RT_TRACE(COMP_TRACE
, " <==RtUsbCheckForHangWorkItemCallback()\n");
4224 void watch_dog_timer_callback(unsigned long data
)
4226 struct r8192_priv
*priv
= ieee80211_priv((struct net_device
*) data
);
4227 queue_delayed_work(priv
->priv_wq
,&priv
->watch_dog_wq
,0);
4228 mod_timer(&priv
->watch_dog_timer
, jiffies
+ MSECS(IEEE80211_WATCH_DOG_TIME
));
4232 static int _rtl8192_up(struct net_device
*dev
)
4234 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4236 RT_STATUS init_status
= RT_STATUS_SUCCESS
;
4238 priv
->ieee80211
->ieee_up
=1;
4239 priv
->bdisable_nic
= false; //YJ,add,091111
4240 RT_TRACE(COMP_INIT
, "Bringing up iface");
4242 init_status
= rtl8192_adapter_start(dev
);
4243 if(init_status
!= RT_STATUS_SUCCESS
)
4245 RT_TRACE(COMP_ERR
,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__
);
4248 RT_TRACE(COMP_INIT
, "start adapter finished\n");
4250 if(priv
->ieee80211
->eRFPowerState
!=eRfOn
)
4251 MgntActSet_RF_State(dev
, eRfOn
, priv
->ieee80211
->RfOffReason
);
4253 if(priv
->ieee80211
->state
!= IEEE80211_LINKED
)
4254 ieee80211_softmac_start_protocol(priv
->ieee80211
);
4255 ieee80211_reset_queue(priv
->ieee80211
);
4256 watch_dog_timer_callback((unsigned long) dev
);
4257 if(!netif_queue_stopped(dev
))
4258 netif_start_queue(dev
);
4260 netif_wake_queue(dev
);
4266 static int rtl8192_open(struct net_device
*dev
)
4268 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4271 down(&priv
->wx_sem
);
4272 ret
= rtl8192_up(dev
);
4279 int rtl8192_up(struct net_device
*dev
)
4281 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4283 if (priv
->up
== 1) return -1;
4285 return _rtl8192_up(dev
);
4289 static int rtl8192_close(struct net_device
*dev
)
4291 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4294 down(&priv
->wx_sem
);
4296 ret
= rtl8192_down(dev
);
4304 int rtl8192_down(struct net_device
*dev
)
4306 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4308 if (priv
->up
== 0) return -1;
4311 //LZM for PS-Poll AID issue. 090429
4312 if(priv
->ieee80211
->state
== IEEE80211_LINKED
)
4313 LeisurePSLeave(dev
);
4317 priv
->ieee80211
->ieee_up
= 0;
4318 RT_TRACE(COMP_DOWN
, "==========>%s()\n", __FUNCTION__
);
4320 if (!netif_queue_stopped(dev
))
4321 netif_stop_queue(dev
);
4323 rtl8192_irq_disable(dev
);
4324 rtl8192_cancel_deferred_work(priv
);
4326 del_timer_sync(&priv
->watch_dog_timer
);
4328 ieee80211_softmac_stop_protocol(priv
->ieee80211
,true);
4330 rtl8192_halt_adapter(dev
,false);
4331 memset(&priv
->ieee80211
->current_network
, 0 , offsetof(struct ieee80211_network
, list
));
4333 RT_TRACE(COMP_DOWN
, "<==========%s()\n", __FUNCTION__
);
4339 void rtl8192_commit(struct net_device
*dev
)
4341 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4343 if (priv
->up
== 0) return ;
4346 ieee80211_softmac_stop_protocol(priv
->ieee80211
,true);
4348 rtl8192_irq_disable(dev
);
4349 rtl8192_halt_adapter(dev
,true);
4353 static void rtl8192_restart(struct work_struct
*work
)
4355 struct r8192_priv
*priv
= container_of(work
, struct r8192_priv
, reset_wq
);
4356 struct net_device
*dev
= priv
->ieee80211
->dev
;
4358 down(&priv
->wx_sem
);
4360 rtl8192_commit(dev
);
4365 static void r8192_set_multicast(struct net_device
*dev
)
4367 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4370 //down(&priv->wx_sem);
4374 promisc
= (dev
->flags
& IFF_PROMISC
) ? 1:0;
4376 if (promisc
!= priv
->promisc
) {
4378 // rtl8192_commit(dev);
4381 priv
->promisc
= promisc
;
4383 //schedule_work(&priv->reset_wq);
4384 //up(&priv->wx_sem);
4388 static int r8192_set_mac_adr(struct net_device
*dev
, void *mac
)
4390 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4391 struct sockaddr
*addr
= mac
;
4393 down(&priv
->wx_sem
);
4395 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
4397 schedule_work(&priv
->reset_wq
);
4403 /* based on ipw2200 driver */
4404 static int rtl8192_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
4406 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4407 struct iwreq
*wrq
= (struct iwreq
*)rq
;
4409 struct ieee80211_device
*ieee
= priv
->ieee80211
;
4411 u8 broadcast_addr
[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4412 struct iw_point
*p
= &wrq
->u
.data
;
4413 struct ieee_param
*ipw
= NULL
;//(struct ieee_param *)wrq->u.data.pointer;
4415 down(&priv
->wx_sem
);
4418 if (p
->length
< sizeof(struct ieee_param
) || !p
->pointer
){
4423 ipw
= kmalloc(p
->length
, GFP_KERNEL
);
4428 if (copy_from_user(ipw
, p
->pointer
, p
->length
)) {
4435 case RTL_IOCTL_WPA_SUPPLICANT
:
4436 //parse here for HW security
4437 if (ipw
->cmd
== IEEE_CMD_SET_ENCRYPTION
)
4439 if (ipw
->u
.crypt
.set_tx
)
4441 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
4442 ieee
->pairwise_key_type
= KEY_TYPE_CCMP
;
4443 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
4444 ieee
->pairwise_key_type
= KEY_TYPE_TKIP
;
4445 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0)
4447 if (ipw
->u
.crypt
.key_len
== 13)
4448 ieee
->pairwise_key_type
= KEY_TYPE_WEP104
;
4449 else if (ipw
->u
.crypt
.key_len
== 5)
4450 ieee
->pairwise_key_type
= KEY_TYPE_WEP40
;
4453 ieee
->pairwise_key_type
= KEY_TYPE_NA
;
4455 if (ieee
->pairwise_key_type
)
4457 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
4458 EnableHWSecurityConfig8192(dev
);
4459 //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!
4461 setKey(dev
, 4, ipw
->u
.crypt
.idx
, ieee
->pairwise_key_type
, (u8
*)ieee
->ap_mac_addr
, 0, key
);
4462 if (ieee
->auth_mode
!= 2) //LEAP WEP will never set this.
4463 setKey(dev
, ipw
->u
.crypt
.idx
, ipw
->u
.crypt
.idx
, ieee
->pairwise_key_type
, (u8
*)ieee
->ap_mac_addr
, 0, key
);
4465 if ((ieee
->pairwise_key_type
== KEY_TYPE_CCMP
) && ieee
->pHTInfo
->bCurrentHTSupport
){
4466 write_nic_byte(dev
, 0x173, 1); //fix aes bug
4470 else //if (ipw->u.crypt.idx) //group key use idx > 0
4472 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
4473 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
4474 ieee
->group_key_type
= KEY_TYPE_CCMP
;
4475 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
4476 ieee
->group_key_type
= KEY_TYPE_TKIP
;
4477 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0)
4479 if (ipw
->u
.crypt
.key_len
== 13)
4480 ieee
->group_key_type
= KEY_TYPE_WEP104
;
4481 else if (ipw
->u
.crypt
.key_len
== 5)
4482 ieee
->group_key_type
= KEY_TYPE_WEP40
;
4485 ieee
->group_key_type
= KEY_TYPE_NA
;
4487 if (ieee
->group_key_type
)
4491 ipw
->u
.crypt
.idx
, //KeyIndex
4492 ieee
->group_key_type
, //KeyType
4493 broadcast_addr
, //MacAddr
4499 ret
= ieee80211_wpa_supplicant_ioctl(priv
->ieee80211
, &wrq
->u
.data
);
4514 static u8
HwRateToMRate90(bool bIsHT
, u8 rate
)
4520 case DESC90_RATE1M
: ret_rate
= MGN_1M
; break;
4521 case DESC90_RATE2M
: ret_rate
= MGN_2M
; break;
4522 case DESC90_RATE5_5M
: ret_rate
= MGN_5_5M
; break;
4523 case DESC90_RATE11M
: ret_rate
= MGN_11M
; break;
4524 case DESC90_RATE6M
: ret_rate
= MGN_6M
; break;
4525 case DESC90_RATE9M
: ret_rate
= MGN_9M
; break;
4526 case DESC90_RATE12M
: ret_rate
= MGN_12M
; break;
4527 case DESC90_RATE18M
: ret_rate
= MGN_18M
; break;
4528 case DESC90_RATE24M
: ret_rate
= MGN_24M
; break;
4529 case DESC90_RATE36M
: ret_rate
= MGN_36M
; break;
4530 case DESC90_RATE48M
: ret_rate
= MGN_48M
; break;
4531 case DESC90_RATE54M
: ret_rate
= MGN_54M
; break;
4534 RT_TRACE(COMP_RECV
, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate
, bIsHT
);
4540 case DESC90_RATEMCS0
: ret_rate
= MGN_MCS0
; break;
4541 case DESC90_RATEMCS1
: ret_rate
= MGN_MCS1
; break;
4542 case DESC90_RATEMCS2
: ret_rate
= MGN_MCS2
; break;
4543 case DESC90_RATEMCS3
: ret_rate
= MGN_MCS3
; break;
4544 case DESC90_RATEMCS4
: ret_rate
= MGN_MCS4
; break;
4545 case DESC90_RATEMCS5
: ret_rate
= MGN_MCS5
; break;
4546 case DESC90_RATEMCS6
: ret_rate
= MGN_MCS6
; break;
4547 case DESC90_RATEMCS7
: ret_rate
= MGN_MCS7
; break;
4548 case DESC90_RATEMCS8
: ret_rate
= MGN_MCS8
; break;
4549 case DESC90_RATEMCS9
: ret_rate
= MGN_MCS9
; break;
4550 case DESC90_RATEMCS10
: ret_rate
= MGN_MCS10
; break;
4551 case DESC90_RATEMCS11
: ret_rate
= MGN_MCS11
; break;
4552 case DESC90_RATEMCS12
: ret_rate
= MGN_MCS12
; break;
4553 case DESC90_RATEMCS13
: ret_rate
= MGN_MCS13
; break;
4554 case DESC90_RATEMCS14
: ret_rate
= MGN_MCS14
; break;
4555 case DESC90_RATEMCS15
: ret_rate
= MGN_MCS15
; break;
4556 case DESC90_RATEMCS32
: ret_rate
= (0x80|0x20); break;
4559 RT_TRACE(COMP_RECV
, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate
, bIsHT
);
4567 /* Record the TSF time stamp when receiving a packet */
4568 static void UpdateRxPktTimeStamp8190 (struct net_device
*dev
, struct ieee80211_rx_stats
*stats
)
4570 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4572 if(stats
->bIsAMPDU
&& !stats
->bFirstMPDU
) {
4573 stats
->mac_time
[0] = priv
->LastRxDescTSFLow
;
4574 stats
->mac_time
[1] = priv
->LastRxDescTSFHigh
;
4576 priv
->LastRxDescTSFLow
= stats
->mac_time
[0];
4577 priv
->LastRxDescTSFHigh
= stats
->mac_time
[1];
4581 static long rtl819x_translate_todbm(u8 signal_strength_index
)// 0-100 index.
4583 long signal_power
; // in dBm.
4585 // Translate to dBm (x=0.5y-95).
4586 signal_power
= (long)((signal_strength_index
+ 1) >> 1);
4589 return signal_power
;
4593 rtl8190_process_cck_rxpathsel(
4594 struct r8192_priv
* priv
,
4595 struct ieee80211_rx_stats
* pprevious_stats
4598 #ifdef RTL8190P //Only 90P 2T4R need to check
4599 char last_cck_adc_pwdb
[4]={0,0,0,0};
4601 //cosa add for Rx path selection
4602 if(priv
->rf_type
== RF_2T4R
&& DM_RxPathSelTable
.Enable
)
4604 if(pprevious_stats
->bIsCCK
&&
4605 (pprevious_stats
->bPacketToSelf
||pprevious_stats
->bPacketBeacon
))
4607 /* record the cck adc_pwdb to the sliding window. */
4608 if(priv
->stats
.cck_adc_pwdb
.TotalNum
++ >= PHY_RSSI_SLID_WIN_MAX
)
4610 priv
->stats
.cck_adc_pwdb
.TotalNum
= PHY_RSSI_SLID_WIN_MAX
;
4611 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
4613 last_cck_adc_pwdb
[i
] = priv
->stats
.cck_adc_pwdb
.elements
[i
][priv
->stats
.cck_adc_pwdb
.index
];
4614 priv
->stats
.cck_adc_pwdb
.TotalVal
[i
] -= last_cck_adc_pwdb
[i
];
4617 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
4619 priv
->stats
.cck_adc_pwdb
.TotalVal
[i
] += pprevious_stats
->cck_adc_pwdb
[i
];
4620 priv
->stats
.cck_adc_pwdb
.elements
[i
][priv
->stats
.cck_adc_pwdb
.index
] = pprevious_stats
->cck_adc_pwdb
[i
];
4622 priv
->stats
.cck_adc_pwdb
.index
++;
4623 if(priv
->stats
.cck_adc_pwdb
.index
>= PHY_RSSI_SLID_WIN_MAX
)
4624 priv
->stats
.cck_adc_pwdb
.index
= 0;
4626 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
4628 DM_RxPathSelTable
.cck_pwdb_sta
[i
] = priv
->stats
.cck_adc_pwdb
.TotalVal
[i
]/priv
->stats
.cck_adc_pwdb
.TotalNum
;
4631 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
4633 if(pprevious_stats
->cck_adc_pwdb
[i
] > (char)priv
->undecorated_smoothed_cck_adc_pwdb
[i
])
4635 priv
->undecorated_smoothed_cck_adc_pwdb
[i
] =
4636 ( (priv
->undecorated_smoothed_cck_adc_pwdb
[i
]*(Rx_Smooth_Factor
-1)) +
4637 (pprevious_stats
->cck_adc_pwdb
[i
])) /(Rx_Smooth_Factor
);
4638 priv
->undecorated_smoothed_cck_adc_pwdb
[i
] = priv
->undecorated_smoothed_cck_adc_pwdb
[i
] + 1;
4642 priv
->undecorated_smoothed_cck_adc_pwdb
[i
] =
4643 ( (priv
->undecorated_smoothed_cck_adc_pwdb
[i
]*(Rx_Smooth_Factor
-1)) +
4644 (pprevious_stats
->cck_adc_pwdb
[i
])) /(Rx_Smooth_Factor
);
4653 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
4654 be a local static. Otherwise, it may increase when we return from S3/S4. The
4655 value will be kept in memory or disk. We must delcare the value in adapter
4656 and it will be reinitialized when return from S3/S4. */
4657 static void rtl8192_process_phyinfo(struct r8192_priv
* priv
, u8
* buffer
,struct ieee80211_rx_stats
* pprevious_stats
, struct ieee80211_rx_stats
* pcurrent_stats
)
4659 bool bcheck
= false;
4661 u32 nspatial_stream
, tmp_val
;
4663 static u32 slide_rssi_index
=0, slide_rssi_statistics
=0;
4664 static u32 slide_evm_index
=0, slide_evm_statistics
=0;
4665 static u32 last_rssi
=0, last_evm
=0;
4666 //cosa add for rx path selection
4667 // static long slide_cck_adc_pwdb_index=0, slide_cck_adc_pwdb_statistics=0;
4668 // static char last_cck_adc_pwdb[4]={0,0,0,0};
4669 //cosa add for beacon rssi smoothing
4670 static u32 slide_beacon_adc_pwdb_index
=0, slide_beacon_adc_pwdb_statistics
=0;
4671 static u32 last_beacon_adc_pwdb
=0;
4673 struct ieee80211_hdr_3addr
*hdr
;
4675 unsigned int frag
,seq
;
4676 hdr
= (struct ieee80211_hdr_3addr
*)buffer
;
4677 sc
= le16_to_cpu(hdr
->seq_ctl
);
4678 frag
= WLAN_GET_SEQ_FRAG(sc
);
4679 seq
= WLAN_GET_SEQ_SEQ(sc
);
4680 //cosa add 04292008 to record the sequence number
4681 pcurrent_stats
->Seq_Num
= seq
;
4683 // Check whether we should take the previous packet into accounting
4685 if(!pprevious_stats
->bIsAMPDU
)
4687 // if previous packet is not aggregated packet
4691 if(slide_rssi_statistics
++ >= PHY_RSSI_SLID_WIN_MAX
)
4693 slide_rssi_statistics
= PHY_RSSI_SLID_WIN_MAX
;
4694 last_rssi
= priv
->stats
.slide_signal_strength
[slide_rssi_index
];
4695 priv
->stats
.slide_rssi_total
-= last_rssi
;
4697 priv
->stats
.slide_rssi_total
+= pprevious_stats
->SignalStrength
;
4699 priv
->stats
.slide_signal_strength
[slide_rssi_index
++] = pprevious_stats
->SignalStrength
;
4700 if(slide_rssi_index
>= PHY_RSSI_SLID_WIN_MAX
)
4701 slide_rssi_index
= 0;
4703 // <1> Showed on UI for user, in dbm
4704 tmp_val
= priv
->stats
.slide_rssi_total
/slide_rssi_statistics
;
4705 priv
->stats
.signal_strength
= rtl819x_translate_todbm((u8
)tmp_val
);
4706 pcurrent_stats
->rssi
= priv
->stats
.signal_strength
;
4708 // If the previous packet does not match the criteria, neglect it
4710 if(!pprevious_stats
->bPacketMatchBSSID
)
4712 if(!pprevious_stats
->bToSelfBA
)
4719 rtl8190_process_cck_rxpathsel(priv
,pprevious_stats
);
4721 // <2> Showed on UI for engineering
4722 // hardware does not provide rssi information for each rf path in CCK
4723 if(!pprevious_stats
->bIsCCK
&& pprevious_stats
->bPacketToSelf
)
4725 for (rfpath
= RF90_PATH_A
; rfpath
< RF90_PATH_C
; rfpath
++)
4727 if (!rtl8192_phy_CheckIsLegalRFPath(priv
->ieee80211
->dev
, rfpath
))
4729 RT_TRACE(COMP_DBG
,"Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d \n" ,pprevious_stats
->RxMIMOSignalStrength
[rfpath
] );
4730 //Fixed by Jacken 2008-03-20
4731 if(priv
->stats
.rx_rssi_percentage
[rfpath
] == 0)
4733 priv
->stats
.rx_rssi_percentage
[rfpath
] = pprevious_stats
->RxMIMOSignalStrength
[rfpath
];
4735 if(pprevious_stats
->RxMIMOSignalStrength
[rfpath
] > priv
->stats
.rx_rssi_percentage
[rfpath
])
4737 priv
->stats
.rx_rssi_percentage
[rfpath
] =
4738 ( (priv
->stats
.rx_rssi_percentage
[rfpath
]*(Rx_Smooth_Factor
-1)) +
4739 (pprevious_stats
->RxMIMOSignalStrength
[rfpath
])) /(Rx_Smooth_Factor
);
4740 priv
->stats
.rx_rssi_percentage
[rfpath
] = priv
->stats
.rx_rssi_percentage
[rfpath
] + 1;
4744 priv
->stats
.rx_rssi_percentage
[rfpath
] =
4745 ( (priv
->stats
.rx_rssi_percentage
[rfpath
]*(Rx_Smooth_Factor
-1)) +
4746 (pprevious_stats
->RxMIMOSignalStrength
[rfpath
])) /(Rx_Smooth_Factor
);
4748 RT_TRACE(COMP_DBG
,"Jacken -> priv->RxStats.RxRSSIPercentage[rfPath] = %d \n" ,priv
->stats
.rx_rssi_percentage
[rfpath
] );
4756 //cosa add for beacon rssi smoothing by average.
4757 if(pprevious_stats
->bPacketBeacon
)
4759 /* record the beacon pwdb to the sliding window. */
4760 if(slide_beacon_adc_pwdb_statistics
++ >= PHY_Beacon_RSSI_SLID_WIN_MAX
)
4762 slide_beacon_adc_pwdb_statistics
= PHY_Beacon_RSSI_SLID_WIN_MAX
;
4763 last_beacon_adc_pwdb
= priv
->stats
.Slide_Beacon_pwdb
[slide_beacon_adc_pwdb_index
];
4764 priv
->stats
.Slide_Beacon_Total
-= last_beacon_adc_pwdb
;
4765 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
4767 priv
->stats
.Slide_Beacon_Total
+= pprevious_stats
->RxPWDBAll
;
4768 priv
->stats
.Slide_Beacon_pwdb
[slide_beacon_adc_pwdb_index
] = pprevious_stats
->RxPWDBAll
;
4769 slide_beacon_adc_pwdb_index
++;
4770 if(slide_beacon_adc_pwdb_index
>= PHY_Beacon_RSSI_SLID_WIN_MAX
)
4771 slide_beacon_adc_pwdb_index
= 0;
4772 pprevious_stats
->RxPWDBAll
= priv
->stats
.Slide_Beacon_Total
/slide_beacon_adc_pwdb_statistics
;
4773 if(pprevious_stats
->RxPWDBAll
>= 3)
4774 pprevious_stats
->RxPWDBAll
-= 3;
4777 RT_TRACE(COMP_RXDESC
, "Smooth %s PWDB = %d\n",
4778 pprevious_stats
->bIsCCK
? "CCK": "OFDM",
4779 pprevious_stats
->RxPWDBAll
);
4781 if(pprevious_stats
->bPacketToSelf
|| pprevious_stats
->bPacketBeacon
|| pprevious_stats
->bToSelfBA
)
4783 if(priv
->undecorated_smoothed_pwdb
< 0) // initialize
4785 priv
->undecorated_smoothed_pwdb
= pprevious_stats
->RxPWDBAll
;
4788 if(pprevious_stats
->RxPWDBAll
> (u32
)priv
->undecorated_smoothed_pwdb
)
4790 priv
->undecorated_smoothed_pwdb
=
4791 ( ((priv
->undecorated_smoothed_pwdb
)*(Rx_Smooth_Factor
-1)) +
4792 (pprevious_stats
->RxPWDBAll
)) /(Rx_Smooth_Factor
);
4793 priv
->undecorated_smoothed_pwdb
= priv
->undecorated_smoothed_pwdb
+ 1;
4797 priv
->undecorated_smoothed_pwdb
=
4798 ( ((priv
->undecorated_smoothed_pwdb
)*(Rx_Smooth_Factor
-1)) +
4799 (pprevious_stats
->RxPWDBAll
)) /(Rx_Smooth_Factor
);
4806 /* record the general EVM to the sliding window. */
4807 if(pprevious_stats
->SignalQuality
== 0)
4812 if(pprevious_stats
->bPacketToSelf
|| pprevious_stats
->bPacketBeacon
|| pprevious_stats
->bToSelfBA
){
4813 if(slide_evm_statistics
++ >= PHY_RSSI_SLID_WIN_MAX
){
4814 slide_evm_statistics
= PHY_RSSI_SLID_WIN_MAX
;
4815 last_evm
= priv
->stats
.slide_evm
[slide_evm_index
];
4816 priv
->stats
.slide_evm_total
-= last_evm
;
4819 priv
->stats
.slide_evm_total
+= pprevious_stats
->SignalQuality
;
4821 priv
->stats
.slide_evm
[slide_evm_index
++] = pprevious_stats
->SignalQuality
;
4822 if(slide_evm_index
>= PHY_RSSI_SLID_WIN_MAX
)
4823 slide_evm_index
= 0;
4825 // <1> Showed on UI for user, in percentage.
4826 tmp_val
= priv
->stats
.slide_evm_total
/slide_evm_statistics
;
4827 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
4830 // <2> Showed on UI for engineering
4831 if(pprevious_stats
->bPacketToSelf
|| pprevious_stats
->bPacketBeacon
|| pprevious_stats
->bToSelfBA
)
4833 for(nspatial_stream
= 0; nspatial_stream
<2 ; nspatial_stream
++) // 2 spatial stream
4835 if(pprevious_stats
->RxMIMOSignalQuality
[nspatial_stream
] != -1)
4837 if(priv
->stats
.rx_evm_percentage
[nspatial_stream
] == 0) // initialize
4839 priv
->stats
.rx_evm_percentage
[nspatial_stream
] = pprevious_stats
->RxMIMOSignalQuality
[nspatial_stream
];
4841 priv
->stats
.rx_evm_percentage
[nspatial_stream
] =
4842 ( (priv
->stats
.rx_evm_percentage
[nspatial_stream
]* (Rx_Smooth_Factor
-1)) +
4843 (pprevious_stats
->RxMIMOSignalQuality
[nspatial_stream
]* 1)) / (Rx_Smooth_Factor
);
4851 static u8
rtl819x_query_rxpwrpercentage(
4855 if ((antpower
<= -100) || (antpower
>= 20))
4859 else if (antpower
>= 0)
4865 return (100+antpower
);
4871 rtl819x_evm_dbtopercentage(
4883 ret_val
= 0 - ret_val
;
4890 /* We want good-looking for signal strength/quality */
4891 static long rtl819x_signal_scale_mapping(long currsig
)
4895 // Step 1. Scale mapping.
4896 if(currsig
>= 61 && currsig
<= 100)
4898 retsig
= 90 + ((currsig
- 60) / 4);
4900 else if(currsig
>= 41 && currsig
<= 60)
4902 retsig
= 78 + ((currsig
- 40) / 2);
4904 else if(currsig
>= 31 && currsig
<= 40)
4906 retsig
= 66 + (currsig
- 30);
4908 else if(currsig
>= 21 && currsig
<= 30)
4910 retsig
= 54 + (currsig
- 20);
4912 else if(currsig
>= 5 && currsig
<= 20)
4914 retsig
= 42 + (((currsig
- 5) * 2) / 3);
4916 else if(currsig
== 4)
4920 else if(currsig
== 3)
4924 else if(currsig
== 2)
4928 else if(currsig
== 1)
4940 static void rtl8192_query_rxphystatus(
4941 struct r8192_priv
* priv
,
4942 struct ieee80211_rx_stats
* pstats
,
4943 prx_desc_819x_pci pdesc
,
4944 prx_fwinfo_819x_pci pdrvinfo
,
4945 struct ieee80211_rx_stats
* precord_stats
,
4946 bool bpacket_match_bssid
,
4947 bool bpacket_toself
,
4952 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
4953 phy_sts_ofdm_819xpci_t
* pofdm_buf
;
4954 phy_sts_cck_819xpci_t
* pcck_buf
;
4955 phy_ofdm_rx_status_rxsc_sgien_exintfflag
* prxsc
;
4957 u8 i
,max_spatial_stream
, tmp_rxsnr
, tmp_rxevm
, rxsc_sgien_exflg
;
4958 char rx_pwr
[4], rx_pwr_all
=0;
4959 //long rx_avg_pwr = 0;
4960 char rx_snrX
, rx_evmX
;
4962 u32 RSSI
, total_rssi
=0;//, total_evm=0;
4963 // long signal_strength_index = 0;
4967 is_cck_rate
= rx_hal_is_cck_rate(pdrvinfo
);
4969 // Record it for next packet processing
4970 memset(precord_stats
, 0, sizeof(struct ieee80211_rx_stats
));
4971 pstats
->bPacketMatchBSSID
= precord_stats
->bPacketMatchBSSID
= bpacket_match_bssid
;
4972 pstats
->bPacketToSelf
= precord_stats
->bPacketToSelf
= bpacket_toself
;
4973 pstats
->bIsCCK
= precord_stats
->bIsCCK
= is_cck_rate
;//RX_HAL_IS_CCK_RATE(pDrvInfo);
4974 pstats
->bPacketBeacon
= precord_stats
->bPacketBeacon
= bPacketBeacon
;
4975 pstats
->bToSelfBA
= precord_stats
->bToSelfBA
= bToSelfBA
;
4976 /*2007.08.30 requested by SD3 Jerry */
4977 if (priv
->phy_check_reg824
== 0)
4979 priv
->phy_reg824_bit9
= rtl8192_QueryBBReg(priv
->ieee80211
->dev
, rFPGA0_XA_HSSIParameter2
, 0x200);
4980 priv
->phy_check_reg824
= 1;
4984 prxpkt
= (u8
*)pdrvinfo
;
4986 /* Move pointer to the 16th bytes. Phy status start address. */
4987 prxpkt
+= sizeof(rx_fwinfo_819x_pci
);
4989 /* Initial the cck and ofdm buffer pointer */
4990 pcck_buf
= (phy_sts_cck_819xpci_t
*)prxpkt
;
4991 pofdm_buf
= (phy_sts_ofdm_819xpci_t
*)prxpkt
;
4993 pstats
->RxMIMOSignalQuality
[0] = -1;
4994 pstats
->RxMIMOSignalQuality
[1] = -1;
4995 precord_stats
->RxMIMOSignalQuality
[0] = -1;
4996 precord_stats
->RxMIMOSignalQuality
[1] = -1;
5001 // (1)Hardware does not provide RSSI for CCK
5005 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5007 u8 report
;//, cck_agc_rpt;
5010 char cck_adc_pwdb
[4];
5013 #ifdef RTL8190P //Only 90P 2T4R need to check
5014 if(priv
->rf_type
== RF_2T4R
&& DM_RxPathSelTable
.Enable
&& bpacket_match_bssid
)
5016 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
5018 tmp_pwdb
= pcck_buf
->adc_pwdb_X
[i
];
5019 cck_adc_pwdb
[i
] = (char)tmp_pwdb
;
5020 cck_adc_pwdb
[i
] /= 2;
5021 pstats
->cck_adc_pwdb
[i
] = precord_stats
->cck_adc_pwdb
[i
] = cck_adc_pwdb
[i
];
5026 if (!priv
->phy_reg824_bit9
)
5028 report
= pcck_buf
->cck_agc_rpt
& 0xc0;
5032 //Fixed by Jacken from Bryant 2008-03-20
5033 //Original value is -38 , -26 , -14 , -2
5034 //Fixed value is -35 , -23 , -11 , 6
5036 rx_pwr_all
= -35 - (pcck_buf
->cck_agc_rpt
& 0x3e);
5039 rx_pwr_all
= -23 - (pcck_buf
->cck_agc_rpt
& 0x3e);
5042 rx_pwr_all
= -11 - (pcck_buf
->cck_agc_rpt
& 0x3e);
5045 rx_pwr_all
= 8 - (pcck_buf
->cck_agc_rpt
& 0x3e);
5051 report
= pcck_buf
->cck_agc_rpt
& 0x60;
5056 rx_pwr_all
= -35 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1) ;
5059 rx_pwr_all
= -23 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1);
5062 rx_pwr_all
= -11 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1) ;
5065 rx_pwr_all
= -8 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1) ;
5070 pwdb_all
= rtl819x_query_rxpwrpercentage(rx_pwr_all
);
5071 pstats
->RxPWDBAll
= precord_stats
->RxPWDBAll
= pwdb_all
;
5072 pstats
->RecvSignalPower
= rx_pwr_all
;
5075 // (3) Get Signal Quality (EVM)
5077 if(bpacket_match_bssid
)
5081 if(pstats
->RxPWDBAll
> 40)
5086 sq
= pcck_buf
->sq_rpt
;
5088 if(pcck_buf
->sq_rpt
> 64)
5090 else if (pcck_buf
->sq_rpt
< 20)
5093 sq
= ((64-sq
) * 100) / 44;
5095 pstats
->SignalQuality
= precord_stats
->SignalQuality
= sq
;
5096 pstats
->RxMIMOSignalQuality
[0] = precord_stats
->RxMIMOSignalQuality
[0] = sq
;
5097 pstats
->RxMIMOSignalQuality
[1] = precord_stats
->RxMIMOSignalQuality
[1] = -1;
5103 // (1)Get RSSI for HT rate
5105 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
5107 // 2008/01/30 MH we will judge RF RX path now.
5108 if (priv
->brfpath_rxenable
[i
])
5113 //Fixed by Jacken from Bryant 2008-03-20
5114 //Original value is 106
5115 #ifdef RTL8190P //Modify by Jacken 2008/03/31
5116 rx_pwr
[i
] = ((pofdm_buf
->trsw_gain_X
[i
]&0x3F)*2) - 106;
5118 rx_pwr
[i
] = ((pofdm_buf
->trsw_gain_X
[i
]&0x3F)*2) - 110;
5121 //Get Rx snr value in DB
5122 tmp_rxsnr
= pofdm_buf
->rxsnr_X
[i
];
5123 rx_snrX
= (char)(tmp_rxsnr
);
5126 /* Translate DBM to percentage. */
5127 RSSI
= rtl819x_query_rxpwrpercentage(rx_pwr
[i
]);
5128 if (priv
->brfpath_rxenable
[i
])
5131 /* Record Signal Strength for next packet */
5132 if(bpacket_match_bssid
)
5134 pstats
->RxMIMOSignalStrength
[i
] =(u8
) RSSI
;
5135 precord_stats
->RxMIMOSignalStrength
[i
] =(u8
) RSSI
;
5141 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5143 //Fixed by Jacken from Bryant 2008-03-20
5144 //Original value is 106
5145 rx_pwr_all
= (((pofdm_buf
->pwdb_all
) >> 1 )& 0x7f) -106;
5146 pwdb_all
= rtl819x_query_rxpwrpercentage(rx_pwr_all
);
5148 pstats
->RxPWDBAll
= precord_stats
->RxPWDBAll
= pwdb_all
;
5149 pstats
->RxPower
= precord_stats
->RxPower
= rx_pwr_all
;
5150 pstats
->RecvSignalPower
= rx_pwr_all
;
5152 // (3)EVM of HT rate
5154 if(pdrvinfo
->RxHT
&& pdrvinfo
->RxRate
>=DESC90_RATEMCS8
&&
5155 pdrvinfo
->RxRate
<=DESC90_RATEMCS15
)
5156 max_spatial_stream
= 2; //both spatial stream make sense
5158 max_spatial_stream
= 1; //only spatial stream 1 makes sense
5160 for(i
=0; i
<max_spatial_stream
; i
++)
5162 tmp_rxevm
= pofdm_buf
->rxevm_X
[i
];
5163 rx_evmX
= (char)(tmp_rxevm
);
5165 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5166 // fill most significant bit to "zero" when doing shifting operation which may change a negative
5167 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5170 evm
= rtl819x_evm_dbtopercentage(rx_evmX
);
5171 if(bpacket_match_bssid
)
5173 if(i
==0) // Fill value in RFD, Get the first spatial stream only
5174 pstats
->SignalQuality
= precord_stats
->SignalQuality
= (u8
)(evm
& 0xff);
5175 pstats
->RxMIMOSignalQuality
[i
] = precord_stats
->RxMIMOSignalQuality
[i
] = (u8
)(evm
& 0xff);
5180 /* record rx statistics for debug */
5181 rxsc_sgien_exflg
= pofdm_buf
->rxsc_sgien_exflg
;
5182 prxsc
= (phy_ofdm_rx_status_rxsc_sgien_exintfflag
*)&rxsc_sgien_exflg
;
5185 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5186 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5189 pstats
->SignalStrength
= precord_stats
->SignalStrength
= (u8
)(rtl819x_signal_scale_mapping((long)pwdb_all
));//PWDB_ALL;
5194 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u1Byte)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u1Byte)(total_rssi/=RF90_PATH_MAX);
5195 // We can judge RX path number now.
5197 pstats
->SignalStrength
= precord_stats
->SignalStrength
= (u8
)(rtl819x_signal_scale_mapping((long)(total_rssi
/=rf_rx_num
)));
5202 rtl8192_record_rxdesc_forlateruse(
5203 struct ieee80211_rx_stats
* psrc_stats
,
5204 struct ieee80211_rx_stats
* ptarget_stats
5207 ptarget_stats
->bIsAMPDU
= psrc_stats
->bIsAMPDU
;
5208 ptarget_stats
->bFirstMPDU
= psrc_stats
->bFirstMPDU
;
5209 //ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5214 static void TranslateRxSignalStuff819xpci(struct net_device
*dev
,
5215 struct sk_buff
*skb
,
5216 struct ieee80211_rx_stats
* pstats
,
5217 prx_desc_819x_pci pdesc
,
5218 prx_fwinfo_819x_pci pdrvinfo
)
5220 // TODO: We must only check packet for current MAC address. Not finish
5221 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5222 bool bpacket_match_bssid
, bpacket_toself
;
5223 bool bPacketBeacon
=false, bToSelfBA
=false;
5224 struct ieee80211_hdr_3addr
*hdr
;
5227 // Get Signal Quality for only RX data queue (but not command queue)
5232 /* Get MAC frame start address. */
5233 tmp_buf
= skb
->data
;
5235 hdr
= (struct ieee80211_hdr_3addr
*)tmp_buf
;
5236 fc
= le16_to_cpu(hdr
->frame_ctl
);
5237 type
= WLAN_FC_GET_TYPE(fc
);
5238 praddr
= hdr
->addr1
;
5240 /* Check if the received packet is acceptabe. */
5241 bpacket_match_bssid
= ((IEEE80211_FTYPE_CTL
!= type
) &&
5242 (!compare_ether_addr(priv
->ieee80211
->current_network
.bssid
, (fc
& IEEE80211_FCTL_TODS
)? hdr
->addr1
: (fc
& IEEE80211_FCTL_FROMDS
)? hdr
->addr2
: hdr
->addr3
))
5243 && (!pstats
->bHwError
) && (!pstats
->bCRC
)&& (!pstats
->bICV
));
5244 bpacket_toself
= bpacket_match_bssid
& (!compare_ether_addr(praddr
, priv
->ieee80211
->dev
->dev_addr
));
5246 if(WLAN_FC_GET_FRAMETYPE(fc
)== IEEE80211_STYPE_BEACON
)
5248 bPacketBeacon
= true;
5250 if(WLAN_FC_GET_FRAMETYPE(fc
) == IEEE80211_STYPE_BLOCKACK
)
5252 if((!compare_ether_addr(praddr
,dev
->dev_addr
)))
5257 // Process PHY information for previous packet (RSSI/PWDB/EVM)
5259 // Because phy information is contained in the last packet of AMPDU only, so driver
5260 // should process phy information of previous packet
5261 rtl8192_process_phyinfo(priv
, tmp_buf
, &priv
->previous_stats
, pstats
);
5262 rtl8192_query_rxphystatus(priv
, pstats
, pdesc
, pdrvinfo
, &priv
->previous_stats
, bpacket_match_bssid
,
5263 bpacket_toself
,bPacketBeacon
, bToSelfBA
);
5264 rtl8192_record_rxdesc_forlateruse(pstats
, &priv
->previous_stats
);
5269 static void rtl8192_tx_resume(struct net_device
*dev
)
5271 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5272 struct ieee80211_device
*ieee
= priv
->ieee80211
;
5273 struct sk_buff
*skb
;
5276 for(queue_index
= BK_QUEUE
; queue_index
< TXCMD_QUEUE
;queue_index
++) {
5277 while((!skb_queue_empty(&ieee
->skb_waitQ
[queue_index
]))&&
5278 (priv
->ieee80211
->check_nic_enough_desc(dev
,queue_index
) > 0)) {
5279 /* 1. dequeue the packet from the wait queue */
5280 skb
= skb_dequeue(&ieee
->skb_waitQ
[queue_index
]);
5281 /* 2. tx the packet directly */
5282 ieee
->softmac_data_hard_start_xmit(skb
,dev
,0/* rate useless now*/);
5287 static void rtl8192_irq_tx_tasklet(struct r8192_priv
*priv
)
5289 rtl8192_tx_resume(priv
->ieee80211
->dev
);
5292 /* Record the received data rate */
5293 static void UpdateReceivedRateHistogramStatistics8190(
5294 struct net_device
*dev
,
5295 struct ieee80211_rx_stats
* pstats
5298 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5299 u32 rcvType
=1; //0: Total, 1:OK, 2:CRC, 3:ICV
5301 u32 preamble_guardinterval
; //1: short preamble/GI, 0: long preamble/GI
5305 else if(pstats
->bICV
)
5308 if(pstats
->bShortPreamble
)
5309 preamble_guardinterval
= 1;// short
5311 preamble_guardinterval
= 0;// long
5313 switch(pstats
->rate
)
5318 case MGN_1M
: rateIndex
= 0; break;
5319 case MGN_2M
: rateIndex
= 1; break;
5320 case MGN_5_5M
: rateIndex
= 2; break;
5321 case MGN_11M
: rateIndex
= 3; break;
5325 case MGN_6M
: rateIndex
= 4; break;
5326 case MGN_9M
: rateIndex
= 5; break;
5327 case MGN_12M
: rateIndex
= 6; break;
5328 case MGN_18M
: rateIndex
= 7; break;
5329 case MGN_24M
: rateIndex
= 8; break;
5330 case MGN_36M
: rateIndex
= 9; break;
5331 case MGN_48M
: rateIndex
= 10; break;
5332 case MGN_54M
: rateIndex
= 11; break;
5334 // 11n High throughput rate
5336 case MGN_MCS0
: rateIndex
= 12; break;
5337 case MGN_MCS1
: rateIndex
= 13; break;
5338 case MGN_MCS2
: rateIndex
= 14; break;
5339 case MGN_MCS3
: rateIndex
= 15; break;
5340 case MGN_MCS4
: rateIndex
= 16; break;
5341 case MGN_MCS5
: rateIndex
= 17; break;
5342 case MGN_MCS6
: rateIndex
= 18; break;
5343 case MGN_MCS7
: rateIndex
= 19; break;
5344 case MGN_MCS8
: rateIndex
= 20; break;
5345 case MGN_MCS9
: rateIndex
= 21; break;
5346 case MGN_MCS10
: rateIndex
= 22; break;
5347 case MGN_MCS11
: rateIndex
= 23; break;
5348 case MGN_MCS12
: rateIndex
= 24; break;
5349 case MGN_MCS13
: rateIndex
= 25; break;
5350 case MGN_MCS14
: rateIndex
= 26; break;
5351 case MGN_MCS15
: rateIndex
= 27; break;
5352 default: rateIndex
= 28; break;
5354 priv
->stats
.received_rate_histogram
[0][rateIndex
]++; //total
5355 priv
->stats
.received_rate_histogram
[rcvType
][rateIndex
]++;
5358 static void rtl8192_rx(struct net_device
*dev
)
5360 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5361 struct ieee80211_hdr_1addr
*ieee80211_hdr
= NULL
;
5362 bool unicast_packet
= false;
5363 struct ieee80211_rx_stats stats
= {
5367 .freq
= IEEE80211_24GHZ_BAND
,
5369 unsigned int count
= priv
->rxringcount
;
5372 rx_desc_819x_pci
*pdesc
= &priv
->rx_ring
[priv
->rx_idx
];//rx descriptor
5373 struct sk_buff
*skb
= priv
->rx_buf
[priv
->rx_idx
];//rx pkt
5376 /* wait data to be filled by hardware */
5379 stats
.bICV
= pdesc
->ICV
;
5380 stats
.bCRC
= pdesc
->CRC32
;
5381 stats
.bHwError
= pdesc
->CRC32
| pdesc
->ICV
;
5383 stats
.Length
= pdesc
->Length
;
5384 if(stats
.Length
< 24)
5385 stats
.bHwError
|= 1;
5387 if(stats
.bHwError
) {
5388 stats
.bShift
= false;
5391 prx_fwinfo_819x_pci pDrvInfo
= NULL
;
5392 struct sk_buff
*new_skb
= dev_alloc_skb(priv
->rxbuffersize
);
5394 if (unlikely(!new_skb
)) {
5398 stats
.RxDrvInfoSize
= pdesc
->RxDrvInfoSize
;
5399 stats
.RxBufShift
= ((pdesc
->Shift
)&0x03);
5400 stats
.Decrypted
= !pdesc
->SWDec
;
5402 pci_dma_sync_single_for_cpu(priv
->pdev
,
5403 *((dma_addr_t
*)skb
->cb
),
5405 PCI_DMA_FROMDEVICE
);
5406 skb_put(skb
, pdesc
->Length
);
5407 pDrvInfo
= (rx_fwinfo_819x_pci
*)(skb
->data
+ stats
.RxBufShift
);
5408 skb_reserve(skb
, stats
.RxDrvInfoSize
+ stats
.RxBufShift
);
5410 stats
.rate
= HwRateToMRate90((bool)pDrvInfo
->RxHT
, (u8
)pDrvInfo
->RxRate
);
5411 stats
.bShortPreamble
= pDrvInfo
->SPLCP
;
5413 /* it is debug only. It should be disabled in released driver.
5414 * 2007.1.11 by Emily
5416 UpdateReceivedRateHistogramStatistics8190(dev
, &stats
);
5418 stats
.bIsAMPDU
= (pDrvInfo
->PartAggr
==1);
5419 stats
.bFirstMPDU
= (pDrvInfo
->PartAggr
==1) && (pDrvInfo
->FirstAGGR
==1);
5421 stats
.TimeStampLow
= pDrvInfo
->TSFL
;
5422 stats
.TimeStampHigh
= read_nic_dword(dev
, TSFR
+4);
5424 UpdateRxPktTimeStamp8190(dev
, &stats
);
5427 // Get Total offset of MPDU Frame Body
5429 if((stats
.RxBufShift
+ stats
.RxDrvInfoSize
) > 0)
5432 stats
.RxIs40MHzPacket
= pDrvInfo
->BW
;
5435 TranslateRxSignalStuff819xpci(dev
,skb
, &stats
, pdesc
, pDrvInfo
);
5438 if(pDrvInfo
->FirstAGGR
==1 || pDrvInfo
->PartAggr
== 1)
5439 RT_TRACE(COMP_RXDESC
, "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
5440 pDrvInfo
->FirstAGGR
, pDrvInfo
->PartAggr
);
5441 skb_trim(skb
, skb
->len
- 4/*sCrcLng*/);
5442 /* rx packets statistics */
5443 ieee80211_hdr
= (struct ieee80211_hdr_1addr
*)skb
->data
;
5444 unicast_packet
= false;
5446 if(is_broadcast_ether_addr(ieee80211_hdr
->addr1
)) {
5448 }else if(is_multicast_ether_addr(ieee80211_hdr
->addr1
)){
5451 /* unicast packet */
5452 unicast_packet
= true;
5455 stats
.packetlength
= stats
.Length
-4;
5456 stats
.fraglength
= stats
.packetlength
;
5457 stats
.fragoffset
= 0;
5458 stats
.ntotalfrag
= 1;
5460 if(!ieee80211_rtl_rx(priv
->ieee80211
, skb
, &stats
)){
5461 dev_kfree_skb_any(skb
);
5464 if(unicast_packet
) {
5465 priv
->stats
.rxbytesunicast
+= skb
->len
;
5469 pci_unmap_single(priv
->pdev
, *((dma_addr_t
*) skb
->cb
),
5470 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
5473 priv
->rx_buf
[priv
->rx_idx
] = skb
;
5474 *((dma_addr_t
*) skb
->cb
) = pci_map_single(priv
->pdev
, skb_tail_pointer(skb
), priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
5479 pdesc
->BufferAddress
= cpu_to_le32(*((dma_addr_t
*)skb
->cb
));
5481 pdesc
->Length
= priv
->rxbuffersize
;
5482 if (priv
->rx_idx
== priv
->rxringcount
-1)
5484 priv
->rx_idx
= (priv
->rx_idx
+ 1) % priv
->rxringcount
;
5489 static void rtl8192_irq_rx_tasklet(struct r8192_priv
*priv
)
5491 rtl8192_rx(priv
->ieee80211
->dev
);
5493 write_nic_dword(priv
->ieee80211
->dev
, INTA_MASK
,read_nic_dword(priv
->ieee80211
->dev
, INTA_MASK
) | IMR_RDU
);
5496 static const struct net_device_ops rtl8192_netdev_ops
= {
5497 .ndo_open
= rtl8192_open
,
5498 .ndo_stop
= rtl8192_close
,
5499 .ndo_tx_timeout
= tx_timeout
,
5500 .ndo_do_ioctl
= rtl8192_ioctl
,
5501 .ndo_set_multicast_list
= r8192_set_multicast
,
5502 .ndo_set_mac_address
= r8192_set_mac_adr
,
5503 .ndo_start_xmit
= ieee80211_rtl_xmit
,
5506 static int __devinit
rtl8192_pci_probe(struct pci_dev
*pdev
,
5507 const struct pci_device_id
*id
)
5509 unsigned long ioaddr
= 0;
5510 struct net_device
*dev
= NULL
;
5511 struct r8192_priv
*priv
= NULL
;
5515 #ifdef CONFIG_RTL8192_IO_MAP
5516 unsigned long pio_start
, pio_len
, pio_flags
;
5518 unsigned long pmem_start
, pmem_len
, pmem_flags
;
5519 #endif //end #ifdef RTL_IO_MAP
5521 RT_TRACE(COMP_INIT
,"Configuring chip resources");
5523 if( pci_enable_device (pdev
) ){
5524 RT_TRACE(COMP_ERR
,"Failed to enable PCI device");
5528 pci_set_master(pdev
);
5529 //pci_set_wmi(pdev);
5530 pci_set_dma_mask(pdev
, 0xffffff00ULL
);
5531 pci_set_consistent_dma_mask(pdev
,0xffffff00ULL
);
5532 dev
= alloc_ieee80211(sizeof(struct r8192_priv
));
5538 pci_set_drvdata(pdev
, dev
);
5539 SET_NETDEV_DEV(dev
, &pdev
->dev
);
5540 priv
= ieee80211_priv(dev
);
5541 priv
->ieee80211
= netdev_priv(dev
);
5543 if((pdev
->subsystem_vendor
== PCI_VENDOR_ID_DLINK
)&&(pdev
->subsystem_device
== 0x3304)){
5544 priv
->ieee80211
->bSupportRemoteWakeUp
= 1;
5547 priv
->ieee80211
->bSupportRemoteWakeUp
= 0;
5550 #ifdef CONFIG_RTL8192_IO_MAP
5552 pio_start
= (unsigned long)pci_resource_start (pdev
, 0);
5553 pio_len
= (unsigned long)pci_resource_len (pdev
, 0);
5554 pio_flags
= (unsigned long)pci_resource_flags (pdev
, 0);
5556 if (!(pio_flags
& IORESOURCE_IO
)) {
5557 RT_TRACE(COMP_ERR
,"region #0 not a PIO resource, aborting");
5561 //DMESG("IO space @ 0x%08lx", pio_start );
5562 if( ! request_region( pio_start
, pio_len
, RTL819xE_MODULE_NAME
) ){
5563 RT_TRACE(COMP_ERR
,"request_region failed!");
5568 dev
->base_addr
= ioaddr
; // device I/O address
5572 pmem_start
= pci_resource_start(pdev
, 1);
5573 pmem_len
= pci_resource_len(pdev
, 1);
5574 pmem_flags
= pci_resource_flags (pdev
, 1);
5576 if (!(pmem_flags
& IORESOURCE_MEM
)) {
5577 RT_TRACE(COMP_ERR
,"region #1 not a MMIO resource, aborting");
5581 //DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
5582 if( ! request_mem_region(pmem_start
, pmem_len
, RTL819xE_MODULE_NAME
)) {
5583 RT_TRACE(COMP_ERR
,"request_mem_region failed!");
5588 ioaddr
= (unsigned long)ioremap_nocache( pmem_start
, pmem_len
);
5589 if( ioaddr
== (unsigned long)NULL
){
5590 RT_TRACE(COMP_ERR
,"ioremap failed!");
5591 // release_mem_region( pmem_start, pmem_len );
5595 dev
->mem_start
= ioaddr
; // shared mem start
5596 dev
->mem_end
= ioaddr
+ pci_resource_len(pdev
, 0); // shared mem end
5598 #endif //end #ifdef RTL_IO_MAP
5600 /* We disable the RETRY_TIMEOUT register (0x41) to keep
5601 * PCI Tx retries from interfering with C3 CPU state */
5602 pci_write_config_byte(pdev
, 0x41, 0x00);
5605 pci_read_config_byte(pdev
, 0x05, &unit
);
5606 pci_write_config_byte(pdev
, 0x05, unit
& (~0x04));
5608 dev
->irq
= pdev
->irq
;
5611 dev
->netdev_ops
= &rtl8192_netdev_ops
;
5613 dev
->wireless_handlers
= &r8192_wx_handlers_def
;
5614 dev
->type
=ARPHRD_ETHER
;
5616 dev
->watchdog_timeo
= HZ
*3;
5618 if (dev_alloc_name(dev
, ifname
) < 0){
5619 RT_TRACE(COMP_INIT
, "Oops: devname already taken! Trying wlan%%d...\n");
5620 strcpy(ifname
, "wlan%d");
5621 dev_alloc_name(dev
, ifname
);
5624 RT_TRACE(COMP_INIT
, "Driver probe completed1\n");
5625 if(rtl8192_init(dev
)!=0){
5626 RT_TRACE(COMP_ERR
, "Initialization failed");
5630 register_netdev(dev
);
5631 RT_TRACE(COMP_INIT
, "dev name=======> %s\n",dev
->name
);
5632 rtl8192_proc_init_one(dev
);
5635 RT_TRACE(COMP_INIT
, "Driver probe completed\n");
5640 #ifdef CONFIG_RTL8180_IO_MAP
5642 if( dev
->base_addr
!= 0 ){
5644 release_region(dev
->base_addr
,
5645 pci_resource_len(pdev
, 0) );
5648 if( dev
->mem_start
!= (unsigned long)NULL
){
5649 iounmap( (void *)dev
->mem_start
);
5650 release_mem_region( pci_resource_start(pdev
, 1),
5651 pci_resource_len(pdev
, 1) );
5653 #endif //end #ifdef RTL_IO_MAP
5659 free_irq(dev
->irq
, dev
);
5662 free_ieee80211(dev
);
5666 pci_disable_device(pdev
);
5668 DMESG("wlan driver load failed\n");
5669 pci_set_drvdata(pdev
, NULL
);
5674 /* detach all the work and timer structure declared or inititialized
5675 * in r8192_init function.
5677 static void rtl8192_cancel_deferred_work(struct r8192_priv
* priv
)
5679 /* call cancel_work_sync instead of cancel_delayed_work if and only if Linux_version_code
5680 * is or is newer than 2.6.20 and work structure is defined to be struct work_struct.
5681 * Otherwise call cancel_delayed_work is enough.
5682 * FIXME (2.6.20 should 2.6.22, work_struct should not cancel)
5684 cancel_delayed_work(&priv
->watch_dog_wq
);
5685 cancel_delayed_work(&priv
->update_beacon_wq
);
5686 cancel_delayed_work(&priv
->ieee80211
->hw_wakeup_wq
);
5687 cancel_delayed_work(&priv
->ieee80211
->hw_sleep_wq
);
5689 cancel_delayed_work(&priv
->gpio_change_rf_wq
);
5691 cancel_work_sync(&priv
->reset_wq
);
5692 cancel_work_sync(&priv
->qos_activate
);
5693 //cancel_work_sync(&priv->SetBWModeWorkItem);
5694 //cancel_work_sync(&priv->SwChnlWorkItem);
5699 static void __devexit
rtl8192_pci_disconnect(struct pci_dev
*pdev
)
5701 struct net_device
*dev
= pci_get_drvdata(pdev
);
5702 struct r8192_priv
*priv
;
5706 unregister_netdev(dev
);
5708 priv
=ieee80211_priv(dev
);
5710 rtl8192_proc_remove_one(dev
);
5713 if (priv
->pFirmware
)
5715 vfree(priv
->pFirmware
);
5716 priv
->pFirmware
= NULL
;
5718 // priv->rf_close(dev);
5719 // rtl8192_usb_deleteendpoints(dev);
5720 destroy_workqueue(priv
->priv_wq
);
5721 /* redundant with rtl8192_down */
5722 // rtl8192_irq_disable(dev);
5723 // rtl8192_reset(dev);
5727 /* free tx/rx rings */
5728 rtl8192_free_rx_ring(dev
);
5729 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
5730 rtl8192_free_tx_ring(dev
, i
);
5735 printk("Freeing irq %d\n",dev
->irq
);
5736 free_irq(dev
->irq
, dev
);
5741 #ifdef CONFIG_RTL8180_IO_MAP
5743 if( dev
->base_addr
!= 0 ){
5745 release_region(dev
->base_addr
,
5746 pci_resource_len(pdev
, 0) );
5749 if( dev
->mem_start
!= (unsigned long)NULL
){
5750 iounmap( (void *)dev
->mem_start
);
5751 release_mem_region( pci_resource_start(pdev
, 1),
5752 pci_resource_len(pdev
, 1) );
5754 #endif /*end #ifdef RTL_IO_MAP*/
5755 free_ieee80211(dev
);
5759 pci_disable_device(pdev
);
5760 RT_TRACE(COMP_DOWN
, "wlan driver removed\n");
5763 extern int ieee80211_rtl_init(void);
5764 extern void ieee80211_rtl_exit(void);
5766 static int __init
rtl8192_pci_module_init(void)
5770 retval
= ieee80211_rtl_init();
5774 printk(KERN_INFO
"\nLinux kernel driver for RTL8192 based WLAN cards\n");
5775 printk(KERN_INFO
"Copyright (c) 2007-2008, Realsil Wlan\n");
5776 RT_TRACE(COMP_INIT
, "Initializing module");
5777 rtl8192_proc_module_init();
5778 if(0!=pci_register_driver(&rtl8192_pci_driver
))
5780 DMESG("No device found");
5781 /*pci_unregister_driver (&rtl8192_pci_driver);*/
5788 static void __exit
rtl8192_pci_module_exit(void)
5790 pci_unregister_driver(&rtl8192_pci_driver
);
5792 RT_TRACE(COMP_DOWN
, "Exiting");
5793 rtl8192_proc_module_remove();
5794 ieee80211_rtl_exit();
5797 static irqreturn_t
rtl8192_interrupt(int irq
, void *netdev
)
5799 struct net_device
*dev
= (struct net_device
*) netdev
;
5800 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5801 unsigned long flags
;
5803 irqreturn_t ret
= IRQ_HANDLED
;
5805 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
5807 /* We should return IRQ_NONE, but for now let me keep this */
5808 if (priv
->irq_enabled
== 0)
5813 inta
= read_nic_dword(dev
, ISR
); /* & priv->IntrMask; */
5814 write_nic_dword(dev
, ISR
, inta
); /* reset int situation */
5818 * most probably we can safely return IRQ_NONE,
5819 * but for now is better to avoid problems
5824 if (inta
== 0xffff) {
5829 if (!netif_running(dev
))
5832 if (inta
& IMR_TBDOK
) {
5833 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
5834 rtl8192_tx_isr(dev
, BEACON_QUEUE
);
5835 priv
->stats
.txbeaconokint
++;
5838 if (inta
& IMR_TBDER
) {
5839 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
5840 rtl8192_tx_isr(dev
, BEACON_QUEUE
);
5841 priv
->stats
.txbeaconerr
++;
5844 if (inta
& IMR_MGNTDOK
) {
5845 RT_TRACE(COMP_INTR
, "Manage ok interrupt!\n");
5846 priv
->stats
.txmanageokint
++;
5847 rtl8192_tx_isr(dev
,MGNT_QUEUE
);
5850 if (inta
& IMR_COMDOK
)
5852 priv
->stats
.txcmdpktokint
++;
5853 rtl8192_tx_isr(dev
, TXCMD_QUEUE
);
5856 if (inta
& IMR_ROK
) {
5857 priv
->stats
.rxint
++;
5858 tasklet_schedule(&priv
->irq_rx_tasklet
);
5861 if (inta
& IMR_BcnInt
) {
5862 RT_TRACE(COMP_INTR
, "prepare beacon for interrupt!\n");
5863 tasklet_schedule(&priv
->irq_prepare_beacon_tasklet
);
5866 if (inta
& IMR_RDU
) {
5867 RT_TRACE(COMP_INTR
, "rx descriptor unavailable!\n");
5868 priv
->stats
.rxrdu
++;
5869 /* reset int situation */
5870 write_nic_dword(dev
, INTA_MASK
, read_nic_dword(dev
, INTA_MASK
) & ~IMR_RDU
);
5871 tasklet_schedule(&priv
->irq_rx_tasklet
);
5874 if (inta
& IMR_RXFOVW
) {
5875 RT_TRACE(COMP_INTR
, "rx overflow !\n");
5876 priv
->stats
.rxoverflow
++;
5877 tasklet_schedule(&priv
->irq_rx_tasklet
);
5880 if (inta
& IMR_TXFOVW
)
5881 priv
->stats
.txoverflow
++;
5883 if (inta
& IMR_BKDOK
) {
5884 RT_TRACE(COMP_INTR
, "BK Tx OK interrupt!\n");
5885 priv
->stats
.txbkokint
++;
5886 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
5887 rtl8192_tx_isr(dev
, BK_QUEUE
);
5890 if (inta
& IMR_BEDOK
) {
5891 RT_TRACE(COMP_INTR
, "BE TX OK interrupt!\n");
5892 priv
->stats
.txbeokint
++;
5893 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
5894 rtl8192_tx_isr(dev
, BE_QUEUE
);
5897 if (inta
& IMR_VIDOK
) {
5898 RT_TRACE(COMP_INTR
, "VI TX OK interrupt!\n");
5899 priv
->stats
.txviokint
++;
5900 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
5901 rtl8192_tx_isr(dev
, VI_QUEUE
);
5904 if (inta
& IMR_VODOK
) {
5905 priv
->stats
.txvookint
++;
5906 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
5907 rtl8192_tx_isr(dev
, VO_QUEUE
);
5911 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
5916 void EnableHWSecurityConfig8192(struct net_device
*dev
)
5918 u8 SECR_value
= 0x0;
5919 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5920 struct ieee80211_device
* ieee
= priv
->ieee80211
;
5922 SECR_value
= SCR_TxEncEnable
| SCR_RxDecEnable
;
5924 if (((KEY_TYPE_WEP40
== ieee
->pairwise_key_type
) || (KEY_TYPE_WEP104
== ieee
->pairwise_key_type
)) && (priv
->ieee80211
->auth_mode
!= 2))
5926 SECR_value
|= SCR_RxUseDK
;
5927 SECR_value
|= SCR_TxUseDK
;
5929 else if ((ieee
->iw_mode
== IW_MODE_ADHOC
) && (ieee
->pairwise_key_type
& (KEY_TYPE_CCMP
| KEY_TYPE_TKIP
)))
5931 SECR_value
|= SCR_RxUseDK
;
5932 SECR_value
|= SCR_TxUseDK
;
5935 //add HWSec active enable here.
5936 //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
5937 ieee
->hwsec_active
= 1;
5939 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
5941 ieee
->hwsec_active
= 0;
5942 SECR_value
&= ~SCR_RxDecEnable
;
5945 RT_TRACE(COMP_SEC
,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__
,
5946 ieee
->hwsec_active
, ieee
->pairwise_key_type
, SECR_value
);
5948 write_nic_byte(dev
, SECR
, SECR_value
);//SECR_value | SCR_UseDK );
5952 #define TOTAL_CAM_ENTRY 32
5953 //#define CAM_CONTENT_COUNT 8
5954 void setKey( struct net_device
*dev
,
5962 u32 TargetCommand
= 0;
5963 u32 TargetContent
= 0;
5967 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5968 RT_RF_POWER_STATE rtState
;
5969 rtState
= priv
->ieee80211
->eRFPowerState
;
5970 if(priv
->ieee80211
->PowerSaveControl
.bInactivePs
){
5971 if(rtState
== eRfOff
){
5972 if(priv
->ieee80211
->RfOffReason
> RF_CHANGE_BY_IPS
)
5974 RT_TRACE(COMP_ERR
, "%s(): RF is OFF.\n",__FUNCTION__
);
5975 //up(&priv->wx_sem);
5979 down(&priv
->ieee80211
->ips_sem
);
5981 up(&priv
->ieee80211
->ips_sem
);
5985 priv
->ieee80211
->is_set_key
= true;
5987 if (EntryNo
>= TOTAL_CAM_ENTRY
)
5988 RT_TRACE(COMP_ERR
, "cam entry exceeds in setKey()\n");
5990 RT_TRACE(COMP_SEC
, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev
,EntryNo
, KeyIndex
, KeyType
, MacAddr
);
5993 usConfig
|= BIT15
| (KeyType
<<2);
5995 usConfig
|= BIT15
| (KeyType
<<2) | KeyIndex
;
5996 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
5999 for(i
=0 ; i
<CAM_CONTENT_COUNT
; i
++){
6000 TargetCommand
= i
+CAM_CONTENT_COUNT
*EntryNo
;
6001 TargetCommand
|= BIT31
|BIT16
;
6003 if(i
==0){//MAC|Config
6004 TargetContent
= (u32
)(*(MacAddr
+0)) << 16|
6005 (u32
)(*(MacAddr
+1)) << 24|
6008 write_nic_dword(dev
, WCAMI
, TargetContent
);
6009 write_nic_dword(dev
, RWCAM
, TargetCommand
);
6012 TargetContent
= (u32
)(*(MacAddr
+2)) |
6013 (u32
)(*(MacAddr
+3)) << 8|
6014 (u32
)(*(MacAddr
+4)) << 16|
6015 (u32
)(*(MacAddr
+5)) << 24;
6016 write_nic_dword(dev
, WCAMI
, TargetContent
);
6017 write_nic_dword(dev
, RWCAM
, TargetCommand
);
6019 else { //Key Material
6020 if(KeyContent
!= NULL
)
6022 write_nic_dword(dev
, WCAMI
, (u32
)(*(KeyContent
+i
-2)) );
6023 write_nic_dword(dev
, RWCAM
, TargetCommand
);
6027 RT_TRACE(COMP_SEC
,"=========>after set key, usconfig:%x\n", usConfig
);
6030 bool NicIFEnableNIC(struct net_device
* dev
)
6032 RT_STATUS init_status
= RT_STATUS_SUCCESS
;
6033 struct r8192_priv
* priv
= ieee80211_priv(dev
);
6034 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
6038 RT_TRACE(COMP_ERR
, "ERR!!! %s(): Driver is already down!\n",__FUNCTION__
);
6039 priv
->bdisable_nic
= false; //YJ,add,091111
6042 // <1> Reset memory: descriptor, buffer,..
6043 //NicIFResetMemory(Adapter);
6045 // <2> Enable Adapter
6046 //priv->bfirst_init = true;
6047 init_status
= rtl8192_adapter_start(dev
);
6048 if (init_status
!= RT_STATUS_SUCCESS
) {
6049 RT_TRACE(COMP_ERR
,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__
);
6050 priv
->bdisable_nic
= false; //YJ,add,091111
6053 RT_CLEAR_PS_LEVEL(pPSC
, RT_RF_OFF_LEVL_HALT_NIC
);
6054 //priv->bfirst_init = false;
6056 // <3> Enable Interrupt
6057 rtl8192_irq_enable(dev
);
6058 priv
->bdisable_nic
= false;
6060 return (init_status
== RT_STATUS_SUCCESS
);
6063 bool NicIFDisableNIC(struct net_device
* dev
)
6066 struct r8192_priv
* priv
= ieee80211_priv(dev
);
6068 // <1> Disable Interrupt
6070 priv
->bdisable_nic
= true; //YJ,move,091109
6071 tmp_state
= priv
->ieee80211
->state
;
6073 ieee80211_softmac_stop_protocol(priv
->ieee80211
, false);
6075 priv
->ieee80211
->state
= tmp_state
;
6076 rtl8192_cancel_deferred_work(priv
);
6077 rtl8192_irq_disable(dev
);
6078 // <2> Stop all timer
6080 // <3> Disable Adapter
6081 rtl8192_halt_adapter(dev
, false);
6082 // priv->bdisable_nic = true;
6087 module_init(rtl8192_pci_module_init
);
6088 module_exit(rtl8192_pci_module_exit
);