1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 * Linux device driver for 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>
27 //#define CONFIG_RTL8192_IO_MAP
28 #include <linux/vmalloc.h>
29 #include <linux/slab.h>
30 #include <asm/uaccess.h>
31 #include "r8192E_hw.h"
33 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
34 #include "r8180_93cx6.h" /* Card EEPROM */
35 #include "r8192E_wx.h"
36 #include "r819xE_phy.h" //added by WB 4.30.2008
37 #include "r819xE_phyreg.h"
38 #include "r819xE_cmdpkt.h"
39 #include "r8192E_dm.h"
46 #include "ieee80211/dot11d.h"
49 //set here to open your trace code. //WB
50 u32 rt_global_debug_component
= COMP_ERR
; //always open err flags on
52 static DEFINE_PCI_DEVICE_TABLE(rtl8192_pci_id_tbl
) = {
54 { PCI_DEVICE(0x10ec, 0x8192) },
57 { PCI_DEVICE(0x07aa, 0x0044) },
58 { PCI_DEVICE(0x07aa, 0x0047) },
62 static char ifname
[IFNAMSIZ
] = "wlan%d";
63 static int hwwep
= 1; //default use hw. set 0 to use software security
64 static int channels
= 0x3fff;
66 MODULE_LICENSE("GPL");
67 MODULE_VERSION("V 1.1");
68 MODULE_DEVICE_TABLE(pci
, rtl8192_pci_id_tbl
);
69 //MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
70 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
73 module_param_string(ifname
, ifname
, sizeof(ifname
), S_IRUGO
|S_IWUSR
);
74 module_param(hwwep
,int, S_IRUGO
|S_IWUSR
);
75 module_param(channels
,int, S_IRUGO
|S_IWUSR
);
77 MODULE_PARM_DESC(ifname
," Net interface name, wlan%d=default");
78 MODULE_PARM_DESC(hwwep
," Try to use hardware WEP support. Still broken and not available on all cards");
79 MODULE_PARM_DESC(channels
," Channel bitmask for specific locales. NYI");
81 static int __devinit
rtl8192_pci_probe(struct pci_dev
*pdev
,
82 const struct pci_device_id
*id
);
83 static void __devexit
rtl8192_pci_disconnect(struct pci_dev
*pdev
);
85 static struct pci_driver rtl8192_pci_driver
= {
86 .name
= RTL819xE_MODULE_NAME
, /* Driver name */
87 .id_table
= rtl8192_pci_id_tbl
, /* PCI_ID table */
88 .probe
= rtl8192_pci_probe
, /* probe fn */
89 .remove
= __devexit_p(rtl8192_pci_disconnect
), /* remove fn */
91 .suspend
= rtl8192E_suspend
, /* PM suspend fn */
92 .resume
= rtl8192E_resume
, /* PM resume fn */
94 .suspend
= NULL
, /* PM suspend fn */
95 .resume
= NULL
, /* PM resume fn */
99 static void rtl8192_start_beacon(struct net_device
*dev
);
100 static void rtl8192_stop_beacon(struct net_device
*dev
);
101 static void rtl819x_watchdog_wqcallback(struct work_struct
*work
);
102 static void rtl8192_irq_rx_tasklet(unsigned long arg
);
103 static void rtl8192_irq_tx_tasklet(unsigned long arg
);
104 static void rtl8192_prepare_beacon(unsigned long arg
);
105 static irqreturn_t
rtl8192_interrupt(int irq
, void *netdev
);
106 static void rtl819xE_tx_cmd(struct net_device
*dev
, struct sk_buff
*skb
);
107 static void rtl8192_update_ratr_table(struct net_device
* dev
);
108 static void rtl8192_restart(struct work_struct
*work
);
109 static void watch_dog_timer_callback(unsigned long data
);
110 static int _rtl8192_up(struct net_device
*dev
);
111 static void rtl8192_cancel_deferred_work(struct r8192_priv
* priv
);
115 typedef struct _CHANNEL_LIST
119 }CHANNEL_LIST
, *PCHANNEL_LIST
;
121 static const CHANNEL_LIST ChannelPlan
[] = {
122 {{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
123 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
124 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
125 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
126 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
127 {{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
128 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
129 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
130 {{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
131 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
132 {{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
135 static void rtl819x_set_channel_map(u8 channel_plan
, struct r8192_priv
* priv
)
137 int i
, max_chan
=-1, min_chan
=-1;
138 struct ieee80211_device
* ieee
= priv
->ieee80211
;
139 switch (channel_plan
)
141 case COUNTRY_CODE_FCC
:
142 case COUNTRY_CODE_IC
:
143 case COUNTRY_CODE_ETSI
:
144 case COUNTRY_CODE_SPAIN
:
145 case COUNTRY_CODE_FRANCE
:
146 case COUNTRY_CODE_MKK
:
147 case COUNTRY_CODE_MKK1
:
148 case COUNTRY_CODE_ISRAEL
:
149 case COUNTRY_CODE_TELEC
:
150 case COUNTRY_CODE_MIC
:
153 ieee
->bGlobalDomain
= false;
154 //acturally 8225 & 8256 rf chip only support B,G,24N mode
158 if (ChannelPlan
[channel_plan
].Len
!= 0){
159 // Clear old channel map
160 memset(GET_DOT11D_INFO(ieee
)->channel_map
, 0, sizeof(GET_DOT11D_INFO(ieee
)->channel_map
));
161 // Set new channel map
162 for (i
=0;i
<ChannelPlan
[channel_plan
].Len
;i
++)
164 if (ChannelPlan
[channel_plan
].Channel
[i
] < min_chan
|| ChannelPlan
[channel_plan
].Channel
[i
] > max_chan
)
166 GET_DOT11D_INFO(ieee
)->channel_map
[ChannelPlan
[channel_plan
].Channel
[i
]] = 1;
171 case COUNTRY_CODE_GLOBAL_DOMAIN
:
173 GET_DOT11D_INFO(ieee
)->bEnabled
= 0; //this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain setting
175 ieee
->bGlobalDomain
= true;
184 static inline bool rx_hal_is_cck_rate(prx_fwinfo_819x_pci pdrvinfo
)
186 return (pdrvinfo
->RxRate
== DESC90_RATE1M
||
187 pdrvinfo
->RxRate
== DESC90_RATE2M
||
188 pdrvinfo
->RxRate
== DESC90_RATE5_5M
||
189 pdrvinfo
->RxRate
== DESC90_RATE11M
) &&
193 void CamResetAllEntry(struct net_device
*dev
)
195 struct r8192_priv
* priv
= ieee80211_priv(dev
);
196 write_nic_dword(priv
, RWCAM
, BIT31
|BIT30
);
199 void write_cam(struct r8192_priv
*priv
, u8 addr
, u32 data
)
201 write_nic_dword(priv
, WCAMI
, data
);
202 write_nic_dword(priv
, RWCAM
, BIT31
|BIT16
|(addr
&0xff) );
205 u32
read_cam(struct r8192_priv
*priv
, u8 addr
)
207 write_nic_dword(priv
, RWCAM
, 0x80000000|(addr
&0xff) );
208 return read_nic_dword(priv
, 0xa8);
211 #ifdef CONFIG_RTL8180_IO_MAP
213 u8
read_nic_byte(struct r8192_priv
*priv
, int x
)
215 struct net_device
*dev
= priv
->ieee80211
->dev
;
216 return 0xff&inb(dev
->base_addr
+x
);
219 u32
read_nic_dword(struct r8192_priv
*priv
, int x
)
221 struct net_device
*dev
= priv
->ieee80211
->dev
;
222 return inl(dev
->base_addr
+x
);
225 u16
read_nic_word(struct r8192_priv
*priv
, int x
)
227 struct net_device
*dev
= priv
->ieee80211
->dev
;
228 return inw(dev
->base_addr
+x
);
231 void write_nic_byte(struct r8192_priv
*priv
, int x
,u8 y
)
233 struct net_device
*dev
= priv
->ieee80211
->dev
;
234 outb(y
&0xff,dev
->base_addr
+x
);
237 void write_nic_word(struct r8192_priv
*priv
, int x
,u16 y
)
239 struct net_device
*dev
= priv
->ieee80211
->dev
;
240 outw(y
,dev
->base_addr
+x
);
243 void write_nic_dword(struct r8192_priv
*priv
, int x
,u32 y
)
245 struct net_device
*dev
= priv
->ieee80211
->dev
;
246 outl(y
,dev
->base_addr
+x
);
249 #else /* RTL_IO_MAP */
251 u8
read_nic_byte(struct r8192_priv
*priv
, int x
)
253 struct net_device
*dev
= priv
->ieee80211
->dev
;
254 return 0xff&readb((u8
*)dev
->mem_start
+x
);
257 u32
read_nic_dword(struct r8192_priv
*priv
, int x
)
259 struct net_device
*dev
= priv
->ieee80211
->dev
;
260 return readl((u8
*)dev
->mem_start
+x
);
263 u16
read_nic_word(struct r8192_priv
*priv
, int x
)
265 struct net_device
*dev
= priv
->ieee80211
->dev
;
266 return readw((u8
*)dev
->mem_start
+x
);
269 void write_nic_byte(struct r8192_priv
*priv
, int x
,u8 y
)
271 struct net_device
*dev
= priv
->ieee80211
->dev
;
272 writeb(y
,(u8
*)dev
->mem_start
+x
);
276 void write_nic_dword(struct r8192_priv
*priv
, int x
,u32 y
)
278 struct net_device
*dev
= priv
->ieee80211
->dev
;
279 writel(y
,(u8
*)dev
->mem_start
+x
);
283 void write_nic_word(struct r8192_priv
*priv
, int x
,u16 y
)
285 struct net_device
*dev
= priv
->ieee80211
->dev
;
286 writew(y
,(u8
*)dev
->mem_start
+x
);
290 #endif /* RTL_IO_MAP */
292 u8
rtl8192e_ap_sec_type(struct ieee80211_device
*ieee
)
294 static const u8 ccmp_ie
[4] = {0x00,0x50,0xf2,0x04};
295 static const u8 ccmp_rsn_ie
[4] = {0x00, 0x0f, 0xac, 0x04};
296 int wpa_ie_len
= ieee
->wpa_ie_len
;
297 struct ieee80211_crypt_data
* crypt
;
300 crypt
= ieee
->crypt
[ieee
->tx_keyidx
];
302 encrypt
= (ieee
->current_network
.capability
& WLAN_CAPABILITY_PRIVACY
) ||
303 (ieee
->host_encrypt
&& crypt
&& crypt
->ops
&&
304 (0 == strcmp(crypt
->ops
->name
,"WEP")));
307 if(encrypt
&& (wpa_ie_len
== 0)) {
308 // wep encryption, no N mode setting */
310 } else if((wpa_ie_len
!= 0)) {
311 // parse pairwise key type */
312 if (((ieee
->wpa_ie
[0] == 0xdd) && (!memcmp(&(ieee
->wpa_ie
[14]),ccmp_ie
,4))) ||
313 ((ieee
->wpa_ie
[0] == 0x30) && (!memcmp(&ieee
->wpa_ie
[10],ccmp_rsn_ie
, 4))))
323 rtl8192e_SetHwReg(struct net_device
*dev
,u8 variable
,u8
* val
)
325 struct r8192_priv
* priv
= ieee80211_priv(dev
);
331 write_nic_dword(priv
, BSSIDR
, ((u32
*)(val
))[0]);
332 write_nic_word(priv
, BSSIDR
+2, ((u16
*)(val
+2))[0]);
335 case HW_VAR_MEDIA_STATUS
:
337 RT_OP_MODE OpMode
= *((RT_OP_MODE
*)(val
));
338 u8 btMsr
= read_nic_byte(priv
, MSR
);
344 case RT_OP_MODE_INFRASTRUCTURE
:
348 case RT_OP_MODE_IBSS
:
361 write_nic_byte(priv
, MSR
, btMsr
);
365 case HW_VAR_CHECK_BSSID
:
369 Type
= ((u8
*)(val
))[0];
370 RegRCR
= read_nic_dword(priv
, RCR
);
371 priv
->ReceiveConfig
= RegRCR
;
374 RegRCR
|= (RCR_CBSSID
);
375 else if (Type
== false)
376 RegRCR
&= (~RCR_CBSSID
);
378 write_nic_dword(priv
, RCR
,RegRCR
);
379 priv
->ReceiveConfig
= RegRCR
;
384 case HW_VAR_SLOT_TIME
:
386 priv
->slot_time
= val
[0];
387 write_nic_byte(priv
, SLOT_TIME
, val
[0]);
392 case HW_VAR_ACK_PREAMBLE
:
395 priv
->short_preamble
= (bool)(*(u8
*)val
);
396 regTmp
= priv
->basic_rate
;
397 if (priv
->short_preamble
)
398 regTmp
|= BRSR_AckShortPmb
;
399 write_nic_dword(priv
, RRSR
, regTmp
);
404 write_nic_dword(priv
, CPU_GEN
, ((u32
*)(val
))[0]);
413 static struct proc_dir_entry
*rtl8192_proc
= NULL
;
415 static int proc_get_stats_ap(char *page
, char **start
,
416 off_t offset
, int count
,
417 int *eof
, void *data
)
419 struct net_device
*dev
= data
;
420 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
421 struct ieee80211_device
*ieee
= priv
->ieee80211
;
422 struct ieee80211_network
*target
;
425 list_for_each_entry(target
, &ieee
->network_list
, list
) {
427 len
+= snprintf(page
+ len
, count
- len
,
428 "%s ", target
->ssid
);
430 if(target
->wpa_ie_len
>0 || target
->rsn_ie_len
>0){
431 len
+= snprintf(page
+ len
, count
- len
,
435 len
+= snprintf(page
+ len
, count
- len
,
445 static int proc_get_registers(char *page
, char **start
,
446 off_t offset
, int count
,
447 int *eof
, void *data
)
449 struct net_device
*dev
= data
;
450 struct r8192_priv
*priv
= ieee80211_priv(dev
);
455 /* This dump the current register page */
456 len
+= snprintf(page
+ len
, count
- len
,
457 "\n####################page 0##################\n ");
461 len
+= snprintf(page
+ len
, count
- len
,
464 for(i
=0;i
<16 && n
<=max
;i
++,n
++)
465 len
+= snprintf(page
+ len
, count
- len
,
466 "%2x ",read_nic_byte(priv
,n
));
468 len
+= snprintf(page
+ len
, count
- len
,"\n");
469 len
+= snprintf(page
+ len
, count
- len
,
470 "\n####################page 1##################\n ");
473 len
+= snprintf(page
+ len
, count
- len
,
476 for(i
=0;i
<16 && n
<=max
;i
++,n
++)
477 len
+= snprintf(page
+ len
, count
- len
,
478 "%2x ",read_nic_byte(priv
,0x100|n
));
481 len
+= snprintf(page
+ len
, count
- len
,
482 "\n####################page 3##################\n ");
485 len
+= snprintf(page
+ len
, count
- len
,
488 for(i
=0;i
<16 && n
<=max
;i
++,n
++)
489 len
+= snprintf(page
+ len
, count
- len
,
490 "%2x ",read_nic_byte(priv
,0x300|n
));
498 static int proc_get_stats_tx(char *page
, char **start
,
499 off_t offset
, int count
,
500 int *eof
, void *data
)
502 struct net_device
*dev
= data
;
503 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
507 len
+= snprintf(page
+ len
, count
- len
,
508 "TX VI priority ok int: %lu\n"
509 "TX VO priority ok int: %lu\n"
510 "TX BE priority ok int: %lu\n"
511 "TX BK priority ok int: %lu\n"
512 "TX MANAGE priority ok int: %lu\n"
513 "TX BEACON priority ok int: %lu\n"
514 "TX BEACON priority error int: %lu\n"
515 "TX CMDPKT priority ok int: %lu\n"
516 "TX queue stopped?: %d\n"
517 "TX fifo overflow: %lu\n"
518 "TX total data packets %lu\n"
519 "TX total data bytes :%lu\n",
520 priv
->stats
.txviokint
,
521 priv
->stats
.txvookint
,
522 priv
->stats
.txbeokint
,
523 priv
->stats
.txbkokint
,
524 priv
->stats
.txmanageokint
,
525 priv
->stats
.txbeaconokint
,
526 priv
->stats
.txbeaconerr
,
527 priv
->stats
.txcmdpktokint
,
528 netif_queue_stopped(dev
),
529 priv
->stats
.txoverflow
,
530 priv
->ieee80211
->stats
.tx_packets
,
531 priv
->ieee80211
->stats
.tx_bytes
);
539 static int proc_get_stats_rx(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
,
551 "RX rx overflow error: %lu\n",
554 priv
->stats
.rxoverflow
);
560 static void rtl8192_proc_module_init(void)
562 RT_TRACE(COMP_INIT
, "Initializing proc filesystem");
563 rtl8192_proc
=create_proc_entry(RTL819xE_MODULE_NAME
, S_IFDIR
, init_net
.proc_net
);
567 static void rtl8192_proc_module_remove(void)
569 remove_proc_entry(RTL819xE_MODULE_NAME
, init_net
.proc_net
);
573 static void rtl8192_proc_remove_one(struct net_device
*dev
)
575 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
577 printk("dev name=======> %s\n",dev
->name
);
580 remove_proc_entry("stats-tx", priv
->dir_dev
);
581 remove_proc_entry("stats-rx", priv
->dir_dev
);
582 remove_proc_entry("stats-ap", priv
->dir_dev
);
583 remove_proc_entry("registers", priv
->dir_dev
);
584 remove_proc_entry("wlan0", rtl8192_proc
);
585 priv
->dir_dev
= NULL
;
590 static void rtl8192_proc_init_one(struct net_device
*dev
)
592 struct proc_dir_entry
*e
;
593 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
594 priv
->dir_dev
= create_proc_entry(dev
->name
,
595 S_IFDIR
| S_IRUGO
| S_IXUGO
,
597 if (!priv
->dir_dev
) {
598 RT_TRACE(COMP_ERR
, "Unable to initialize /proc/net/rtl8192/%s\n",
602 e
= create_proc_read_entry("stats-rx", S_IFREG
| S_IRUGO
,
603 priv
->dir_dev
, proc_get_stats_rx
, dev
);
606 RT_TRACE(COMP_ERR
,"Unable to initialize "
607 "/proc/net/rtl8192/%s/stats-rx\n",
612 e
= create_proc_read_entry("stats-tx", S_IFREG
| S_IRUGO
,
613 priv
->dir_dev
, proc_get_stats_tx
, dev
);
616 RT_TRACE(COMP_ERR
, "Unable to initialize "
617 "/proc/net/rtl8192/%s/stats-tx\n",
621 e
= create_proc_read_entry("stats-ap", S_IFREG
| S_IRUGO
,
622 priv
->dir_dev
, proc_get_stats_ap
, dev
);
625 RT_TRACE(COMP_ERR
, "Unable to initialize "
626 "/proc/net/rtl8192/%s/stats-ap\n",
630 e
= create_proc_read_entry("registers", S_IFREG
| S_IRUGO
,
631 priv
->dir_dev
, proc_get_registers
, dev
);
633 RT_TRACE(COMP_ERR
, "Unable to initialize "
634 "/proc/net/rtl8192/%s/registers\n",
639 short check_nic_enough_desc(struct net_device
*dev
, int prio
)
641 struct r8192_priv
*priv
= ieee80211_priv(dev
);
642 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
644 /* for now we reserve two free descriptor as a safety boundary
645 * between the tail and the head
647 return (ring
->entries
- skb_queue_len(&ring
->queue
) >= 2);
650 static void tx_timeout(struct net_device
*dev
)
652 struct r8192_priv
*priv
= ieee80211_priv(dev
);
654 schedule_work(&priv
->reset_wq
);
658 static void rtl8192_irq_enable(struct net_device
*dev
)
660 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
661 priv
->irq_enabled
= 1;
662 write_nic_dword(priv
, INTA_MASK
, priv
->irq_mask
);
665 void rtl8192_irq_disable(struct net_device
*dev
)
667 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
669 write_nic_dword(priv
, INTA_MASK
, 0);
670 priv
->irq_enabled
= 0;
673 void rtl8192_update_msr(struct net_device
*dev
)
675 struct r8192_priv
*priv
= ieee80211_priv(dev
);
678 msr
= read_nic_byte(priv
, MSR
);
679 msr
&= ~ MSR_LINK_MASK
;
681 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
682 * msr must be updated if the state is ASSOCIATING.
683 * this is intentional and make sense for ad-hoc and
684 * master (see the create BSS/IBSS func)
686 if (priv
->ieee80211
->state
== IEEE80211_LINKED
){
688 if (priv
->ieee80211
->iw_mode
== IW_MODE_INFRA
)
689 msr
|= (MSR_LINK_MANAGED
<<MSR_LINK_SHIFT
);
690 else if (priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
691 msr
|= (MSR_LINK_ADHOC
<<MSR_LINK_SHIFT
);
692 else if (priv
->ieee80211
->iw_mode
== IW_MODE_MASTER
)
693 msr
|= (MSR_LINK_MASTER
<<MSR_LINK_SHIFT
);
696 msr
|= (MSR_LINK_NONE
<<MSR_LINK_SHIFT
);
698 write_nic_byte(priv
, MSR
, msr
);
701 void rtl8192_set_chan(struct net_device
*dev
,short ch
)
703 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
707 /* need to implement rf set channel here WB */
709 if (priv
->rf_set_chan
)
710 priv
->rf_set_chan(dev
, priv
->chan
);
713 void rtl8192_rx_enable(struct net_device
*dev
)
715 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
717 write_nic_dword(priv
, RDQDA
,priv
->rx_ring_dma
);
720 /* the TX_DESC_BASE setting is according to the following queue index
729 * BEACON_QUEUE ===> 8
731 static const u32 TX_DESC_BASE
[] = {BKQDA
, BEQDA
, VIQDA
, VOQDA
, HCCAQDA
, CQDA
, MQDA
, HQDA
, BQDA
};
732 void rtl8192_tx_enable(struct net_device
*dev
)
734 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
737 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
738 write_nic_dword(priv
, TX_DESC_BASE
[i
], priv
->tx_ring
[i
].dma
);
740 ieee80211_reset_queue(priv
->ieee80211
);
744 static void rtl8192_free_rx_ring(struct net_device
*dev
)
746 struct r8192_priv
*priv
= ieee80211_priv(dev
);
749 for (i
= 0; i
< priv
->rxringcount
; i
++) {
750 struct sk_buff
*skb
= priv
->rx_buf
[i
];
754 pci_unmap_single(priv
->pdev
,
755 *((dma_addr_t
*)skb
->cb
),
756 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
760 pci_free_consistent(priv
->pdev
, sizeof(*priv
->rx_ring
) * priv
->rxringcount
,
761 priv
->rx_ring
, priv
->rx_ring_dma
);
762 priv
->rx_ring
= NULL
;
765 static void rtl8192_free_tx_ring(struct net_device
*dev
, unsigned int prio
)
767 struct r8192_priv
*priv
= ieee80211_priv(dev
);
768 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
770 while (skb_queue_len(&ring
->queue
)) {
771 tx_desc_819x_pci
*entry
= &ring
->desc
[ring
->idx
];
772 struct sk_buff
*skb
= __skb_dequeue(&ring
->queue
);
774 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
775 skb
->len
, PCI_DMA_TODEVICE
);
777 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
780 pci_free_consistent(priv
->pdev
, sizeof(*ring
->desc
)*ring
->entries
,
781 ring
->desc
, ring
->dma
);
785 void PHY_SetRtl8192eRfOff(struct net_device
* dev
)
787 struct r8192_priv
*priv
= ieee80211_priv(dev
);
789 //disable RF-Chip A/B
790 rtl8192_setBBreg(dev
, rFPGA0_XA_RFInterfaceOE
, BIT4
, 0x0);
791 //analog to digital off, for power save
792 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter4
, 0x300, 0x0);
793 //digital to analog off, for power save
794 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter1
, 0x18, 0x0);
796 rtl8192_setBBreg(dev
, rOFDM0_TRxPathEnable
, 0xf, 0x0);
798 rtl8192_setBBreg(dev
, rOFDM1_TRxPathEnable
, 0xf, 0x0);
799 //analog to digital part2 off, for power save
800 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter1
, 0x60, 0x0);
801 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter1
, 0x4, 0x0);
802 // Analog parameter!!Change bias and Lbus control.
803 write_nic_byte(priv
, ANAPAR_FOR_8192PciE
, 0x07);
807 void rtl8192_halt_adapter(struct net_device
*dev
, bool reset
)
809 struct r8192_priv
*priv
= ieee80211_priv(dev
);
814 OpMode
= RT_OP_MODE_NO_LINK
;
815 priv
->ieee80211
->SetHwRegHandler(dev
, HW_VAR_MEDIA_STATUS
, &OpMode
);
817 if (!priv
->ieee80211
->bSupportRemoteWakeUp
) {
819 * disable tx/rx. In 8185 we write 0x10 (Reset bit),
820 * but here we make reference to WMAC and wirte 0x0
822 write_nic_byte(priv
, CMDR
, 0);
830 priv
->bHwRfOffAction
= 2;
833 * Call MgntActSet_RF_State instead to
834 * prevent RF config race condition.
836 if (!priv
->ieee80211
->bSupportRemoteWakeUp
) {
837 PHY_SetRtl8192eRfOff(dev
);
838 ulRegRead
= read_nic_dword(priv
, CPU_GEN
);
839 ulRegRead
|= CPU_GEN_SYSTEM_RESET
;
840 write_nic_dword(priv
,CPU_GEN
, ulRegRead
);
843 write_nic_dword(priv
, WFCRC0
, 0xffffffff);
844 write_nic_dword(priv
, WFCRC1
, 0xffffffff);
845 write_nic_dword(priv
, WFCRC2
, 0xffffffff);
847 /* Write PMR register */
848 write_nic_byte(priv
, PMR
, 0x5);
849 /* Disable tx, enanble rx */
850 write_nic_byte(priv
, MacBlkCtrl
, 0xa);
854 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
855 skb_queue_purge(&priv
->ieee80211
->skb_waitQ
[i
]);
857 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
858 skb_queue_purge(&priv
->ieee80211
->skb_aggQ
[i
]);
861 skb_queue_purge(&priv
->skb_queue
);
864 static const u16 rtl_rate
[] = {10,20,55,110,60,90,120,180,240,360,480,540};
865 inline u16
rtl8192_rate2rate(short rate
)
867 if (rate
>11) return 0;
868 return rtl_rate
[rate
];
871 static void rtl8192_data_hard_stop(struct net_device
*dev
)
875 static void rtl8192_data_hard_resume(struct net_device
*dev
)
880 * this function TX data frames when the ieee80211 stack requires this.
881 * It checks also if we need to stop the ieee tx queue, eventually do it
883 static void rtl8192_hard_data_xmit(struct sk_buff
*skb
, struct net_device
*dev
, int rate
)
885 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
887 cb_desc
*tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
888 u8 queue_index
= tcb_desc
->queue_index
;
890 /* shall not be referred by command packet */
891 BUG_ON(queue_index
== TXCMD_QUEUE
);
893 if (priv
->bHwRadioOff
|| (!priv
->up
))
899 memcpy(skb
->cb
, &dev
, sizeof(dev
));
901 skb_push(skb
, priv
->ieee80211
->tx_headroom
);
902 ret
= rtl8192_tx(dev
, skb
);
907 if (queue_index
!= MGNT_QUEUE
) {
908 priv
->ieee80211
->stats
.tx_bytes
+= (skb
->len
- priv
->ieee80211
->tx_headroom
);
909 priv
->ieee80211
->stats
.tx_packets
++;
914 * This is a rough attempt to TX a frame
915 * This is called by the ieee 80211 stack to TX management frames.
916 * If the ring is full packet are dropped (for data frame the queue
917 * is stopped before this can happen).
919 static int rtl8192_hard_start_xmit(struct sk_buff
*skb
,struct net_device
*dev
)
921 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
923 cb_desc
*tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
924 u8 queue_index
= tcb_desc
->queue_index
;
926 if (queue_index
!= TXCMD_QUEUE
) {
927 if (priv
->bHwRadioOff
|| (!priv
->up
))
934 memcpy(skb
->cb
, &dev
, sizeof(dev
));
935 if (queue_index
== TXCMD_QUEUE
) {
936 rtl819xE_tx_cmd(dev
, skb
);
940 tcb_desc
->RATRIndex
= 7;
941 tcb_desc
->bTxDisableRateFallBack
= 1;
942 tcb_desc
->bTxUseDriverAssingedRate
= 1;
943 tcb_desc
->bTxEnableFwCalcDur
= 1;
944 skb_push(skb
, priv
->ieee80211
->tx_headroom
);
945 ret
= rtl8192_tx(dev
, skb
);
955 static void rtl8192_tx_isr(struct net_device
*dev
, int prio
)
957 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
958 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
960 while (skb_queue_len(&ring
->queue
)) {
961 tx_desc_819x_pci
*entry
= &ring
->desc
[ring
->idx
];
965 * beacon packet will only use the first descriptor defaultly,
966 * and the OWN may not be cleared by the hardware
968 if (prio
!= BEACON_QUEUE
) {
971 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
974 skb
= __skb_dequeue(&ring
->queue
);
975 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
976 skb
->len
, PCI_DMA_TODEVICE
);
981 if (prio
!= BEACON_QUEUE
) {
982 /* try to deal with the pending packets */
983 tasklet_schedule(&priv
->irq_tx_tasklet
);
987 static void rtl8192_stop_beacon(struct net_device
*dev
)
991 static void rtl8192_config_rate(struct net_device
* dev
, u16
* rate_config
)
993 struct r8192_priv
*priv
= ieee80211_priv(dev
);
994 struct ieee80211_network
*net
;
995 u8 i
=0, basic_rate
= 0;
996 net
= & priv
->ieee80211
->current_network
;
998 for (i
=0; i
<net
->rates_len
; i
++)
1000 basic_rate
= net
->rates
[i
]&0x7f;
1003 case MGN_1M
: *rate_config
|= RRSR_1M
; break;
1004 case MGN_2M
: *rate_config
|= RRSR_2M
; break;
1005 case MGN_5_5M
: *rate_config
|= RRSR_5_5M
; break;
1006 case MGN_11M
: *rate_config
|= RRSR_11M
; break;
1007 case MGN_6M
: *rate_config
|= RRSR_6M
; break;
1008 case MGN_9M
: *rate_config
|= RRSR_9M
; break;
1009 case MGN_12M
: *rate_config
|= RRSR_12M
; break;
1010 case MGN_18M
: *rate_config
|= RRSR_18M
; break;
1011 case MGN_24M
: *rate_config
|= RRSR_24M
; break;
1012 case MGN_36M
: *rate_config
|= RRSR_36M
; break;
1013 case MGN_48M
: *rate_config
|= RRSR_48M
; break;
1014 case MGN_54M
: *rate_config
|= RRSR_54M
; break;
1017 for (i
=0; i
<net
->rates_ex_len
; i
++)
1019 basic_rate
= net
->rates_ex
[i
]&0x7f;
1022 case MGN_1M
: *rate_config
|= RRSR_1M
; break;
1023 case MGN_2M
: *rate_config
|= RRSR_2M
; break;
1024 case MGN_5_5M
: *rate_config
|= RRSR_5_5M
; break;
1025 case MGN_11M
: *rate_config
|= RRSR_11M
; break;
1026 case MGN_6M
: *rate_config
|= RRSR_6M
; break;
1027 case MGN_9M
: *rate_config
|= RRSR_9M
; break;
1028 case MGN_12M
: *rate_config
|= RRSR_12M
; break;
1029 case MGN_18M
: *rate_config
|= RRSR_18M
; break;
1030 case MGN_24M
: *rate_config
|= RRSR_24M
; break;
1031 case MGN_36M
: *rate_config
|= RRSR_36M
; break;
1032 case MGN_48M
: *rate_config
|= RRSR_48M
; break;
1033 case MGN_54M
: *rate_config
|= RRSR_54M
; break;
1039 #define SHORT_SLOT_TIME 9
1040 #define NON_SHORT_SLOT_TIME 20
1042 static void rtl8192_update_cap(struct net_device
* dev
, u16 cap
)
1045 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1046 struct ieee80211_network
*net
= &priv
->ieee80211
->current_network
;
1047 priv
->short_preamble
= cap
& WLAN_CAPABILITY_SHORT_PREAMBLE
;
1048 tmp
= priv
->basic_rate
;
1049 if (priv
->short_preamble
)
1050 tmp
|= BRSR_AckShortPmb
;
1051 write_nic_dword(priv
, RRSR
, tmp
);
1053 if (net
->mode
& (IEEE_G
|IEEE_N_24G
))
1056 if ((cap
& WLAN_CAPABILITY_SHORT_SLOT
)&&(!priv
->ieee80211
->pHTInfo
->bCurrentRT2RTLongSlotTime
))
1058 slot_time
= SHORT_SLOT_TIME
;
1060 else //long slot time
1061 slot_time
= NON_SHORT_SLOT_TIME
;
1062 priv
->slot_time
= slot_time
;
1063 write_nic_byte(priv
, SLOT_TIME
, slot_time
);
1068 static void rtl8192_net_update(struct net_device
*dev
)
1070 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1071 struct ieee80211_network
*net
;
1072 u16 BcnTimeCfg
= 0, BcnCW
= 6, BcnIFS
= 0xf;
1073 u16 rate_config
= 0;
1074 net
= &priv
->ieee80211
->current_network
;
1076 /* update Basic rate: RR, BRSR */
1077 rtl8192_config_rate(dev
, &rate_config
);
1080 * Select RRSR (in Legacy-OFDM and CCK)
1081 * For 8190, we select only 24M, 12M, 6M, 11M, 5.5M,
1082 * 2M, and 1M from the Basic rate.
1083 * We do not use other rates.
1085 priv
->basic_rate
= rate_config
&= 0x15f;
1088 write_nic_dword(priv
, BSSIDR
, ((u32
*)net
->bssid
)[0]);
1089 write_nic_word(priv
, BSSIDR
+4, ((u16
*)net
->bssid
)[2]);
1091 if (priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
1093 write_nic_word(priv
, ATIMWND
, 2);
1094 write_nic_word(priv
, BCN_DMATIME
, 256);
1095 write_nic_word(priv
, BCN_INTERVAL
, net
->beacon_interval
);
1097 * BIT15 of BCN_DRV_EARLY_INT will indicate
1098 * whether software beacon or hw beacon is applied.
1100 write_nic_word(priv
, BCN_DRV_EARLY_INT
, 10);
1101 write_nic_byte(priv
, BCN_ERR_THRESH
, 100);
1103 BcnTimeCfg
|= (BcnCW
<<BCN_TCFG_CW_SHIFT
);
1104 /* TODO: BcnIFS may required to be changed on ASIC */
1105 BcnTimeCfg
|= BcnIFS
<<BCN_TCFG_IFS
;
1106 write_nic_word(priv
, BCN_TCFG
, BcnTimeCfg
);
1110 void rtl819xE_tx_cmd(struct net_device
*dev
, struct sk_buff
*skb
)
1112 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1113 struct rtl8192_tx_ring
*ring
;
1114 tx_desc_819x_pci
*entry
;
1118 unsigned long flags
;
1120 ring
= &priv
->tx_ring
[TXCMD_QUEUE
];
1121 mapping
= pci_map_single(priv
->pdev
, skb
->data
, skb
->len
, PCI_DMA_TODEVICE
);
1123 spin_lock_irqsave(&priv
->irq_th_lock
,flags
);
1124 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
1125 entry
= &ring
->desc
[idx
];
1127 tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
1129 entry
->LINIP
= tcb_desc
->bLastIniPkt
;
1130 entry
->FirstSeg
= 1;//first segment
1131 entry
->LastSeg
= 1; //last segment
1132 if(tcb_desc
->bCmdOrInit
== DESC_PACKET_TYPE_INIT
) {
1133 entry
->CmdInit
= DESC_PACKET_TYPE_INIT
;
1135 entry
->CmdInit
= DESC_PACKET_TYPE_NORMAL
;
1136 entry
->Offset
= sizeof(TX_FWINFO_8190PCI
) + 8;
1137 entry
->PktSize
= (u16
)(tcb_desc
->pkt_size
+ entry
->Offset
);
1138 entry
->QueueSelect
= QSLT_CMD
;
1139 entry
->TxFWInfoSize
= 0x08;
1140 entry
->RATid
= (u8
)DESC_PACKET_TYPE_INIT
;
1142 entry
->TxBufferSize
= skb
->len
;
1143 entry
->TxBuffAddr
= cpu_to_le32(mapping
);
1146 __skb_queue_tail(&ring
->queue
, skb
);
1147 spin_unlock_irqrestore(&priv
->irq_th_lock
,flags
);
1149 write_nic_byte(priv
, TPPoll
, TPPoll_CQ
);
1155 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1156 * in TxFwInfo data structure
1158 static u8
MapHwQueueToFirmwareQueue(u8 QueueID
)
1164 QueueSelect
= QSLT_BE
;
1168 QueueSelect
= QSLT_BK
;
1172 QueueSelect
= QSLT_VO
;
1176 QueueSelect
= QSLT_VI
;
1180 QueueSelect
= QSLT_MGNT
;
1184 QueueSelect
= QSLT_BEACON
;
1188 QueueSelect
= QSLT_CMD
;
1193 RT_TRACE(COMP_ERR
, "Impossible Queue Selection: %d\n", QueueID
);
1199 static u8
MRateToHwRate8190Pci(u8 rate
)
1201 u8 ret
= DESC90_RATE1M
;
1204 case MGN_1M
: ret
= DESC90_RATE1M
; break;
1205 case MGN_2M
: ret
= DESC90_RATE2M
; break;
1206 case MGN_5_5M
: ret
= DESC90_RATE5_5M
; break;
1207 case MGN_11M
: ret
= DESC90_RATE11M
; break;
1208 case MGN_6M
: ret
= DESC90_RATE6M
; break;
1209 case MGN_9M
: ret
= DESC90_RATE9M
; break;
1210 case MGN_12M
: ret
= DESC90_RATE12M
; break;
1211 case MGN_18M
: ret
= DESC90_RATE18M
; break;
1212 case MGN_24M
: ret
= DESC90_RATE24M
; break;
1213 case MGN_36M
: ret
= DESC90_RATE36M
; break;
1214 case MGN_48M
: ret
= DESC90_RATE48M
; break;
1215 case MGN_54M
: ret
= DESC90_RATE54M
; break;
1217 // HT rate since here
1218 case MGN_MCS0
: ret
= DESC90_RATEMCS0
; break;
1219 case MGN_MCS1
: ret
= DESC90_RATEMCS1
; break;
1220 case MGN_MCS2
: ret
= DESC90_RATEMCS2
; break;
1221 case MGN_MCS3
: ret
= DESC90_RATEMCS3
; break;
1222 case MGN_MCS4
: ret
= DESC90_RATEMCS4
; break;
1223 case MGN_MCS5
: ret
= DESC90_RATEMCS5
; break;
1224 case MGN_MCS6
: ret
= DESC90_RATEMCS6
; break;
1225 case MGN_MCS7
: ret
= DESC90_RATEMCS7
; break;
1226 case MGN_MCS8
: ret
= DESC90_RATEMCS8
; break;
1227 case MGN_MCS9
: ret
= DESC90_RATEMCS9
; break;
1228 case MGN_MCS10
: ret
= DESC90_RATEMCS10
; break;
1229 case MGN_MCS11
: ret
= DESC90_RATEMCS11
; break;
1230 case MGN_MCS12
: ret
= DESC90_RATEMCS12
; break;
1231 case MGN_MCS13
: ret
= DESC90_RATEMCS13
; break;
1232 case MGN_MCS14
: ret
= DESC90_RATEMCS14
; break;
1233 case MGN_MCS15
: ret
= DESC90_RATEMCS15
; break;
1234 case (0x80|0x20): ret
= DESC90_RATEMCS32
; break;
1242 static u8
QueryIsShort(u8 TxHT
, u8 TxRate
, cb_desc
*tcb_desc
)
1246 tmp_Short
= (TxHT
==1)?((tcb_desc
->bUseShortGI
)?1:0):((tcb_desc
->bUseShortPreamble
)?1:0);
1248 if(TxHT
==1 && TxRate
!= DESC90_RATEMCS15
)
1255 * The tx procedure is just as following,
1256 * skb->cb will contain all the following information,
1257 * priority, morefrag, rate, &dev.
1259 short rtl8192_tx(struct net_device
*dev
, struct sk_buff
* skb
)
1261 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1262 struct rtl8192_tx_ring
*ring
;
1263 unsigned long flags
;
1264 cb_desc
*tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
1265 tx_desc_819x_pci
*pdesc
= NULL
;
1266 TX_FWINFO_8190PCI
*pTxFwInfo
= NULL
;
1268 bool multi_addr
= false, broad_addr
= false, uni_addr
= false;
1269 u8
*pda_addr
= NULL
;
1272 if (priv
->bdisable_nic
) {
1273 RT_TRACE(COMP_ERR
, "Nic is disabled! Can't tx packet len=%d qidx=%d!!!\n",
1274 skb
->len
, tcb_desc
->queue_index
);
1279 priv
->ieee80211
->bAwakePktSent
= true;
1282 mapping
= pci_map_single(priv
->pdev
, skb
->data
, skb
->len
, PCI_DMA_TODEVICE
);
1284 /* collect the tx packets statitcs */
1285 pda_addr
= ((u8
*)skb
->data
) + sizeof(TX_FWINFO_8190PCI
);
1286 if (is_multicast_ether_addr(pda_addr
))
1288 else if (is_broadcast_ether_addr(pda_addr
))
1294 priv
->stats
.txbytesunicast
+= (u8
)(skb
->len
) - sizeof(TX_FWINFO_8190PCI
);
1296 /* fill tx firmware */
1297 pTxFwInfo
= (PTX_FWINFO_8190PCI
)skb
->data
;
1298 memset(pTxFwInfo
, 0, sizeof(TX_FWINFO_8190PCI
));
1299 pTxFwInfo
->TxHT
= (tcb_desc
->data_rate
&0x80) ? 1 : 0;
1300 pTxFwInfo
->TxRate
= MRateToHwRate8190Pci((u8
)tcb_desc
->data_rate
);
1301 pTxFwInfo
->EnableCPUDur
= tcb_desc
->bTxEnableFwCalcDur
;
1302 pTxFwInfo
->Short
= QueryIsShort(pTxFwInfo
->TxHT
, pTxFwInfo
->TxRate
, tcb_desc
);
1304 /* Aggregation related */
1305 if (tcb_desc
->bAMPDUEnable
) {
1306 pTxFwInfo
->AllowAggregation
= 1;
1307 pTxFwInfo
->RxMF
= tcb_desc
->ampdu_factor
;
1308 pTxFwInfo
->RxAMD
= tcb_desc
->ampdu_density
;
1310 pTxFwInfo
->AllowAggregation
= 0;
1311 pTxFwInfo
->RxMF
= 0;
1312 pTxFwInfo
->RxAMD
= 0;
1315 /* Protection mode related */
1316 pTxFwInfo
->RtsEnable
= (tcb_desc
->bRTSEnable
) ? 1 : 0;
1317 pTxFwInfo
->CtsEnable
= (tcb_desc
->bCTSEnable
) ? 1 : 0;
1318 pTxFwInfo
->RtsSTBC
= (tcb_desc
->bRTSSTBC
) ? 1 : 0;
1319 pTxFwInfo
->RtsHT
= (tcb_desc
->rts_rate
&0x80) ? 1 : 0;
1320 pTxFwInfo
->RtsRate
= MRateToHwRate8190Pci((u8
)tcb_desc
->rts_rate
);
1321 pTxFwInfo
->RtsBandwidth
= 0;
1322 pTxFwInfo
->RtsSubcarrier
= tcb_desc
->RTSSC
;
1323 pTxFwInfo
->RtsShort
= (pTxFwInfo
->RtsHT
== 0) ? (tcb_desc
->bRTSUseShortPreamble
? 1 : 0) : (tcb_desc
->bRTSUseShortGI
? 1 : 0);
1325 /* Set Bandwidth and sub-channel settings. */
1326 if (priv
->CurrentChannelBW
== HT_CHANNEL_WIDTH_20_40
) {
1327 if (tcb_desc
->bPacketBW
) {
1328 pTxFwInfo
->TxBandwidth
= 1;
1329 /* use duplicated mode */
1330 pTxFwInfo
->TxSubCarrier
= 0;
1332 pTxFwInfo
->TxBandwidth
= 0;
1333 pTxFwInfo
->TxSubCarrier
= priv
->nCur40MhzPrimeSC
;
1336 pTxFwInfo
->TxBandwidth
= 0;
1337 pTxFwInfo
->TxSubCarrier
= 0;
1340 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
1341 ring
= &priv
->tx_ring
[tcb_desc
->queue_index
];
1342 if (tcb_desc
->queue_index
!= BEACON_QUEUE
)
1343 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
1347 pdesc
= &ring
->desc
[idx
];
1348 if ((pdesc
->OWN
== 1) && (tcb_desc
->queue_index
!= BEACON_QUEUE
)) {
1349 RT_TRACE(COMP_ERR
, "No more TX desc@%d, ring->idx = %d,idx = %d,%x",
1350 tcb_desc
->queue_index
, ring
->idx
, idx
, skb
->len
);
1351 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
1355 /* fill tx descriptor */
1356 memset(pdesc
, 0, 12);
1361 pdesc
->Offset
= sizeof(TX_FWINFO_8190PCI
) + 8; /* We must add 8!! */
1362 pdesc
->PktSize
= (u16
)skb
->len
-sizeof(TX_FWINFO_8190PCI
);
1365 pdesc
->SecCAMID
= 0;
1366 pdesc
->RATid
= tcb_desc
->RATRIndex
;
1369 pdesc
->SecType
= 0x0;
1370 if (tcb_desc
->bHwSec
) {
1371 switch (priv
->ieee80211
->pairwise_key_type
) {
1372 case KEY_TYPE_WEP40
:
1373 case KEY_TYPE_WEP104
:
1374 pdesc
->SecType
= 0x1;
1378 pdesc
->SecType
= 0x2;
1382 pdesc
->SecType
= 0x3;
1386 pdesc
->SecType
= 0x0;
1395 pdesc
->QueueSelect
= MapHwQueueToFirmwareQueue(tcb_desc
->queue_index
);
1396 pdesc
->TxFWInfoSize
= sizeof(TX_FWINFO_8190PCI
);
1398 pdesc
->DISFB
= tcb_desc
->bTxDisableRateFallBack
;
1399 pdesc
->USERATE
= tcb_desc
->bTxUseDriverAssingedRate
;
1401 pdesc
->FirstSeg
= 1;
1403 pdesc
->TxBufferSize
= skb
->len
;
1405 pdesc
->TxBuffAddr
= cpu_to_le32(mapping
);
1406 __skb_queue_tail(&ring
->queue
, skb
);
1408 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
1409 dev
->trans_start
= jiffies
;
1410 write_nic_word(priv
, TPPoll
, 0x01<<tcb_desc
->queue_index
);
1414 static short rtl8192_alloc_rx_desc_ring(struct net_device
*dev
)
1416 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1417 rx_desc_819x_pci
*entry
= NULL
;
1420 priv
->rx_ring
= pci_alloc_consistent(priv
->pdev
,
1421 sizeof(*priv
->rx_ring
) * priv
->rxringcount
, &priv
->rx_ring_dma
);
1423 if (!priv
->rx_ring
|| (unsigned long)priv
->rx_ring
& 0xFF) {
1424 RT_TRACE(COMP_ERR
,"Cannot allocate RX ring\n");
1428 memset(priv
->rx_ring
, 0, sizeof(*priv
->rx_ring
) * priv
->rxringcount
);
1431 for (i
= 0; i
< priv
->rxringcount
; i
++) {
1432 struct sk_buff
*skb
= dev_alloc_skb(priv
->rxbuffersize
);
1433 dma_addr_t
*mapping
;
1434 entry
= &priv
->rx_ring
[i
];
1437 priv
->rx_buf
[i
] = skb
;
1438 mapping
= (dma_addr_t
*)skb
->cb
;
1439 *mapping
= pci_map_single(priv
->pdev
, skb_tail_pointer(skb
),
1440 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
1442 entry
->BufferAddress
= cpu_to_le32(*mapping
);
1444 entry
->Length
= priv
->rxbuffersize
;
1452 static int rtl8192_alloc_tx_desc_ring(struct net_device
*dev
,
1453 unsigned int prio
, unsigned int entries
)
1455 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
1456 tx_desc_819x_pci
*ring
;
1460 ring
= pci_alloc_consistent(priv
->pdev
, sizeof(*ring
) * entries
, &dma
);
1461 if (!ring
|| (unsigned long)ring
& 0xFF) {
1462 RT_TRACE(COMP_ERR
, "Cannot allocate TX ring (prio = %d)\n", prio
);
1466 memset(ring
, 0, sizeof(*ring
)*entries
);
1467 priv
->tx_ring
[prio
].desc
= ring
;
1468 priv
->tx_ring
[prio
].dma
= dma
;
1469 priv
->tx_ring
[prio
].idx
= 0;
1470 priv
->tx_ring
[prio
].entries
= entries
;
1471 skb_queue_head_init(&priv
->tx_ring
[prio
].queue
);
1473 for (i
= 0; i
< entries
; i
++)
1474 ring
[i
].NextDescAddress
=
1475 cpu_to_le32((u32
)dma
+ ((i
+ 1) % entries
) * sizeof(*ring
));
1480 static short rtl8192_pci_initdescring(struct net_device
*dev
)
1484 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1486 ret
= rtl8192_alloc_rx_desc_ring(dev
);
1490 /* general process for other queue */
1491 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
1492 ret
= rtl8192_alloc_tx_desc_ring(dev
, i
, priv
->txringcount
);
1494 goto err_free_rings
;
1500 rtl8192_free_rx_ring(dev
);
1501 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
1502 if (priv
->tx_ring
[i
].desc
)
1503 rtl8192_free_tx_ring(dev
, i
);
1507 static void rtl8192_pci_resetdescring(struct net_device
*dev
)
1509 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1512 /* force the rx_idx to the first one */
1514 rx_desc_819x_pci
*entry
= NULL
;
1515 for (i
= 0; i
< priv
->rxringcount
; i
++) {
1516 entry
= &priv
->rx_ring
[i
];
1522 /* after reset, release previous pending packet, and force the
1523 * tx idx to the first one */
1524 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
1525 if (priv
->tx_ring
[i
].desc
) {
1526 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[i
];
1528 while (skb_queue_len(&ring
->queue
)) {
1529 tx_desc_819x_pci
*entry
= &ring
->desc
[ring
->idx
];
1530 struct sk_buff
*skb
= __skb_dequeue(&ring
->queue
);
1532 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
1533 skb
->len
, PCI_DMA_TODEVICE
);
1535 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
1542 static void rtl8192_link_change(struct net_device
*dev
)
1544 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1545 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1547 if (ieee
->state
== IEEE80211_LINKED
)
1549 rtl8192_net_update(dev
);
1550 rtl8192_update_ratr_table(dev
);
1552 //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
1553 if ((KEY_TYPE_WEP40
== ieee
->pairwise_key_type
) || (KEY_TYPE_WEP104
== ieee
->pairwise_key_type
))
1554 EnableHWSecurityConfig8192(dev
);
1558 write_nic_byte(priv
, 0x173, 0);
1561 rtl8192_update_msr(dev
);
1563 // 2007/10/16 MH MAC Will update TSF according to all received beacon, so we have
1564 // // To set CBSSID bit when link with any AP or STA.
1565 if (ieee
->iw_mode
== IW_MODE_INFRA
|| ieee
->iw_mode
== IW_MODE_ADHOC
)
1568 reg
= read_nic_dword(priv
, RCR
);
1569 if (priv
->ieee80211
->state
== IEEE80211_LINKED
)
1570 priv
->ReceiveConfig
= reg
|= RCR_CBSSID
;
1572 priv
->ReceiveConfig
= reg
&= ~RCR_CBSSID
;
1573 write_nic_dword(priv
, RCR
, reg
);
1578 static const struct ieee80211_qos_parameters def_qos_parameters
= {
1579 {3,3,3,3},/* cw_min */
1580 {7,7,7,7},/* cw_max */
1581 {2,2,2,2},/* aifs */
1582 {0,0,0,0},/* flags */
1583 {0,0,0,0} /* tx_op_limit */
1586 static void rtl8192_update_beacon(struct work_struct
* work
)
1588 struct r8192_priv
*priv
= container_of(work
, struct r8192_priv
, update_beacon_wq
.work
);
1589 struct net_device
*dev
= priv
->ieee80211
->dev
;
1590 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1591 struct ieee80211_network
* net
= &ieee
->current_network
;
1593 if (ieee
->pHTInfo
->bCurrentHTSupport
)
1594 HTUpdateSelfAndPeerSetting(ieee
, net
);
1595 ieee
->pHTInfo
->bCurrentRT2RTLongSlotTime
= net
->bssht
.bdRT2RTLongSlotTime
;
1596 rtl8192_update_cap(dev
, net
->capability
);
1600 * background support to run QoS activate functionality
1602 static const int WDCAPARA_ADD
[] = {EDCAPARA_BE
,EDCAPARA_BK
,EDCAPARA_VI
,EDCAPARA_VO
};
1603 static void rtl8192_qos_activate(struct work_struct
* work
)
1605 struct r8192_priv
*priv
= container_of(work
, struct r8192_priv
, qos_activate
);
1606 struct ieee80211_qos_parameters
*qos_parameters
= &priv
->ieee80211
->current_network
.qos_data
.parameters
;
1607 u8 mode
= priv
->ieee80211
->current_network
.mode
;
1612 mutex_lock(&priv
->mutex
);
1613 if(priv
->ieee80211
->state
!= IEEE80211_LINKED
)
1615 RT_TRACE(COMP_QOS
,"qos active process with associate response received\n");
1616 /* It better set slot time at first */
1617 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
1618 /* update the ac parameter to related registers */
1619 for(i
= 0; i
< QOS_QUEUE_NUM
; i
++) {
1620 //Mode G/A: slotTimeTimer = 9; Mode B: 20
1621 u1bAIFS
= qos_parameters
->aifs
[i
] * ((mode
&(IEEE_G
|IEEE_N_24G
)) ?9:20) + aSifsTime
;
1622 u4bAcParam
= ((((u32
)(qos_parameters
->tx_op_limit
[i
]))<< AC_PARAM_TXOP_LIMIT_OFFSET
)|
1623 (((u32
)(qos_parameters
->cw_max
[i
]))<< AC_PARAM_ECW_MAX_OFFSET
)|
1624 (((u32
)(qos_parameters
->cw_min
[i
]))<< AC_PARAM_ECW_MIN_OFFSET
)|
1625 ((u32
)u1bAIFS
<< AC_PARAM_AIFS_OFFSET
));
1626 write_nic_dword(priv
, WDCAPARA_ADD
[i
], u4bAcParam
);
1630 mutex_unlock(&priv
->mutex
);
1633 static int rtl8192_qos_handle_probe_response(struct r8192_priv
*priv
,
1635 struct ieee80211_network
*network
)
1638 u32 size
= sizeof(struct ieee80211_qos_parameters
);
1640 if(priv
->ieee80211
->state
!=IEEE80211_LINKED
)
1643 if ((priv
->ieee80211
->iw_mode
!= IW_MODE_INFRA
))
1646 if (network
->flags
& NETWORK_HAS_QOS_MASK
) {
1647 if (active_network
&&
1648 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
))
1649 network
->qos_data
.active
= network
->qos_data
.supported
;
1651 if ((network
->qos_data
.active
== 1) && (active_network
== 1) &&
1652 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) &&
1653 (network
->qos_data
.old_param_count
!=
1654 network
->qos_data
.param_count
)) {
1655 network
->qos_data
.old_param_count
=
1656 network
->qos_data
.param_count
;
1657 queue_work(priv
->priv_wq
, &priv
->qos_activate
);
1658 RT_TRACE (COMP_QOS
, "QoS parameters change call "
1662 memcpy(&priv
->ieee80211
->current_network
.qos_data
.parameters
,
1663 &def_qos_parameters
, size
);
1665 if ((network
->qos_data
.active
== 1) && (active_network
== 1)) {
1666 queue_work(priv
->priv_wq
, &priv
->qos_activate
);
1667 RT_TRACE(COMP_QOS
, "QoS was disabled call qos_activate \n");
1669 network
->qos_data
.active
= 0;
1670 network
->qos_data
.supported
= 0;
1676 /* handle manage frame frame beacon and probe response */
1677 static int rtl8192_handle_beacon(struct net_device
* dev
,
1678 struct ieee80211_beacon
* beacon
,
1679 struct ieee80211_network
* network
)
1681 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1683 rtl8192_qos_handle_probe_response(priv
,1,network
);
1685 queue_delayed_work(priv
->priv_wq
, &priv
->update_beacon_wq
, 0);
1691 * handling the beaconing responses. if we get different QoS setting
1692 * off the network from the associated setting, adjust the QoS setting
1694 static int rtl8192_qos_association_resp(struct r8192_priv
*priv
,
1695 struct ieee80211_network
*network
)
1698 unsigned long flags
;
1699 u32 size
= sizeof(struct ieee80211_qos_parameters
);
1700 int set_qos_param
= 0;
1702 if ((priv
== NULL
) || (network
== NULL
))
1705 if (priv
->ieee80211
->state
!= IEEE80211_LINKED
)
1708 if ((priv
->ieee80211
->iw_mode
!= IW_MODE_INFRA
))
1711 spin_lock_irqsave(&priv
->ieee80211
->lock
, flags
);
1712 if (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) {
1713 memcpy(&priv
->ieee80211
->current_network
.qos_data
.parameters
,
1714 &network
->qos_data
.parameters
,
1715 sizeof(struct ieee80211_qos_parameters
));
1716 priv
->ieee80211
->current_network
.qos_data
.active
= 1;
1718 /* update qos parameter for current network */
1719 priv
->ieee80211
->current_network
.qos_data
.old_param_count
=
1720 priv
->ieee80211
->current_network
.qos_data
.param_count
;
1721 priv
->ieee80211
->current_network
.qos_data
.param_count
=
1722 network
->qos_data
.param_count
;
1725 memcpy(&priv
->ieee80211
->current_network
.qos_data
.parameters
,
1726 &def_qos_parameters
, size
);
1727 priv
->ieee80211
->current_network
.qos_data
.active
= 0;
1728 priv
->ieee80211
->current_network
.qos_data
.supported
= 0;
1732 spin_unlock_irqrestore(&priv
->ieee80211
->lock
, flags
);
1734 RT_TRACE(COMP_QOS
, "%s: network->flags = %d,%d\n", __FUNCTION__
,
1735 network
->flags
, priv
->ieee80211
->current_network
.qos_data
.active
);
1736 if (set_qos_param
== 1)
1737 queue_work(priv
->priv_wq
, &priv
->qos_activate
);
1743 static int rtl8192_handle_assoc_response(struct net_device
*dev
,
1744 struct ieee80211_assoc_response_frame
*resp
,
1745 struct ieee80211_network
*network
)
1747 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1748 rtl8192_qos_association_resp(priv
, network
);
1753 /* updateRATRTabel for MCS only. Basic rate is not implemented. */
1754 static void rtl8192_update_ratr_table(struct net_device
* dev
)
1756 struct r8192_priv
* priv
= ieee80211_priv(dev
);
1757 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1758 u8
* pMcsRate
= ieee
->dot11HTOperationalRateSet
;
1762 rtl8192_config_rate(dev
, (u16
*)(&ratr_value
));
1763 ratr_value
|= (*(u16
*)(pMcsRate
)) << 12;
1768 ratr_value
&= 0x00000FF0;
1771 ratr_value
&= 0x0000000F;
1774 ratr_value
&= 0x00000FF7;
1778 if (ieee
->pHTInfo
->PeerMimoPs
== 0) //MIMO_PS_STATIC
1779 ratr_value
&= 0x0007F007;
1781 if (priv
->rf_type
== RF_1T2R
)
1782 ratr_value
&= 0x000FF007;
1784 ratr_value
&= 0x0F81F007;
1790 ratr_value
&= 0x0FFFFFFF;
1791 if(ieee
->pHTInfo
->bCurTxBW40MHz
&& ieee
->pHTInfo
->bCurShortGI40MHz
){
1792 ratr_value
|= 0x80000000;
1793 }else if(!ieee
->pHTInfo
->bCurTxBW40MHz
&& ieee
->pHTInfo
->bCurShortGI20MHz
){
1794 ratr_value
|= 0x80000000;
1796 write_nic_dword(priv
, RATR0
+rate_index
*4, ratr_value
);
1797 write_nic_byte(priv
, UFWP
, 1);
1800 static bool GetNmodeSupportBySecCfg8190Pci(struct net_device
*dev
)
1802 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1803 struct ieee80211_device
*ieee
= priv
->ieee80211
;
1805 return !(ieee
->rtllib_ap_sec_type
&&
1806 (ieee
->rtllib_ap_sec_type(ieee
)&(SEC_ALG_WEP
|SEC_ALG_TKIP
)));
1809 static void rtl8192_refresh_supportrate(struct r8192_priv
* priv
)
1811 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1812 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
1813 if (ieee
->mode
== WIRELESS_MODE_N_24G
|| ieee
->mode
== WIRELESS_MODE_N_5G
)
1815 memcpy(ieee
->Regdot11HTOperationalRateSet
, ieee
->RegHTSuppRateSet
, 16);
1818 memset(ieee
->Regdot11HTOperationalRateSet
, 0, 16);
1821 static u8
rtl8192_getSupportedWireleeMode(struct net_device
*dev
)
1823 return (WIRELESS_MODE_N_24G
|WIRELESS_MODE_G
|WIRELESS_MODE_B
);
1826 static void rtl8192_SetWirelessMode(struct net_device
* dev
, u8 wireless_mode
)
1828 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1829 u8 bSupportMode
= rtl8192_getSupportedWireleeMode(dev
);
1831 if ((wireless_mode
== WIRELESS_MODE_AUTO
) || ((wireless_mode
&bSupportMode
)==0))
1833 if(bSupportMode
& WIRELESS_MODE_N_24G
)
1835 wireless_mode
= WIRELESS_MODE_N_24G
;
1837 else if(bSupportMode
& WIRELESS_MODE_N_5G
)
1839 wireless_mode
= WIRELESS_MODE_N_5G
;
1841 else if((bSupportMode
& WIRELESS_MODE_A
))
1843 wireless_mode
= WIRELESS_MODE_A
;
1845 else if((bSupportMode
& WIRELESS_MODE_G
))
1847 wireless_mode
= WIRELESS_MODE_G
;
1849 else if((bSupportMode
& WIRELESS_MODE_B
))
1851 wireless_mode
= WIRELESS_MODE_B
;
1854 RT_TRACE(COMP_ERR
, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__
,bSupportMode
);
1855 wireless_mode
= WIRELESS_MODE_B
;
1858 priv
->ieee80211
->mode
= wireless_mode
;
1860 if ((wireless_mode
== WIRELESS_MODE_N_24G
) || (wireless_mode
== WIRELESS_MODE_N_5G
))
1861 priv
->ieee80211
->pHTInfo
->bEnableHT
= 1;
1863 priv
->ieee80211
->pHTInfo
->bEnableHT
= 0;
1864 RT_TRACE(COMP_INIT
, "Current Wireless Mode is %x\n", wireless_mode
);
1865 rtl8192_refresh_supportrate(priv
);
1868 static bool GetHalfNmodeSupportByAPs819xPci(struct net_device
* dev
)
1870 struct r8192_priv
* priv
= ieee80211_priv(dev
);
1871 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1873 return ieee
->bHalfWirelessN24GMode
;
1876 short rtl8192_is_tx_queue_empty(struct net_device
*dev
)
1879 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1880 for (i
=0; i
<=MGNT_QUEUE
; i
++)
1882 if ((i
== TXCMD_QUEUE
) || (i
== HCCA_QUEUE
) )
1884 if (skb_queue_len(&(&priv
->tx_ring
[i
])->queue
) > 0){
1885 printk("===>tx queue is not empty:%d, %d\n", i
, skb_queue_len(&(&priv
->tx_ring
[i
])->queue
));
1892 static void rtl8192_hw_sleep_down(struct net_device
*dev
)
1894 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1895 unsigned long flags
= 0;
1897 spin_lock_irqsave(&priv
->rf_ps_lock
,flags
);
1898 if (priv
->RFChangeInProgress
) {
1899 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
1900 RT_TRACE(COMP_RF
, "rtl8192_hw_sleep_down(): RF Change in progress! \n");
1901 printk("rtl8192_hw_sleep_down(): RF Change in progress!\n");
1904 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
1906 MgntActSet_RF_State(dev
, eRfSleep
, RF_CHANGE_BY_PS
);
1909 static void rtl8192_hw_sleep_wq (struct work_struct
*work
)
1911 struct delayed_work
*dwork
= container_of(work
,struct delayed_work
,work
);
1912 struct ieee80211_device
*ieee
= container_of(dwork
,struct ieee80211_device
,hw_sleep_wq
);
1913 struct net_device
*dev
= ieee
->dev
;
1915 rtl8192_hw_sleep_down(dev
);
1918 static void rtl8192_hw_wakeup(struct net_device
* dev
)
1920 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1921 unsigned long flags
= 0;
1923 spin_lock_irqsave(&priv
->rf_ps_lock
,flags
);
1924 if (priv
->RFChangeInProgress
) {
1925 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
1926 RT_TRACE(COMP_RF
, "rtl8192_hw_wakeup(): RF Change in progress! \n");
1927 printk("rtl8192_hw_wakeup(): RF Change in progress! schedule wake up task again\n");
1928 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
1931 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
1933 MgntActSet_RF_State(dev
, eRfOn
, RF_CHANGE_BY_PS
);
1936 void rtl8192_hw_wakeup_wq (struct work_struct
*work
)
1938 struct delayed_work
*dwork
= container_of(work
,struct delayed_work
,work
);
1939 struct ieee80211_device
*ieee
= container_of(dwork
,struct ieee80211_device
,hw_wakeup_wq
);
1940 struct net_device
*dev
= ieee
->dev
;
1941 rtl8192_hw_wakeup(dev
);
1945 #define MIN_SLEEP_TIME 50
1946 #define MAX_SLEEP_TIME 10000
1947 static void rtl8192_hw_to_sleep(struct net_device
*dev
, u32 th
, u32 tl
)
1949 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1953 spin_lock(&priv
->ps_lock
);
1955 // Writing HW register with 0 equals to disable
1956 // the timer, that is not really what we want
1958 tl
-= MSECS(8+16+7);
1960 // If the interval in witch we are requested to sleep is too
1961 // short then give up and remain awake
1962 // when we sleep after send null frame, the timer will be too short to sleep.
1964 if(((tl
>=rb
)&& (tl
-rb
) <= MSECS(MIN_SLEEP_TIME
))
1965 ||((rb
>tl
)&& (rb
-tl
) < MSECS(MIN_SLEEP_TIME
))) {
1966 printk("too short to sleep::%x, %x, %lx\n",tl
, rb
, MSECS(MIN_SLEEP_TIME
));
1970 if(((tl
> rb
) && ((tl
-rb
) > MSECS(MAX_SLEEP_TIME
)))||
1971 ((tl
< rb
) && (tl
>MSECS(69)) && ((rb
-tl
) > MSECS(MAX_SLEEP_TIME
)))||
1972 ((tl
<rb
)&&(tl
<MSECS(69))&&((tl
+0xffffffff-rb
)>MSECS(MAX_SLEEP_TIME
)))) {
1973 printk("========>too long to sleep:%x, %x, %lx\n", tl
, rb
, MSECS(MAX_SLEEP_TIME
));
1977 tmp
= (tl
>rb
)?(tl
-rb
):(rb
-tl
);
1978 queue_delayed_work(priv
->ieee80211
->wq
,
1979 &priv
->ieee80211
->hw_wakeup_wq
,tmp
);
1981 queue_delayed_work(priv
->ieee80211
->wq
,
1982 (void *)&priv
->ieee80211
->hw_sleep_wq
,0);
1984 spin_unlock(&priv
->ps_lock
);
1987 static void rtl8192_init_priv_variable(struct net_device
* dev
)
1989 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1991 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
1993 // Default Halt the NIC if RF is OFF.
1994 pPSC
->RegRfPsLevel
|= RT_RF_OFF_LEVL_HALT_NIC
;
1995 pPSC
->RegRfPsLevel
|= RT_RF_OFF_LEVL_CLK_REQ
;
1996 pPSC
->RegRfPsLevel
|= RT_RF_OFF_LEVL_ASPM
;
1997 pPSC
->RegRfPsLevel
|= RT_RF_LPS_LEVEL_ASPM
;
1998 pPSC
->bLeisurePs
= true;
1999 pPSC
->RegMaxLPSAwakeIntvl
= 5;
2000 priv
->bHwRadioOff
= false;
2002 priv
->being_init_adapter
= false;
2003 priv
->txringcount
= 64;//32;
2004 priv
->rxbuffersize
= 9100;//2048;//1024;
2005 priv
->rxringcount
= MAX_RX_COUNT
;//64;
2006 priv
->irq_enabled
=0;
2007 priv
->rx_skb_complete
= 1;
2008 priv
->chan
= 1; //set to channel 1
2009 priv
->RegWirelessMode
= WIRELESS_MODE_AUTO
;
2010 priv
->RegChannelPlan
= 0xf;
2011 priv
->ieee80211
->mode
= WIRELESS_MODE_AUTO
; //SET AUTO
2012 priv
->ieee80211
->iw_mode
= IW_MODE_INFRA
;
2013 priv
->ieee80211
->ieee_up
=0;
2014 priv
->retry_rts
= DEFAULT_RETRY_RTS
;
2015 priv
->retry_data
= DEFAULT_RETRY_DATA
;
2016 priv
->ieee80211
->rts
= DEFAULT_RTS_THRESHOLD
;
2017 priv
->ieee80211
->rate
= 110; //11 mbps
2018 priv
->ieee80211
->short_slot
= 1;
2019 priv
->promisc
= (dev
->flags
& IFF_PROMISC
) ? 1:0;
2020 priv
->bcck_in_ch14
= false;
2021 priv
->CCKPresentAttentuation
= 0;
2022 priv
->rfa_txpowertrackingindex
= 0;
2023 priv
->rfc_txpowertrackingindex
= 0;
2025 //added by amy for silent reset
2026 priv
->ResetProgress
= RESET_TYPE_NORESET
;
2027 priv
->bForcedSilentReset
= 0;
2028 priv
->bDisableNormalResetCheck
= false;
2029 priv
->force_reset
= false;
2030 //added by amy for power save
2031 priv
->ieee80211
->RfOffReason
= 0;
2032 priv
->RFChangeInProgress
= false;
2033 priv
->bHwRfOffAction
= 0;
2034 priv
->SetRFPowerStateInProgress
= false;
2035 priv
->ieee80211
->PowerSaveControl
.bInactivePs
= true;
2036 priv
->ieee80211
->PowerSaveControl
.bIPSModeBackup
= false;
2038 priv
->ieee80211
->current_network
.beacon_interval
= DEFAULT_BEACONINTERVAL
;
2039 priv
->ieee80211
->iw_mode
= IW_MODE_INFRA
;
2040 priv
->ieee80211
->softmac_features
= IEEE_SOFTMAC_SCAN
|
2041 IEEE_SOFTMAC_ASSOCIATE
| IEEE_SOFTMAC_PROBERQ
|
2042 IEEE_SOFTMAC_PROBERS
| IEEE_SOFTMAC_TX_QUEUE
;/* |
2043 IEEE_SOFTMAC_BEACONS;*///added by amy
080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2045 priv
->ieee80211
->active_scan
= 1;
2046 priv
->ieee80211
->modulation
= IEEE80211_CCK_MODULATION
| IEEE80211_OFDM_MODULATION
;
2047 priv
->ieee80211
->host_encrypt
= 1;
2048 priv
->ieee80211
->host_decrypt
= 1;
2049 priv
->ieee80211
->start_send_beacons
= rtl8192_start_beacon
;//+by david 081107
2050 priv
->ieee80211
->stop_send_beacons
= rtl8192_stop_beacon
;//+by david 081107
2051 priv
->ieee80211
->softmac_hard_start_xmit
= rtl8192_hard_start_xmit
;
2052 priv
->ieee80211
->set_chan
= rtl8192_set_chan
;
2053 priv
->ieee80211
->link_change
= rtl8192_link_change
;
2054 priv
->ieee80211
->softmac_data_hard_start_xmit
= rtl8192_hard_data_xmit
;
2055 priv
->ieee80211
->data_hard_stop
= rtl8192_data_hard_stop
;
2056 priv
->ieee80211
->data_hard_resume
= rtl8192_data_hard_resume
;
2057 priv
->ieee80211
->init_wmmparam_flag
= 0;
2058 priv
->ieee80211
->fts
= DEFAULT_FRAG_THRESHOLD
;
2059 priv
->ieee80211
->check_nic_enough_desc
= check_nic_enough_desc
;
2060 priv
->ieee80211
->tx_headroom
= sizeof(TX_FWINFO_8190PCI
);
2061 priv
->ieee80211
->qos_support
= 1;
2062 priv
->ieee80211
->dot11PowerSaveMode
= 0;
2063 priv
->ieee80211
->SetBWModeHandler
= rtl8192_SetBWMode
;
2064 priv
->ieee80211
->handle_assoc_response
= rtl8192_handle_assoc_response
;
2065 priv
->ieee80211
->handle_beacon
= rtl8192_handle_beacon
;
2067 priv
->ieee80211
->sta_wake_up
= rtl8192_hw_wakeup
;
2068 priv
->ieee80211
->enter_sleep_state
= rtl8192_hw_to_sleep
;
2069 priv
->ieee80211
->ps_is_queue_empty
= rtl8192_is_tx_queue_empty
;
2070 priv
->ieee80211
->GetNmodeSupportBySecCfg
= GetNmodeSupportBySecCfg8190Pci
;
2071 priv
->ieee80211
->SetWirelessMode
= rtl8192_SetWirelessMode
;
2072 priv
->ieee80211
->GetHalfNmodeSupportByAPsHandler
= GetHalfNmodeSupportByAPs819xPci
;
2074 priv
->ieee80211
->InitialGainHandler
= InitialGain819xPci
;
2077 priv
->ieee80211
->ieee80211_ips_leave_wq
= ieee80211_ips_leave_wq
;
2078 priv
->ieee80211
->ieee80211_ips_leave
= ieee80211_ips_leave
;
2081 priv
->ieee80211
->LeisurePSLeave
= LeisurePSLeave
;
2084 priv
->ieee80211
->SetHwRegHandler
= rtl8192e_SetHwReg
;
2085 priv
->ieee80211
->rtllib_ap_sec_type
= rtl8192e_ap_sec_type
;
2087 priv
->ShortRetryLimit
= 0x30;
2088 priv
->LongRetryLimit
= 0x30;
2090 priv
->ReceiveConfig
= RCR_ADD3
|
2091 RCR_AMF
| RCR_ADF
| //accept management/data
2092 RCR_AICV
| //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2093 RCR_AB
| RCR_AM
| RCR_APM
| //accept BC/MC/UC
2094 RCR_AAP
| ((u32
)7<<RCR_MXDMA_OFFSET
) |
2095 ((u32
)7 << RCR_FIFO_OFFSET
) | RCR_ONLYERLPKT
;
2097 priv
->irq_mask
= (u32
)(IMR_ROK
| IMR_VODOK
| IMR_VIDOK
| IMR_BEDOK
| IMR_BKDOK
|
2098 IMR_HCCADOK
| IMR_MGNTDOK
| IMR_COMDOK
| IMR_HIGHDOK
|
2099 IMR_BDOK
| IMR_RXCMDOK
| IMR_TIMEOUT0
| IMR_RDU
| IMR_RXFOVW
|
2100 IMR_TXFOVW
| IMR_BcnInt
| IMR_TBDOK
| IMR_TBDER
);
2102 priv
->pFirmware
= vzalloc(sizeof(rt_firmware
));
2104 /* rx related queue */
2105 skb_queue_head_init(&priv
->skb_queue
);
2107 /* Tx related queue */
2108 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
2109 skb_queue_head_init(&priv
->ieee80211
->skb_waitQ
[i
]);
2111 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
2112 skb_queue_head_init(&priv
->ieee80211
->skb_aggQ
[i
]);
2114 priv
->rf_set_chan
= rtl8192_phy_SwChnl
;
2117 static void rtl8192_init_priv_lock(struct r8192_priv
* priv
)
2119 spin_lock_init(&priv
->irq_th_lock
);
2120 spin_lock_init(&priv
->rf_ps_lock
);
2121 spin_lock_init(&priv
->ps_lock
);
2122 sema_init(&priv
->wx_sem
,1);
2123 sema_init(&priv
->rf_sem
,1);
2124 mutex_init(&priv
->mutex
);
2127 /* init tasklet and wait_queue here */
2128 #define DRV_NAME "wlan0"
2129 static void rtl8192_init_priv_task(struct net_device
* dev
)
2131 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2133 priv
->priv_wq
= create_workqueue(DRV_NAME
);
2136 INIT_WORK(&priv
->ieee80211
->ips_leave_wq
, IPSLeave_wq
);
2139 INIT_WORK(&priv
->reset_wq
, rtl8192_restart
);
2140 INIT_DELAYED_WORK(&priv
->watch_dog_wq
, rtl819x_watchdog_wqcallback
);
2141 INIT_DELAYED_WORK(&priv
->txpower_tracking_wq
, dm_txpower_trackingcallback
);
2142 INIT_DELAYED_WORK(&priv
->rfpath_check_wq
, dm_rf_pathcheck_workitemcallback
);
2143 INIT_DELAYED_WORK(&priv
->update_beacon_wq
, rtl8192_update_beacon
);
2144 INIT_WORK(&priv
->qos_activate
, rtl8192_qos_activate
);
2145 INIT_DELAYED_WORK(&priv
->ieee80211
->hw_wakeup_wq
, rtl8192_hw_wakeup_wq
);
2146 INIT_DELAYED_WORK(&priv
->ieee80211
->hw_sleep_wq
, rtl8192_hw_sleep_wq
);
2148 tasklet_init(&priv
->irq_rx_tasklet
, rtl8192_irq_rx_tasklet
,
2149 (unsigned long) priv
);
2150 tasklet_init(&priv
->irq_tx_tasklet
, rtl8192_irq_tx_tasklet
,
2151 (unsigned long) priv
);
2152 tasklet_init(&priv
->irq_prepare_beacon_tasklet
, rtl8192_prepare_beacon
,
2153 (unsigned long) priv
);
2156 static void rtl8192_get_eeprom_size(struct net_device
* dev
)
2159 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2160 RT_TRACE(COMP_INIT
, "===========>%s()\n", __FUNCTION__
);
2161 curCR
= read_nic_dword(priv
, EPROM_CMD
);
2162 RT_TRACE(COMP_INIT
, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD
, curCR
);
2163 //whether need I consider BIT5?
2164 priv
->epromtype
= (curCR
& EPROM_CMD_9356SEL
) ? EPROM_93c56
: EPROM_93c46
;
2165 RT_TRACE(COMP_INIT
, "<===========%s(), epromtype:%d\n", __FUNCTION__
, priv
->epromtype
);
2169 * Adapter->EEPROMAddressSize should be set before this function call.
2170 * EEPROM address size can be got through GetEEPROMSize8185()
2172 static void rtl8192_read_eeprom_info(struct r8192_priv
*priv
)
2174 struct net_device
*dev
= priv
->ieee80211
->dev
;
2176 u8 ICVer8192
, ICVer8256
;
2177 u16 i
,usValue
, IC_Version
;
2179 u8 bMac_Tmp_Addr
[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01};
2180 RT_TRACE(COMP_INIT
, "====> rtl8192_read_eeprom_info\n");
2183 // TODO: I don't know if we need to apply EF function to EEPROM read function
2185 //2 Read EEPROM ID to make sure autoload is success
2186 EEPROMId
= eprom_read(dev
, 0);
2187 if( EEPROMId
!= RTL8190_EEPROM_ID
)
2189 RT_TRACE(COMP_ERR
, "EEPROM ID is invalid:%x, %x\n", EEPROMId
, RTL8190_EEPROM_ID
);
2190 priv
->AutoloadFailFlag
=true;
2194 priv
->AutoloadFailFlag
=false;
2198 // Assign Chip Version ID
2200 // Read IC Version && Channel Plan
2201 if(!priv
->AutoloadFailFlag
)
2204 priv
->eeprom_vid
= eprom_read(dev
, (EEPROM_VID
>> 1));
2205 priv
->eeprom_did
= eprom_read(dev
, (EEPROM_DID
>> 1));
2207 usValue
= eprom_read(dev
, (u16
)(EEPROM_Customer_ID
>>1)) >> 8 ;
2208 priv
->eeprom_CustomerID
= (u8
)( usValue
& 0xff);
2209 usValue
= eprom_read(dev
, (EEPROM_ICVersion_ChannelPlan
>>1));
2210 priv
->eeprom_ChannelPlan
= usValue
&0xff;
2211 IC_Version
= ((usValue
&0xff00)>>8);
2213 ICVer8192
= (IC_Version
&0xf); //bit0~3; 1:A cut, 2:B cut, 3:C cut...
2214 ICVer8256
= ((IC_Version
&0xf0)>>4);//bit4~6, bit7 reserved for other RF chip; 1:A cut, 2:B cut, 3:C cut...
2215 RT_TRACE(COMP_INIT
, "\nICVer8192 = 0x%x\n", ICVer8192
);
2216 RT_TRACE(COMP_INIT
, "\nICVer8256 = 0x%x\n", ICVer8256
);
2217 if(ICVer8192
== 0x2) //B-cut
2219 if(ICVer8256
== 0x5) //E-cut
2220 priv
->card_8192_version
= VERSION_8190_BE
;
2223 switch(priv
->card_8192_version
)
2225 case VERSION_8190_BD
:
2226 case VERSION_8190_BE
:
2229 priv
->card_8192_version
= VERSION_8190_BD
;
2232 RT_TRACE(COMP_INIT
, "\nIC Version = 0x%x\n", priv
->card_8192_version
);
2236 priv
->card_8192_version
= VERSION_8190_BD
;
2237 priv
->eeprom_vid
= 0;
2238 priv
->eeprom_did
= 0;
2239 priv
->eeprom_CustomerID
= 0;
2240 priv
->eeprom_ChannelPlan
= 0;
2241 RT_TRACE(COMP_INIT
, "\nIC Version = 0x%x\n", 0xff);
2244 RT_TRACE(COMP_INIT
, "EEPROM VID = 0x%4x\n", priv
->eeprom_vid
);
2245 RT_TRACE(COMP_INIT
, "EEPROM DID = 0x%4x\n", priv
->eeprom_did
);
2246 RT_TRACE(COMP_INIT
,"EEPROM Customer ID: 0x%2x\n", priv
->eeprom_CustomerID
);
2248 //2 Read Permanent MAC address
2249 if(!priv
->AutoloadFailFlag
)
2251 for(i
= 0; i
< 6; i
+= 2)
2253 usValue
= eprom_read(dev
, (u16
) ((EEPROM_NODE_ADDRESS_BYTE_0
+i
)>>1));
2254 *(u16
*)(&dev
->dev_addr
[i
]) = usValue
;
2257 // when auto load failed, the last address byte set to be a random one.
2258 // added by david woo.2007/11/7
2259 memcpy(dev
->dev_addr
, bMac_Tmp_Addr
, 6);
2262 RT_TRACE(COMP_INIT
, "Permanent Address = %pM\n", dev
->dev_addr
);
2264 //2 TX Power Check EEPROM Fail or not
2265 if(priv
->card_8192_version
> VERSION_8190_BD
) {
2266 priv
->bTXPowerDataReadFromEEPORM
= true;
2268 priv
->bTXPowerDataReadFromEEPORM
= false;
2271 // 2007/11/15 MH 8190PCI Default=2T4R, 8192PCIE default=1T2R
2272 priv
->rf_type
= RTL819X_DEFAULT_RF_TYPE
;
2274 if(priv
->card_8192_version
> VERSION_8190_BD
)
2276 // Read RF-indication and Tx Power gain index diff of legacy to HT OFDM rate.
2277 if(!priv
->AutoloadFailFlag
)
2279 tempval
= (eprom_read(dev
, (EEPROM_RFInd_PowerDiff
>>1))) & 0xff;
2280 priv
->EEPROMLegacyHTTxPowerDiff
= tempval
& 0xf; // bit[3:0]
2282 if (tempval
&0x80) //RF-indication, bit[7]
2283 priv
->rf_type
= RF_1T2R
;
2285 priv
->rf_type
= RF_2T4R
;
2289 priv
->EEPROMLegacyHTTxPowerDiff
= EEPROM_Default_LegacyHTTxPowerDiff
;
2291 RT_TRACE(COMP_INIT
, "EEPROMLegacyHTTxPowerDiff = %d\n",
2292 priv
->EEPROMLegacyHTTxPowerDiff
);
2294 // Read ThermalMeter from EEPROM
2295 if(!priv
->AutoloadFailFlag
)
2297 priv
->EEPROMThermalMeter
= (u8
)(((eprom_read(dev
, (EEPROM_ThermalMeter
>>1))) & 0xff00)>>8);
2301 priv
->EEPROMThermalMeter
= EEPROM_Default_ThermalMeter
;
2303 RT_TRACE(COMP_INIT
, "ThermalMeter = %d\n", priv
->EEPROMThermalMeter
);
2304 //vivi, for tx power track
2305 priv
->TSSI_13dBm
= priv
->EEPROMThermalMeter
*100;
2307 if(priv
->epromtype
== EPROM_93c46
)
2309 // Read antenna tx power offset of B/C/D to A and CrystalCap from EEPROM
2310 if(!priv
->AutoloadFailFlag
)
2312 usValue
= eprom_read(dev
, (EEPROM_TxPwDiff_CrystalCap
>>1));
2313 priv
->EEPROMAntPwDiff
= (usValue
&0x0fff);
2314 priv
->EEPROMCrystalCap
= (u8
)((usValue
&0xf000)>>12);
2318 priv
->EEPROMAntPwDiff
= EEPROM_Default_AntTxPowerDiff
;
2319 priv
->EEPROMCrystalCap
= EEPROM_Default_TxPwDiff_CrystalCap
;
2321 RT_TRACE(COMP_INIT
, "EEPROMAntPwDiff = %d\n", priv
->EEPROMAntPwDiff
);
2322 RT_TRACE(COMP_INIT
, "EEPROMCrystalCap = %d\n", priv
->EEPROMCrystalCap
);
2325 // Get per-channel Tx Power Level
2327 for(i
=0; i
<14; i
+=2)
2329 if(!priv
->AutoloadFailFlag
)
2331 usValue
= eprom_read(dev
, (u16
) ((EEPROM_TxPwIndex_CCK
+i
)>>1) );
2335 usValue
= EEPROM_Default_TxPower
;
2337 *((u16
*)(&priv
->EEPROMTxPowerLevelCCK
[i
])) = usValue
;
2338 RT_TRACE(COMP_INIT
,"CCK Tx Power Level, Index %d = 0x%02x\n", i
, priv
->EEPROMTxPowerLevelCCK
[i
]);
2339 RT_TRACE(COMP_INIT
, "CCK Tx Power Level, Index %d = 0x%02x\n", i
+1, priv
->EEPROMTxPowerLevelCCK
[i
+1]);
2341 for(i
=0; i
<14; i
+=2)
2343 if(!priv
->AutoloadFailFlag
)
2345 usValue
= eprom_read(dev
, (u16
) ((EEPROM_TxPwIndex_OFDM_24G
+i
)>>1) );
2349 usValue
= EEPROM_Default_TxPower
;
2351 *((u16
*)(&priv
->EEPROMTxPowerLevelOFDM24G
[i
])) = usValue
;
2352 RT_TRACE(COMP_INIT
, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i
, priv
->EEPROMTxPowerLevelOFDM24G
[i
]);
2353 RT_TRACE(COMP_INIT
, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i
+1, priv
->EEPROMTxPowerLevelOFDM24G
[i
+1]);
2358 // Update HAL variables.
2360 if(priv
->epromtype
== EPROM_93c46
)
2364 priv
->TxPowerLevelCCK
[i
] = priv
->EEPROMTxPowerLevelCCK
[i
];
2365 priv
->TxPowerLevelOFDM24G
[i
] = priv
->EEPROMTxPowerLevelOFDM24G
[i
];
2367 priv
->LegacyHTTxPowerDiff
= priv
->EEPROMLegacyHTTxPowerDiff
;
2368 // Antenna B gain offset to antenna A, bit0~3
2369 priv
->AntennaTxPwDiff
[0] = (priv
->EEPROMAntPwDiff
& 0xf);
2370 // Antenna C gain offset to antenna A, bit4~7
2371 priv
->AntennaTxPwDiff
[1] = ((priv
->EEPROMAntPwDiff
& 0xf0)>>4);
2372 // Antenna D gain offset to antenna A, bit8~11
2373 priv
->AntennaTxPwDiff
[2] = ((priv
->EEPROMAntPwDiff
& 0xf00)>>8);
2374 // CrystalCap, bit12~15
2375 priv
->CrystalCap
= priv
->EEPROMCrystalCap
;
2376 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2377 priv
->ThermalMeter
[0] = (priv
->EEPROMThermalMeter
& 0xf);
2378 priv
->ThermalMeter
[1] = ((priv
->EEPROMThermalMeter
& 0xf0)>>4);
2380 else if(priv
->epromtype
== EPROM_93c56
)
2382 for(i
=0; i
<3; i
++) // channel 1~3 use the same Tx Power Level.
2384 priv
->TxPowerLevelCCK_A
[i
] = priv
->EEPROMRfACCKChnl1TxPwLevel
[0];
2385 priv
->TxPowerLevelOFDM24G_A
[i
] = priv
->EEPROMRfAOfdmChnlTxPwLevel
[0];
2386 priv
->TxPowerLevelCCK_C
[i
] = priv
->EEPROMRfCCCKChnl1TxPwLevel
[0];
2387 priv
->TxPowerLevelOFDM24G_C
[i
] = priv
->EEPROMRfCOfdmChnlTxPwLevel
[0];
2389 for(i
=3; i
<9; i
++) // channel 4~9 use the same Tx Power Level
2391 priv
->TxPowerLevelCCK_A
[i
] = priv
->EEPROMRfACCKChnl1TxPwLevel
[1];
2392 priv
->TxPowerLevelOFDM24G_A
[i
] = priv
->EEPROMRfAOfdmChnlTxPwLevel
[1];
2393 priv
->TxPowerLevelCCK_C
[i
] = priv
->EEPROMRfCCCKChnl1TxPwLevel
[1];
2394 priv
->TxPowerLevelOFDM24G_C
[i
] = priv
->EEPROMRfCOfdmChnlTxPwLevel
[1];
2396 for(i
=9; i
<14; i
++) // channel 10~14 use the same Tx Power Level
2398 priv
->TxPowerLevelCCK_A
[i
] = priv
->EEPROMRfACCKChnl1TxPwLevel
[2];
2399 priv
->TxPowerLevelOFDM24G_A
[i
] = priv
->EEPROMRfAOfdmChnlTxPwLevel
[2];
2400 priv
->TxPowerLevelCCK_C
[i
] = priv
->EEPROMRfCCCKChnl1TxPwLevel
[2];
2401 priv
->TxPowerLevelOFDM24G_C
[i
] = priv
->EEPROMRfCOfdmChnlTxPwLevel
[2];
2404 RT_TRACE(COMP_INIT
, "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", i
, priv
->TxPowerLevelCCK_A
[i
]);
2406 RT_TRACE(COMP_INIT
,"priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", i
, priv
->TxPowerLevelOFDM24G_A
[i
]);
2408 RT_TRACE(COMP_INIT
, "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", i
, priv
->TxPowerLevelCCK_C
[i
]);
2410 RT_TRACE(COMP_INIT
, "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", i
, priv
->TxPowerLevelOFDM24G_C
[i
]);
2411 priv
->LegacyHTTxPowerDiff
= priv
->EEPROMLegacyHTTxPowerDiff
;
2412 priv
->AntennaTxPwDiff
[0] = 0;
2413 priv
->AntennaTxPwDiff
[1] = 0;
2414 priv
->AntennaTxPwDiff
[2] = 0;
2415 priv
->CrystalCap
= priv
->EEPROMCrystalCap
;
2416 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2417 priv
->ThermalMeter
[0] = (priv
->EEPROMThermalMeter
& 0xf);
2418 priv
->ThermalMeter
[1] = ((priv
->EEPROMThermalMeter
& 0xf0)>>4);
2422 if(priv
->rf_type
== RF_1T2R
)
2424 RT_TRACE(COMP_INIT
, "\n1T2R config\n");
2426 else if (priv
->rf_type
== RF_2T4R
)
2428 RT_TRACE(COMP_INIT
, "\n2T4R config\n");
2431 // 2008/01/16 MH We can only know RF type in the function. So we have to init
2432 // DIG RATR table again.
2433 init_rate_adaptive(dev
);
2435 //1 Make a copy for following variables and we can change them if we want
2437 if(priv
->RegChannelPlan
== 0xf)
2439 priv
->ChannelPlan
= priv
->eeprom_ChannelPlan
;
2443 priv
->ChannelPlan
= priv
->RegChannelPlan
;
2447 // Used PID and DID to Set CustomerID
2449 if( priv
->eeprom_vid
== 0x1186 && priv
->eeprom_did
== 0x3304 )
2451 priv
->CustomerID
= RT_CID_DLINK
;
2454 switch(priv
->eeprom_CustomerID
)
2456 case EEPROM_CID_DEFAULT
:
2457 priv
->CustomerID
= RT_CID_DEFAULT
;
2459 case EEPROM_CID_CAMEO
:
2460 priv
->CustomerID
= RT_CID_819x_CAMEO
;
2462 case EEPROM_CID_RUNTOP
:
2463 priv
->CustomerID
= RT_CID_819x_RUNTOP
;
2465 case EEPROM_CID_NetCore
:
2466 priv
->CustomerID
= RT_CID_819x_Netcore
;
2468 case EEPROM_CID_TOSHIBA
: // Merge by Jacken, 2008/01/31
2469 priv
->CustomerID
= RT_CID_TOSHIBA
;
2470 if(priv
->eeprom_ChannelPlan
&0x80)
2471 priv
->ChannelPlan
= priv
->eeprom_ChannelPlan
&0x7f;
2473 priv
->ChannelPlan
= 0x0;
2474 RT_TRACE(COMP_INIT
, "Toshiba ChannelPlan = 0x%x\n",
2477 case EEPROM_CID_Nettronix
:
2478 priv
->CustomerID
= RT_CID_Nettronix
;
2480 case EEPROM_CID_Pronet
:
2481 priv
->CustomerID
= RT_CID_PRONET
;
2483 case EEPROM_CID_DLINK
:
2484 priv
->CustomerID
= RT_CID_DLINK
;
2487 case EEPROM_CID_WHQL
:
2490 // value from RegCustomerID
2494 //Avoid the channel plan array overflow, by Bruce, 2007-08-27.
2495 if(priv
->ChannelPlan
> CHANNEL_PLAN_LEN
- 1)
2496 priv
->ChannelPlan
= 0; //FCC
2498 switch(priv
->CustomerID
)
2500 case RT_CID_DEFAULT
:
2501 priv
->LedStrategy
= SW_LED_MODE1
;
2504 case RT_CID_819x_CAMEO
:
2505 priv
->LedStrategy
= SW_LED_MODE2
;
2508 case RT_CID_819x_RUNTOP
:
2509 priv
->LedStrategy
= SW_LED_MODE3
;
2512 case RT_CID_819x_Netcore
:
2513 priv
->LedStrategy
= SW_LED_MODE4
;
2516 case RT_CID_Nettronix
:
2517 priv
->LedStrategy
= SW_LED_MODE5
;
2521 priv
->LedStrategy
= SW_LED_MODE6
;
2524 case RT_CID_TOSHIBA
: //Modify by Jacken 2008/01/31
2529 priv
->LedStrategy
= SW_LED_MODE1
;
2534 if( priv
->eeprom_vid
== 0x1186 && priv
->eeprom_did
== 0x3304)
2535 priv
->ieee80211
->bSupportRemoteWakeUp
= true;
2537 priv
->ieee80211
->bSupportRemoteWakeUp
= false;
2540 RT_TRACE(COMP_INIT
, "RegChannelPlan(%d)\n", priv
->RegChannelPlan
);
2541 RT_TRACE(COMP_INIT
, "ChannelPlan = %d \n", priv
->ChannelPlan
);
2542 RT_TRACE(COMP_INIT
, "LedStrategy = %d \n", priv
->LedStrategy
);
2543 RT_TRACE(COMP_TRACE
, "<==== ReadAdapterInfo\n");
2549 static short rtl8192_get_channel_map(struct net_device
* dev
)
2551 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2552 #ifdef ENABLE_DOT11D
2553 if(priv
->ChannelPlan
> COUNTRY_CODE_GLOBAL_DOMAIN
){
2554 printk("rtl8180_init:Error channel plan! Set to default.\n");
2555 priv
->ChannelPlan
= 0;
2557 RT_TRACE(COMP_INIT
, "Channel plan is %d\n",priv
->ChannelPlan
);
2559 rtl819x_set_channel_map(priv
->ChannelPlan
, priv
);
2562 //Set Default Channel Plan
2564 DMESG("No channels, aborting");
2568 priv
->ChannelPlan
= 0;//hikaru
2569 // set channels 1..14 allowed in given locale
2570 for (i
=1; i
<=14; i
++) {
2571 (priv
->ieee80211
->channel_map
)[i
] = (u8
)(ch
& 0x01);
2578 static short rtl8192_init(struct net_device
*dev
)
2580 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2581 memset(&(priv
->stats
),0,sizeof(struct Stats
));
2582 rtl8192_init_priv_variable(dev
);
2583 rtl8192_init_priv_lock(priv
);
2584 rtl8192_init_priv_task(dev
);
2585 rtl8192_get_eeprom_size(dev
);
2586 rtl8192_read_eeprom_info(priv
);
2587 rtl8192_get_channel_map(dev
);
2589 init_timer(&priv
->watch_dog_timer
);
2590 priv
->watch_dog_timer
.data
= (unsigned long)dev
;
2591 priv
->watch_dog_timer
.function
= watch_dog_timer_callback
;
2592 if (request_irq(dev
->irq
, rtl8192_interrupt
, IRQF_SHARED
, dev
->name
, dev
)) {
2593 printk("Error allocating IRQ %d",dev
->irq
);
2597 printk("IRQ %d",dev
->irq
);
2599 if(rtl8192_pci_initdescring(dev
)!=0){
2600 printk("Endopoints initialization failed");
2608 * Actually only set RRSR, RATR and BW_OPMODE registers
2609 * not to do all the hw config as its name says
2610 * This part need to modified according to the rate set we filtered
2612 static void rtl8192_hwconfig(struct net_device
* dev
)
2614 u32 regRATR
= 0, regRRSR
= 0;
2615 u8 regBwOpMode
= 0, regTmp
= 0;
2616 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2618 // Set RRSR, RATR, and BW_OPMODE registers
2620 switch(priv
->ieee80211
->mode
)
2622 case WIRELESS_MODE_B
:
2623 regBwOpMode
= BW_OPMODE_20MHZ
;
2624 regRATR
= RATE_ALL_CCK
;
2625 regRRSR
= RATE_ALL_CCK
;
2627 case WIRELESS_MODE_A
:
2628 regBwOpMode
= BW_OPMODE_5G
|BW_OPMODE_20MHZ
;
2629 regRATR
= RATE_ALL_OFDM_AG
;
2630 regRRSR
= RATE_ALL_OFDM_AG
;
2632 case WIRELESS_MODE_G
:
2633 regBwOpMode
= BW_OPMODE_20MHZ
;
2634 regRATR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
2635 regRRSR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
2637 case WIRELESS_MODE_AUTO
:
2638 case WIRELESS_MODE_N_24G
:
2639 // It support CCK rate by default.
2640 // CCK rate will be filtered out only when associated AP does not support it.
2641 regBwOpMode
= BW_OPMODE_20MHZ
;
2642 regRATR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
| RATE_ALL_OFDM_1SS
| RATE_ALL_OFDM_2SS
;
2643 regRRSR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
2645 case WIRELESS_MODE_N_5G
:
2646 regBwOpMode
= BW_OPMODE_5G
;
2647 regRATR
= RATE_ALL_OFDM_AG
| RATE_ALL_OFDM_1SS
| RATE_ALL_OFDM_2SS
;
2648 regRRSR
= RATE_ALL_OFDM_AG
;
2652 write_nic_byte(priv
, BW_OPMODE
, regBwOpMode
);
2655 ratr_value
= regRATR
;
2656 if (priv
->rf_type
== RF_1T2R
)
2658 ratr_value
&= ~(RATE_ALL_OFDM_2SS
);
2660 write_nic_dword(priv
, RATR0
, ratr_value
);
2661 write_nic_byte(priv
, UFWP
, 1);
2663 regTmp
= read_nic_byte(priv
, 0x313);
2664 regRRSR
= ((regTmp
) << 24) | (regRRSR
& 0x00ffffff);
2665 write_nic_dword(priv
, RRSR
, regRRSR
);
2668 // Set Retry Limit here
2670 write_nic_word(priv
, RETRY_LIMIT
,
2671 priv
->ShortRetryLimit
<< RETRY_LIMIT_SHORT_SHIFT
|
2672 priv
->LongRetryLimit
<< RETRY_LIMIT_LONG_SHIFT
);
2673 // Set Contention Window here
2677 // Set Tx Antenna including Feedback control
2679 // Set Auto Rate fallback control
2685 static RT_STATUS
rtl8192_adapter_start(struct net_device
*dev
)
2687 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2689 RT_STATUS rtStatus
= RT_STATUS_SUCCESS
;
2691 u8 ICVersion
,SwitchingRegulatorOutput
;
2692 bool bfirmwareok
= true;
2693 u32 tmpRegA
, tmpRegC
, TempCCk
;
2696 RT_TRACE(COMP_INIT
, "====>%s()\n", __FUNCTION__
);
2697 priv
->being_init_adapter
= true;
2698 rtl8192_pci_resetdescring(dev
);
2699 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
2700 priv
->Rf_Mode
= RF_OP_By_SW_3wire
;
2703 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
2705 write_nic_byte(priv
, ANAPAR
, 0x37);
2706 // Accordign to designer's explain, LBUS active will never > 10ms. We delay 10ms
2707 // Joseph increae the time to prevent firmware download fail
2711 //PlatformSleepUs(10000);
2712 // For any kind of InitializeAdapter process, we shall use system now!!
2713 priv
->pFirmware
->firmware_status
= FW_STATUS_0_INIT
;
2716 //3 //Config CPUReset Register
2718 //3 Firmware Reset Or Not
2719 ulRegRead
= read_nic_dword(priv
, CPU_GEN
);
2720 if(priv
->pFirmware
->firmware_status
== FW_STATUS_0_INIT
)
2721 { //called from MPInitialized. do nothing
2722 ulRegRead
|= CPU_GEN_SYSTEM_RESET
;
2723 }else if(priv
->pFirmware
->firmware_status
== FW_STATUS_5_READY
)
2724 ulRegRead
|= CPU_GEN_FIRMWARE_RESET
; // Called from MPReset
2726 RT_TRACE(COMP_ERR
, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__
, priv
->pFirmware
->firmware_status
);
2728 write_nic_dword(priv
, CPU_GEN
, ulRegRead
);
2731 //3 //Fix the issue of E-cut high temperature issue
2734 ICVersion
= read_nic_byte(priv
, IC_VERRSION
);
2735 if(ICVersion
>= 0x4) //E-cut only
2737 // HW SD suggest that we should not wirte this register too often, so driver
2738 // should readback this register. This register will be modified only when
2740 SwitchingRegulatorOutput
= read_nic_byte(priv
, SWREGULATOR
);
2741 if(SwitchingRegulatorOutput
!= 0xb8)
2743 write_nic_byte(priv
, SWREGULATOR
, 0xa8);
2745 write_nic_byte(priv
, SWREGULATOR
, 0xb8);
2750 //3// Initialize BB before MAC
2752 RT_TRACE(COMP_INIT
, "BB Config Start!\n");
2753 rtStatus
= rtl8192_BBConfig(dev
);
2754 if(rtStatus
!= RT_STATUS_SUCCESS
)
2756 RT_TRACE(COMP_ERR
, "BB Config failed\n");
2759 RT_TRACE(COMP_INIT
,"BB Config Finished!\n");
2761 //3//Set Loopback mode or Normal mode
2763 //2006.12.13 by emily. Note!We should not merge these two CPU_GEN register writings
2764 // because setting of System_Reset bit reset MAC to default transmission mode.
2765 //Loopback mode or not
2766 priv
->LoopbackMode
= RTL819X_NO_LOOPBACK
;
2767 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
2769 ulRegRead
= read_nic_dword(priv
, CPU_GEN
);
2770 if(priv
->LoopbackMode
== RTL819X_NO_LOOPBACK
)
2772 ulRegRead
= ((ulRegRead
& CPU_GEN_NO_LOOPBACK_MSK
) | CPU_GEN_NO_LOOPBACK_SET
);
2774 else if (priv
->LoopbackMode
== RTL819X_MAC_LOOPBACK
)
2776 ulRegRead
|= CPU_CCK_LOOPBACK
;
2780 RT_TRACE(COMP_ERR
,"Serious error: wrong loopback mode setting\n");
2783 //2008.06.03, for WOL
2784 //ulRegRead &= (~(CPU_GEN_GPIO_UART));
2785 write_nic_dword(priv
, CPU_GEN
, ulRegRead
);
2787 // 2006.11.29. After reset cpu, we sholud wait for a second, otherwise, it may fail to write registers. Emily
2790 //3Set Hardware(Do nothing now)
2791 rtl8192_hwconfig(dev
);
2792 //2=======================================================
2793 // Common Setting for all of the FPGA platform. (part 1)
2794 //2=======================================================
2795 // If there is changes, please make sure it applies to all of the FPGA version
2797 write_nic_byte(priv
, CMDR
, CR_RE
|CR_TE
);
2800 write_nic_byte(priv
, PCIF
, ((MXDMA2_NoLimit
<<MXDMA2_RX_SHIFT
) |
2801 (MXDMA2_NoLimit
<<MXDMA2_TX_SHIFT
) ));
2804 write_nic_dword(priv
, MAC0
, ((u32
*)dev
->dev_addr
)[0]);
2805 write_nic_word(priv
, MAC4
, ((u16
*)(dev
->dev_addr
+ 4))[0]);
2807 write_nic_dword(priv
, RCR
, priv
->ReceiveConfig
);
2809 //3 Initialize Number of Reserved Pages in Firmware Queue
2810 write_nic_dword(priv
, RQPN1
, NUM_OF_PAGE_IN_FW_QUEUE_BK
<< RSVD_FW_QUEUE_PAGE_BK_SHIFT
|
2811 NUM_OF_PAGE_IN_FW_QUEUE_BE
<< RSVD_FW_QUEUE_PAGE_BE_SHIFT
|
2812 NUM_OF_PAGE_IN_FW_QUEUE_VI
<< RSVD_FW_QUEUE_PAGE_VI_SHIFT
|
2813 NUM_OF_PAGE_IN_FW_QUEUE_VO
<<RSVD_FW_QUEUE_PAGE_VO_SHIFT
);
2814 write_nic_dword(priv
, RQPN2
, NUM_OF_PAGE_IN_FW_QUEUE_MGNT
<< RSVD_FW_QUEUE_PAGE_MGNT_SHIFT
);
2815 write_nic_dword(priv
, RQPN3
, APPLIED_RESERVED_QUEUE_IN_FW
|
2816 NUM_OF_PAGE_IN_FW_QUEUE_BCN
<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
|
2817 NUM_OF_PAGE_IN_FW_QUEUE_PUB
<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
);
2819 rtl8192_tx_enable(dev
);
2820 rtl8192_rx_enable(dev
);
2821 //3Set Response Rate Setting Register
2822 // CCK rate is supported by default.
2823 // CCK rate will be filtered out only when associated AP does not support it.
2824 ulRegRead
= (0xFFF00000 & read_nic_dword(priv
, RRSR
)) | RATE_ALL_OFDM_AG
| RATE_ALL_CCK
;
2825 write_nic_dword(priv
, RRSR
, ulRegRead
);
2826 write_nic_dword(priv
, RATR0
+4*7, (RATE_ALL_OFDM_AG
| RATE_ALL_CCK
));
2829 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
2830 write_nic_byte(priv
, ACK_TIMEOUT
, 0x30);
2832 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
2833 rtl8192_SetWirelessMode(dev
, priv
->ieee80211
->mode
);
2834 //-----------------------------------------------------------------------------
2835 // Set up security related. 070106, by rcnjko:
2836 // 1. Clear all H/W keys.
2837 // 2. Enable H/W encryption/decryption.
2838 //-----------------------------------------------------------------------------
2839 CamResetAllEntry(dev
);
2841 u8 SECR_value
= 0x0;
2842 SECR_value
|= SCR_TxEncEnable
;
2843 SECR_value
|= SCR_RxDecEnable
;
2844 SECR_value
|= SCR_NoSKMC
;
2845 write_nic_byte(priv
, SECR
, SECR_value
);
2848 write_nic_word(priv
, ATIMWND
, 2);
2849 write_nic_word(priv
, BCN_INTERVAL
, 100);
2850 for (i
=0; i
<QOS_QUEUE_NUM
; i
++)
2851 write_nic_dword(priv
, WDCAPARA_ADD
[i
], 0x005e4332);
2853 // Switching regulator controller: This is set temporarily.
2854 // It's not sure if this can be removed in the future.
2855 // PJ advised to leave it by default.
2857 write_nic_byte(priv
, 0xbe, 0xc0);
2859 //2=======================================================
2860 // Set PHY related configuration defined in MAC register bank
2861 //2=======================================================
2862 rtl8192_phy_configmac(dev
);
2864 if (priv
->card_8192_version
> (u8
) VERSION_8190_BD
) {
2865 rtl8192_phy_getTxPower(dev
);
2866 rtl8192_phy_setTxPower(dev
, priv
->chan
);
2870 tmpvalue
= read_nic_byte(priv
, IC_VERRSION
);
2871 priv
->IC_Cut
= tmpvalue
;
2872 RT_TRACE(COMP_INIT
, "priv->IC_Cut = 0x%x\n", priv
->IC_Cut
);
2873 if(priv
->IC_Cut
>= IC_VersionCut_D
)
2875 //pHalData->bDcut = TRUE;
2876 if(priv
->IC_Cut
== IC_VersionCut_D
)
2877 RT_TRACE(COMP_INIT
, "D-cut\n");
2878 if(priv
->IC_Cut
== IC_VersionCut_E
)
2880 RT_TRACE(COMP_INIT
, "E-cut\n");
2881 // HW SD suggest that we should not wirte this register too often, so driver
2882 // should readback this register. This register will be modified only when
2888 //pHalData->bDcut = FALSE;
2889 RT_TRACE(COMP_INIT
, "Before C-cut\n");
2893 RT_TRACE(COMP_INIT
, "Load Firmware!\n");
2894 bfirmwareok
= init_firmware(dev
);
2895 if(bfirmwareok
!= true) {
2896 rtStatus
= RT_STATUS_FAILURE
;
2899 RT_TRACE(COMP_INIT
, "Load Firmware finished!\n");
2902 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
2904 RT_TRACE(COMP_INIT
, "RF Config Started!\n");
2905 rtStatus
= rtl8192_phy_RFConfig(dev
);
2906 if(rtStatus
!= RT_STATUS_SUCCESS
)
2908 RT_TRACE(COMP_ERR
, "RF Config failed\n");
2911 RT_TRACE(COMP_INIT
, "RF Config Finished!\n");
2913 rtl8192_phy_updateInitGain(dev
);
2915 /*---- Set CCK and OFDM Block "ON"----*/
2916 rtl8192_setBBreg(dev
, rFPGA0_RFMOD
, bCCKEn
, 0x1);
2917 rtl8192_setBBreg(dev
, rFPGA0_RFMOD
, bOFDMEn
, 0x1);
2920 write_nic_byte(priv
, 0x87, 0x0);
2922 //2=======================================================
2924 //2=======================================================
2928 if(priv
->ieee80211
->RfOffReason
> RF_CHANGE_BY_PS
)
2929 { // H/W or S/W RF OFF before sleep.
2930 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__
,priv
->ieee80211
->RfOffReason
);
2931 MgntActSet_RF_State(dev
, eRfOff
, priv
->ieee80211
->RfOffReason
);
2933 else if(priv
->ieee80211
->RfOffReason
>= RF_CHANGE_BY_IPS
)
2934 { // H/W or S/W RF OFF before sleep.
2935 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__
,priv
->ieee80211
->RfOffReason
);
2936 MgntActSet_RF_State(dev
, eRfOff
, priv
->ieee80211
->RfOffReason
);
2940 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): RF-ON \n",__FUNCTION__
);
2941 priv
->ieee80211
->eRFPowerState
= eRfOn
;
2942 priv
->ieee80211
->RfOffReason
= 0;
2946 // We can force firmware to do RF-R/W
2947 if(priv
->ieee80211
->FwRWRF
)
2948 priv
->Rf_Mode
= RF_OP_By_FW
;
2950 priv
->Rf_Mode
= RF_OP_By_SW_3wire
;
2952 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
2954 dm_initialize_txpower_tracking(dev
);
2956 if(priv
->IC_Cut
>= IC_VersionCut_D
)
2958 tmpRegA
= rtl8192_QueryBBReg(dev
,rOFDM0_XATxIQImbalance
,bMaskDWord
);
2959 tmpRegC
= rtl8192_QueryBBReg(dev
,rOFDM0_XCTxIQImbalance
,bMaskDWord
);
2960 for(i
= 0; i
<TxBBGainTableLength
; i
++)
2962 if(tmpRegA
== priv
->txbbgain_table
[i
].txbbgain_value
)
2964 priv
->rfa_txpowertrackingindex
= (u8
)i
;
2965 priv
->rfa_txpowertrackingindex_real
= (u8
)i
;
2966 priv
->rfa_txpowertracking_default
= priv
->rfa_txpowertrackingindex
;
2971 TempCCk
= rtl8192_QueryBBReg(dev
, rCCK0_TxFilter1
, bMaskByte2
);
2973 for(i
=0 ; i
<CCKTxBBGainTableLength
; i
++)
2975 if(TempCCk
== priv
->cck_txbbgain_table
[i
].ccktxbb_valuearray
[0])
2977 priv
->CCKPresentAttentuation_20Mdefault
=(u8
) i
;
2981 priv
->CCKPresentAttentuation_40Mdefault
= 0;
2982 priv
->CCKPresentAttentuation_difference
= 0;
2983 priv
->CCKPresentAttentuation
= priv
->CCKPresentAttentuation_20Mdefault
;
2984 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_initial = %d\n", priv
->rfa_txpowertrackingindex
);
2985 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv
->rfa_txpowertrackingindex_real
);
2986 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv
->CCKPresentAttentuation_difference
);
2987 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_initial = %d\n", priv
->CCKPresentAttentuation
);
2988 priv
->btxpower_tracking
= FALSE
;//TEMPLY DISABLE
2992 rtl8192_irq_enable(dev
);
2993 priv
->being_init_adapter
= false;
2998 static void rtl8192_prepare_beacon(unsigned long arg
)
3000 struct r8192_priv
*priv
= (struct r8192_priv
*) arg
;
3001 struct sk_buff
*skb
;
3004 skb
= ieee80211_get_beacon(priv
->ieee80211
);
3005 tcb_desc
= (cb_desc
*)(skb
->cb
+ 8);
3006 /* prepare misc info for the beacon xmit */
3007 tcb_desc
->queue_index
= BEACON_QUEUE
;
3008 /* IBSS does not support HT yet, use 1M defaultly */
3009 tcb_desc
->data_rate
= 2;
3010 tcb_desc
->RATRIndex
= 7;
3011 tcb_desc
->bTxDisableRateFallBack
= 1;
3012 tcb_desc
->bTxUseDriverAssingedRate
= 1;
3014 skb_push(skb
, priv
->ieee80211
->tx_headroom
);
3016 rtl8192_tx(priv
->ieee80211
->dev
,skb
);
3022 * configure registers for beacon tx and enables it via
3023 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3024 * be used to stop beacon transmission
3026 static void rtl8192_start_beacon(struct net_device
*dev
)
3028 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
3029 struct ieee80211_network
*net
= &priv
->ieee80211
->current_network
;
3034 DMESG("Enabling beacon TX");
3035 rtl8192_irq_disable(dev
);
3036 //rtl8192_beacon_tx_enable(dev);
3039 write_nic_word(priv
, ATIMWND
, 2);
3041 /* Beacon interval (in unit of TU) */
3042 write_nic_word(priv
, BCN_INTERVAL
, net
->beacon_interval
);
3045 * DrvErlyInt (in unit of TU).
3046 * (Time to send interrupt to notify driver to c
3047 * hange beacon content)
3049 write_nic_word(priv
, BCN_DRV_EARLY_INT
, 10);
3052 * BcnDMATIM(in unit of us).
3053 * Indicates the time before TBTT to perform beacon queue DMA
3055 write_nic_word(priv
, BCN_DMATIME
, 256);
3058 * Force beacon frame transmission even after receiving
3059 * beacon frame from other ad hoc STA
3061 write_nic_byte(priv
, BCN_ERR_THRESH
, 100);
3063 /* Set CW and IFS */
3064 BcnTimeCfg
|= BcnCW
<<BCN_TCFG_CW_SHIFT
;
3065 BcnTimeCfg
|= BcnIFS
<<BCN_TCFG_IFS
;
3066 write_nic_word(priv
, BCN_TCFG
, BcnTimeCfg
);
3069 /* enable the interrupt for ad-hoc process */
3070 rtl8192_irq_enable(dev
);
3073 static bool HalTxCheckStuck8190Pci(struct net_device
*dev
)
3075 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3076 u16 RegTxCounter
= read_nic_word(priv
, 0x128);
3077 bool bStuck
= FALSE
;
3078 RT_TRACE(COMP_RESET
,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__
,RegTxCounter
,priv
->TxCounter
);
3079 if(priv
->TxCounter
==RegTxCounter
)
3082 priv
->TxCounter
= RegTxCounter
;
3088 * Assumption: RT_TX_SPINLOCK is acquired.
3091 TxCheckStuck(struct net_device
*dev
)
3093 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3094 u8 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
3095 bool bCheckFwTxCnt
= false;
3098 // Decide Stuch threshold according to current power save mode
3100 switch (priv
->ieee80211
->dot11PowerSaveMode
)
3102 // The threshold value may required to be adjusted .
3103 case eActive
: // Active/Continuous access.
3104 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_NORMAL
;
3106 case eMaxPs
: // Max power save mode.
3107 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
3109 case eFastPs
: // Fast power save mode.
3110 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
3116 if(HalTxCheckStuck8190Pci(dev
))
3118 RT_TRACE(COMP_RESET
, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3119 return RESET_TYPE_SILENT
;
3123 return RESET_TYPE_NORESET
;
3127 static bool HalRxCheckStuck8190Pci(struct net_device
*dev
)
3129 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3130 u16 RegRxCounter
= read_nic_word(priv
, 0x130);
3131 bool bStuck
= FALSE
;
3133 RT_TRACE(COMP_RESET
,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__
,RegRxCounter
,priv
->RxCounter
);
3134 // If rssi is small, we should check rx for long time because of bad rx.
3135 // or maybe it will continuous silent reset every 2 seconds.
3137 if(priv
->undecorated_smoothed_pwdb
>= (RateAdaptiveTH_High
+5))
3139 priv
->rx_chk_cnt
= 0; /* high rssi, check rx stuck right now. */
3141 else if(priv
->undecorated_smoothed_pwdb
< (RateAdaptiveTH_High
+5) &&
3142 ((priv
->CurrentChannelBW
!=HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
>=RateAdaptiveTH_Low_40M
) ||
3143 (priv
->CurrentChannelBW
==HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
>=RateAdaptiveTH_Low_20M
)) )
3146 if(priv
->rx_chk_cnt
< 2)
3152 priv
->rx_chk_cnt
= 0;
3155 else if(((priv
->CurrentChannelBW
!=HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
<RateAdaptiveTH_Low_40M
) ||
3156 (priv
->CurrentChannelBW
==HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
<RateAdaptiveTH_Low_20M
)) &&
3157 priv
->undecorated_smoothed_pwdb
>= VeryLowRSSI
)
3159 if(priv
->rx_chk_cnt
< 4)
3165 priv
->rx_chk_cnt
= 0;
3170 if(priv
->rx_chk_cnt
< 8)
3176 priv
->rx_chk_cnt
= 0;
3179 if(priv
->RxCounter
==RegRxCounter
)
3182 priv
->RxCounter
= RegRxCounter
;
3187 static RESET_TYPE
RxCheckStuck(struct net_device
*dev
)
3190 if(HalRxCheckStuck8190Pci(dev
))
3192 RT_TRACE(COMP_RESET
, "RxStuck Condition\n");
3193 return RESET_TYPE_SILENT
;
3196 return RESET_TYPE_NORESET
;
3200 rtl819x_ifcheck_resetornot(struct net_device
*dev
)
3202 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3203 RESET_TYPE TxResetType
= RESET_TYPE_NORESET
;
3204 RESET_TYPE RxResetType
= RESET_TYPE_NORESET
;
3205 RT_RF_POWER_STATE rfState
;
3207 rfState
= priv
->ieee80211
->eRFPowerState
;
3209 TxResetType
= TxCheckStuck(dev
);
3211 if( rfState
!= eRfOff
&&
3212 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3213 (priv
->ieee80211
->iw_mode
!= IW_MODE_ADHOC
))
3215 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3216 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3217 // if driver is in firmware download failure status, driver should initialize RF in the following
3218 // silent reset procedure Emily, 2008.01.21
3220 // Driver should not check RX stuck in IBSS mode because it is required to
3221 // set Check BSSID in order to send beacon, however, if check BSSID is
3222 // set, STA cannot hear any packet a all. Emily, 2008.04.12
3223 RxResetType
= RxCheckStuck(dev
);
3226 RT_TRACE(COMP_RESET
,"%s(): TxResetType is %d, RxResetType is %d\n",__FUNCTION__
,TxResetType
,RxResetType
);
3227 if(TxResetType
==RESET_TYPE_NORMAL
|| RxResetType
==RESET_TYPE_NORMAL
)
3228 return RESET_TYPE_NORMAL
;
3229 else if(TxResetType
==RESET_TYPE_SILENT
|| RxResetType
==RESET_TYPE_SILENT
)
3230 return RESET_TYPE_SILENT
;
3232 return RESET_TYPE_NORESET
;
3237 static void CamRestoreAllEntry(struct net_device
*dev
)
3240 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3241 const u8
* MacAddr
= priv
->ieee80211
->current_network
.bssid
;
3243 static const u8 CAM_CONST_ADDR
[4][6] = {
3244 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3245 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3246 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3247 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3248 static const u8 CAM_CONST_BROAD
[] =
3249 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3251 RT_TRACE(COMP_SEC
, "CamRestoreAllEntry: \n");
3254 if ((priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_WEP40
)||
3255 (priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_WEP104
))
3258 for(EntryId
=0; EntryId
<4; EntryId
++)
3261 MacAddr
= CAM_CONST_ADDR
[EntryId
];
3265 priv
->ieee80211
->pairwise_key_type
,
3273 else if(priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_TKIP
)
3277 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3281 priv
->ieee80211
->pairwise_key_type
,
3289 priv
->ieee80211
->pairwise_key_type
,
3295 else if(priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_CCMP
)
3299 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3303 priv
->ieee80211
->pairwise_key_type
,
3311 priv
->ieee80211
->pairwise_key_type
,
3320 if(priv
->ieee80211
->group_key_type
== KEY_TYPE_TKIP
)
3322 MacAddr
= CAM_CONST_BROAD
;
3323 for(EntryId
=1 ; EntryId
<4 ; EntryId
++)
3329 priv
->ieee80211
->group_key_type
,
3335 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3339 priv
->ieee80211
->group_key_type
,
3344 else if(priv
->ieee80211
->group_key_type
== KEY_TYPE_CCMP
)
3346 MacAddr
= CAM_CONST_BROAD
;
3347 for(EntryId
=1; EntryId
<4 ; EntryId
++)
3353 priv
->ieee80211
->group_key_type
,
3360 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3364 priv
->ieee80211
->group_key_type
,
3372 * This function is used to fix Tx/Rx stop bug temporarily.
3373 * This function will do "system reset" to NIC when Tx or Rx is stuck.
3374 * The method checking Tx/Rx stuck of this function is supported by FW,
3375 * which reports Tx and Rx counter to register 0x128 and 0x130.
3377 static void rtl819x_ifsilentreset(struct net_device
*dev
)
3379 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3381 int reset_status
= 0;
3382 struct ieee80211_device
*ieee
= priv
->ieee80211
;
3387 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3388 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3390 if(priv
->ResetProgress
==RESET_TYPE_NORESET
)
3394 //LZM for PS-Poll AID issue. 090429
3395 if(priv
->ieee80211
->state
== IEEE80211_LINKED
)
3396 LeisurePSLeave(dev
);
3399 RT_TRACE(COMP_RESET
,"=========>Reset progress!! \n");
3401 // Set the variable for reset.
3402 priv
->ResetProgress
= RESET_TYPE_SILENT
;
3403 // rtl8192_close(dev);
3405 down(&priv
->wx_sem
);
3408 RT_TRACE(COMP_ERR
,"%s():the driver is not up! return\n",__FUNCTION__
);
3413 RT_TRACE(COMP_RESET
,"%s():======>start to down the driver\n",__FUNCTION__
);
3414 if(!netif_queue_stopped(dev
))
3415 netif_stop_queue(dev
);
3417 dm_backup_dynamic_mechanism_state(dev
);
3419 rtl8192_irq_disable(dev
);
3420 rtl8192_cancel_deferred_work(priv
);
3422 del_timer_sync(&priv
->watch_dog_timer
);
3423 ieee
->sync_scan_hurryup
= 1;
3424 if(ieee
->state
== IEEE80211_LINKED
)
3426 down(&ieee
->wx_sem
);
3427 printk("ieee->state is IEEE80211_LINKED\n");
3428 ieee80211_stop_send_beacons(priv
->ieee80211
);
3429 del_timer_sync(&ieee
->associate_timer
);
3430 cancel_delayed_work(&ieee
->associate_retry_wq
);
3431 ieee80211_stop_scan(ieee
);
3435 printk("ieee->state is NOT LINKED\n");
3436 ieee80211_softmac_stop_protocol(priv
->ieee80211
,true);
3438 rtl8192_halt_adapter(dev
, true);
3440 RT_TRACE(COMP_RESET
,"%s():<==========down process is finished\n",__FUNCTION__
);
3441 RT_TRACE(COMP_RESET
,"%s():===========>start to up the driver\n",__FUNCTION__
);
3442 reset_status
= _rtl8192_up(dev
);
3444 RT_TRACE(COMP_RESET
,"%s():<===========up process is finished\n",__FUNCTION__
);
3445 if(reset_status
== -1)
3454 RT_TRACE(COMP_ERR
," ERR!!! %s(): Reset Failed!!\n",__FUNCTION__
);
3457 ieee
->is_silent_reset
= 1;
3458 EnableHWSecurityConfig8192(dev
);
3459 if(ieee
->state
== IEEE80211_LINKED
&& ieee
->iw_mode
== IW_MODE_INFRA
)
3461 ieee
->set_chan(ieee
->dev
, ieee
->current_network
.channel
);
3463 queue_work(ieee
->wq
, &ieee
->associate_complete_wq
);
3466 else if(ieee
->state
== IEEE80211_LINKED
&& ieee
->iw_mode
== IW_MODE_ADHOC
)
3468 ieee
->set_chan(ieee
->dev
, ieee
->current_network
.channel
);
3469 ieee
->link_change(ieee
->dev
);
3471 // notify_wx_assoc_event(ieee);
3473 ieee80211_start_send_beacons(ieee
);
3475 if (ieee
->data_hard_resume
)
3476 ieee
->data_hard_resume(ieee
->dev
);
3477 netif_carrier_on(ieee
->dev
);
3480 CamRestoreAllEntry(dev
);
3482 // Restore the previous setting for all dynamic mechanism
3483 dm_restore_dynamic_mechanism_state(dev
);
3485 priv
->ResetProgress
= RESET_TYPE_NORESET
;
3486 priv
->reset_count
++;
3488 priv
->bForcedSilentReset
=false;
3489 priv
->bResetInProgress
= false;
3491 // For test --> force write UFWP.
3492 write_nic_byte(priv
, UFWP
, 1);
3493 RT_TRACE(COMP_RESET
, "Reset finished!! ====>[%d]\n", priv
->reset_count
);
3498 void InactivePsWorkItemCallback(struct net_device
*dev
)
3500 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3501 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
3503 RT_TRACE(COMP_POWER
, "InactivePsWorkItemCallback() ---------> \n");
3505 // This flag "bSwRfProcessing", indicates the status of IPS procedure, should be set if the IPS workitem
3506 // is really scheduled.
3507 // The old code, sets this flag before scheduling the IPS workitem and however, at the same time the
3508 // previous IPS workitem did not end yet, fails to schedule the current workitem. Thus, bSwRfProcessing
3509 // blocks the IPS procedure of switching RF.
3510 // By Bruce, 2007-12-25.
3512 pPSC
->bSwRfProcessing
= TRUE
;
3514 RT_TRACE(COMP_RF
, "InactivePsWorkItemCallback(): Set RF to %s.\n",
3515 pPSC
->eInactivePowerState
== eRfOff
?"OFF":"ON");
3518 MgntActSet_RF_State(dev
, pPSC
->eInactivePowerState
, RF_CHANGE_BY_IPS
);
3521 // To solve CAM values miss in RF OFF, rewrite CAM values after RF ON. By Bruce, 2007-09-20.
3523 pPSC
->bSwRfProcessing
= FALSE
;
3524 RT_TRACE(COMP_POWER
, "InactivePsWorkItemCallback() <--------- \n");
3528 /* Change current and default preamble mode. */
3529 bool MgntActSet_802_11_PowerSaveMode(struct net_device
*dev
, u8 rtPsMode
)
3531 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3533 // Currently, we do not change power save mode on IBSS mode.
3534 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3540 // <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
3541 // some AP will not response to our mgnt frames with PwrMgt bit set,
3542 // e.g. cannot associate the AP.
3543 // So I commented out it. 2005.02.16, by rcnjko.
3545 // // Change device's power save mode.
3546 // Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
3548 // Update power save mode configured.
3549 //RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__FUNCTION__,rtPsMode);
3550 if(!priv
->ps_force
) {
3551 priv
->ieee80211
->ps
= rtPsMode
;
3554 // Awake immediately
3555 if(priv
->ieee80211
->sta_sleep
!= 0 && rtPsMode
== IEEE80211_PS_DISABLED
)
3557 unsigned long flags
;
3559 // Notify the AP we awke.
3560 rtl8192_hw_wakeup(dev
);
3561 priv
->ieee80211
->sta_sleep
= 0;
3563 spin_lock_irqsave(&(priv
->ieee80211
->mgmt_tx_lock
), flags
);
3564 printk("LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
3565 ieee80211_sta_ps_send_null_frame(priv
->ieee80211
, 0);
3566 spin_unlock_irqrestore(&(priv
->ieee80211
->mgmt_tx_lock
), flags
);
3572 /* Enter the leisure power save mode. */
3573 void LeisurePSEnter(struct net_device
*dev
)
3575 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3576 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
3578 if(!((priv
->ieee80211
->iw_mode
== IW_MODE_INFRA
) &&
3579 (priv
->ieee80211
->state
== IEEE80211_LINKED
)) ||
3580 (priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
) ||
3581 (priv
->ieee80211
->iw_mode
== IW_MODE_MASTER
))
3584 if (pPSC
->bLeisurePs
)
3586 // Idle for a while if we connect to AP a while ago.
3587 if(pPSC
->LpsIdleCount
>= RT_CHECK_FOR_HANG_PERIOD
) // 4 Sec
3590 if(priv
->ieee80211
->ps
== IEEE80211_PS_DISABLED
)
3592 MgntActSet_802_11_PowerSaveMode(dev
, IEEE80211_PS_MBCAST
|IEEE80211_PS_UNICAST
);
3597 pPSC
->LpsIdleCount
++;
3602 /* Leave leisure power save mode. */
3603 void LeisurePSLeave(struct net_device
*dev
)
3605 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3606 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
3608 if (pPSC
->bLeisurePs
)
3610 if(priv
->ieee80211
->ps
!= IEEE80211_PS_DISABLED
)
3612 // move to lps_wakecomplete()
3613 MgntActSet_802_11_PowerSaveMode(dev
, IEEE80211_PS_DISABLED
);
3621 /* Enter the inactive power save mode. RF will be off */
3623 IPSEnter(struct net_device
*dev
)
3625 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3626 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
3627 RT_RF_POWER_STATE rtState
;
3629 if (pPSC
->bInactivePs
)
3631 rtState
= priv
->ieee80211
->eRFPowerState
;
3633 // Added by Bruce, 2007-12-25.
3634 // Do not enter IPS in the following conditions:
3635 // (1) RF is already OFF or Sleep
3636 // (2) bSwRfProcessing (indicates the IPS is still under going)
3637 // (3) Connectted (only disconnected can trigger IPS)
3638 // (4) IBSS (send Beacon)
3639 // (5) AP mode (send Beacon)
3641 if (rtState
== eRfOn
&& !pPSC
->bSwRfProcessing
3642 && (priv
->ieee80211
->state
!= IEEE80211_LINKED
) )
3644 RT_TRACE(COMP_RF
,"IPSEnter(): Turn off RF.\n");
3645 pPSC
->eInactivePowerState
= eRfOff
;
3646 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
3647 InactivePsWorkItemCallback(dev
);
3654 // Leave the inactive power save mode, RF will be on.
3655 // 2007.08.17, by shien chang.
3658 IPSLeave(struct net_device
*dev
)
3660 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3661 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
3662 RT_RF_POWER_STATE rtState
;
3664 if (pPSC
->bInactivePs
)
3666 rtState
= priv
->ieee80211
->eRFPowerState
;
3667 if (rtState
!= eRfOn
&& !pPSC
->bSwRfProcessing
&& priv
->ieee80211
->RfOffReason
<= RF_CHANGE_BY_IPS
)
3669 RT_TRACE(COMP_POWER
, "IPSLeave(): Turn on RF.\n");
3670 pPSC
->eInactivePowerState
= eRfOn
;
3671 InactivePsWorkItemCallback(dev
);
3676 void IPSLeave_wq(struct work_struct
*work
)
3678 struct ieee80211_device
*ieee
= container_of(work
, struct ieee80211_device
, ips_leave_wq
);
3679 struct net_device
*dev
= ieee
->dev
;
3681 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
3682 down(&priv
->ieee80211
->ips_sem
);
3684 up(&priv
->ieee80211
->ips_sem
);
3687 void ieee80211_ips_leave_wq(struct net_device
*dev
)
3689 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
3690 RT_RF_POWER_STATE rtState
;
3691 rtState
= priv
->ieee80211
->eRFPowerState
;
3693 if(priv
->ieee80211
->PowerSaveControl
.bInactivePs
){
3694 if(rtState
== eRfOff
){
3695 if(priv
->ieee80211
->RfOffReason
> RF_CHANGE_BY_IPS
)
3697 RT_TRACE(COMP_ERR
, "%s(): RF is OFF.\n",__FUNCTION__
);
3701 printk("=========>%s(): IPSLeave\n",__FUNCTION__
);
3702 queue_work(priv
->ieee80211
->wq
,&priv
->ieee80211
->ips_leave_wq
);
3707 //added by amy 090331 end
3708 void ieee80211_ips_leave(struct net_device
*dev
)
3710 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
3711 down(&priv
->ieee80211
->ips_sem
);
3713 up(&priv
->ieee80211
->ips_sem
);
3717 static void rtl819x_update_rxcounts(
3718 struct r8192_priv
*priv
,
3727 *TotalRxDataNum
= 0;
3729 SlotIndex
= (priv
->ieee80211
->LinkDetectInfo
.SlotIndex
++)%(priv
->ieee80211
->LinkDetectInfo
.SlotNum
);
3730 priv
->ieee80211
->LinkDetectInfo
.RxBcnNum
[SlotIndex
] = priv
->ieee80211
->LinkDetectInfo
.NumRecvBcnInPeriod
;
3731 priv
->ieee80211
->LinkDetectInfo
.RxDataNum
[SlotIndex
] = priv
->ieee80211
->LinkDetectInfo
.NumRecvDataInPeriod
;
3732 for( i
=0; i
<priv
->ieee80211
->LinkDetectInfo
.SlotNum
; i
++ ){
3733 *TotalRxBcnNum
+= priv
->ieee80211
->LinkDetectInfo
.RxBcnNum
[i
];
3734 *TotalRxDataNum
+= priv
->ieee80211
->LinkDetectInfo
.RxDataNum
[i
];
3739 static void rtl819x_watchdog_wqcallback(struct work_struct
*work
)
3741 struct delayed_work
*dwork
= container_of(work
,struct delayed_work
,work
);
3742 struct r8192_priv
*priv
= container_of(dwork
,struct r8192_priv
,watch_dog_wq
);
3743 struct net_device
*dev
= priv
->ieee80211
->dev
;
3744 struct ieee80211_device
* ieee
= priv
->ieee80211
;
3745 RESET_TYPE ResetType
= RESET_TYPE_NORESET
;
3746 bool bBusyTraffic
= false;
3747 bool bEnterPS
= false;
3749 if ((!priv
->up
) || priv
->bHwRadioOff
)
3754 hal_dm_watchdog(dev
);
3756 if(ieee
->actscanning
== false){
3757 if((ieee
->iw_mode
== IW_MODE_INFRA
) && (ieee
->state
== IEEE80211_NOLINK
) &&
3758 (ieee
->eRFPowerState
== eRfOn
)&&!ieee
->is_set_key
&&
3759 (!ieee
->proto_stoppping
) && !ieee
->wx_set_enc
){
3760 if(ieee
->PowerSaveControl
.ReturnPoint
== IPS_CALLBACK_NONE
){
3766 {//to get busy traffic condition
3767 if(ieee
->state
== IEEE80211_LINKED
)
3769 if( ieee
->LinkDetectInfo
.NumRxOkInPeriod
> 100 ||
3770 ieee
->LinkDetectInfo
.NumTxOkInPeriod
> 100 ) {
3771 bBusyTraffic
= true;
3775 //added by amy for Leisure PS
3776 if( ((ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
+ ieee
->LinkDetectInfo
.NumTxOkInPeriod
) > 8 ) ||
3777 (ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
> 2) )
3786 // LeisurePS only work in infra mode.
3789 LeisurePSEnter(dev
);
3793 LeisurePSLeave(dev
);
3801 LeisurePSLeave(dev
);
3805 ieee
->LinkDetectInfo
.NumRxOkInPeriod
= 0;
3806 ieee
->LinkDetectInfo
.NumTxOkInPeriod
= 0;
3807 ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
= 0;
3808 ieee
->LinkDetectInfo
.bBusyTraffic
= bBusyTraffic
;
3812 //added by amy for AP roaming
3813 if(ieee
->state
== IEEE80211_LINKED
&& ieee
->iw_mode
== IW_MODE_INFRA
)
3815 u32 TotalRxBcnNum
= 0;
3816 u32 TotalRxDataNum
= 0;
3818 rtl819x_update_rxcounts(priv
, &TotalRxBcnNum
, &TotalRxDataNum
);
3819 if((TotalRxBcnNum
+TotalRxDataNum
) == 0)
3821 if( ieee
->eRFPowerState
== eRfOff
)
3822 RT_TRACE(COMP_ERR
,"========>%s()\n",__FUNCTION__
);
3823 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__
);
3824 // Dot11d_Reset(dev);
3825 ieee
->state
= IEEE80211_ASSOCIATING
;
3826 notify_wx_assoc_event(priv
->ieee80211
);
3827 RemovePeerTS(priv
->ieee80211
,priv
->ieee80211
->current_network
.bssid
);
3828 ieee
->is_roaming
= true;
3829 ieee
->is_set_key
= false;
3830 ieee
->link_change(dev
);
3831 queue_work(ieee
->wq
, &ieee
->associate_procedure_wq
);
3834 ieee
->LinkDetectInfo
.NumRecvBcnInPeriod
=0;
3835 ieee
->LinkDetectInfo
.NumRecvDataInPeriod
=0;
3837 //check if reset the driver
3838 if (priv
->watchdog_check_reset_cnt
++ >= 3 && !ieee
->is_roaming
&&
3839 priv
->watchdog_last_time
!= 1)
3841 ResetType
= rtl819x_ifcheck_resetornot(dev
);
3842 priv
->watchdog_check_reset_cnt
= 3;
3844 if(!priv
->bDisableNormalResetCheck
&& ResetType
== RESET_TYPE_NORMAL
)
3846 priv
->ResetProgress
= RESET_TYPE_NORMAL
;
3847 RT_TRACE(COMP_RESET
,"%s(): NOMAL RESET\n",__FUNCTION__
);
3850 /* disable silent reset temply 2008.9.11*/
3852 if( ((priv
->force_reset
) || (!priv
->bDisableNormalResetCheck
&& ResetType
==RESET_TYPE_SILENT
))) // This is control by OID set in Pomelo
3854 priv
->watchdog_last_time
= 1;
3855 rtl819x_ifsilentreset(dev
);
3858 priv
->watchdog_last_time
= 0;
3860 priv
->force_reset
= false;
3861 priv
->bForcedSilentReset
= false;
3862 priv
->bResetInProgress
= false;
3863 RT_TRACE(COMP_TRACE
, " <==RtUsbCheckForHangWorkItemCallback()\n");
3867 void watch_dog_timer_callback(unsigned long data
)
3869 struct r8192_priv
*priv
= ieee80211_priv((struct net_device
*) data
);
3870 queue_delayed_work(priv
->priv_wq
,&priv
->watch_dog_wq
,0);
3871 mod_timer(&priv
->watch_dog_timer
, jiffies
+ MSECS(IEEE80211_WATCH_DOG_TIME
));
3875 static int _rtl8192_up(struct net_device
*dev
)
3877 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3878 RT_STATUS init_status
= RT_STATUS_SUCCESS
;
3880 priv
->ieee80211
->ieee_up
=1;
3881 priv
->bdisable_nic
= false; //YJ,add,091111
3882 RT_TRACE(COMP_INIT
, "Bringing up iface");
3884 init_status
= rtl8192_adapter_start(dev
);
3885 if(init_status
!= RT_STATUS_SUCCESS
)
3887 RT_TRACE(COMP_ERR
,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__
);
3890 RT_TRACE(COMP_INIT
, "start adapter finished\n");
3892 if(priv
->ieee80211
->eRFPowerState
!=eRfOn
)
3893 MgntActSet_RF_State(dev
, eRfOn
, priv
->ieee80211
->RfOffReason
);
3895 if(priv
->ieee80211
->state
!= IEEE80211_LINKED
)
3896 ieee80211_softmac_start_protocol(priv
->ieee80211
);
3897 ieee80211_reset_queue(priv
->ieee80211
);
3898 watch_dog_timer_callback((unsigned long) dev
);
3899 if(!netif_queue_stopped(dev
))
3900 netif_start_queue(dev
);
3902 netif_wake_queue(dev
);
3908 static int rtl8192_open(struct net_device
*dev
)
3910 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3913 down(&priv
->wx_sem
);
3914 ret
= rtl8192_up(dev
);
3921 int rtl8192_up(struct net_device
*dev
)
3923 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3925 if (priv
->up
== 1) return -1;
3927 return _rtl8192_up(dev
);
3931 static int rtl8192_close(struct net_device
*dev
)
3933 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3936 down(&priv
->wx_sem
);
3938 ret
= rtl8192_down(dev
);
3946 int rtl8192_down(struct net_device
*dev
)
3948 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3950 if (priv
->up
== 0) return -1;
3953 //LZM for PS-Poll AID issue. 090429
3954 if(priv
->ieee80211
->state
== IEEE80211_LINKED
)
3955 LeisurePSLeave(dev
);
3959 priv
->ieee80211
->ieee_up
= 0;
3960 RT_TRACE(COMP_DOWN
, "==========>%s()\n", __FUNCTION__
);
3962 if (!netif_queue_stopped(dev
))
3963 netif_stop_queue(dev
);
3965 rtl8192_irq_disable(dev
);
3966 rtl8192_cancel_deferred_work(priv
);
3968 del_timer_sync(&priv
->watch_dog_timer
);
3970 ieee80211_softmac_stop_protocol(priv
->ieee80211
,true);
3972 rtl8192_halt_adapter(dev
,false);
3973 memset(&priv
->ieee80211
->current_network
, 0 , offsetof(struct ieee80211_network
, list
));
3975 RT_TRACE(COMP_DOWN
, "<==========%s()\n", __FUNCTION__
);
3981 void rtl8192_commit(struct net_device
*dev
)
3983 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3985 if (priv
->up
== 0) return ;
3988 ieee80211_softmac_stop_protocol(priv
->ieee80211
,true);
3990 rtl8192_irq_disable(dev
);
3991 rtl8192_halt_adapter(dev
,true);
3995 static void rtl8192_restart(struct work_struct
*work
)
3997 struct r8192_priv
*priv
= container_of(work
, struct r8192_priv
, reset_wq
);
3998 struct net_device
*dev
= priv
->ieee80211
->dev
;
4000 down(&priv
->wx_sem
);
4002 rtl8192_commit(dev
);
4007 static void r8192_set_multicast(struct net_device
*dev
)
4009 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4011 priv
->promisc
= (dev
->flags
& IFF_PROMISC
) ? 1 : 0;
4015 static int r8192_set_mac_adr(struct net_device
*dev
, void *mac
)
4017 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4018 struct sockaddr
*addr
= mac
;
4020 down(&priv
->wx_sem
);
4022 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
4024 schedule_work(&priv
->reset_wq
);
4030 /* based on ipw2200 driver */
4031 static int rtl8192_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
4033 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4034 struct iwreq
*wrq
= (struct iwreq
*)rq
;
4036 struct ieee80211_device
*ieee
= priv
->ieee80211
;
4038 u8 broadcast_addr
[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4039 struct iw_point
*p
= &wrq
->u
.data
;
4040 struct ieee_param
*ipw
= NULL
;//(struct ieee_param *)wrq->u.data.pointer;
4042 down(&priv
->wx_sem
);
4045 if (p
->length
< sizeof(struct ieee_param
) || !p
->pointer
){
4050 ipw
= kmalloc(p
->length
, GFP_KERNEL
);
4055 if (copy_from_user(ipw
, p
->pointer
, p
->length
)) {
4062 case RTL_IOCTL_WPA_SUPPLICANT
:
4063 //parse here for HW security
4064 if (ipw
->cmd
== IEEE_CMD_SET_ENCRYPTION
)
4066 if (ipw
->u
.crypt
.set_tx
)
4068 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
4069 ieee
->pairwise_key_type
= KEY_TYPE_CCMP
;
4070 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
4071 ieee
->pairwise_key_type
= KEY_TYPE_TKIP
;
4072 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0)
4074 if (ipw
->u
.crypt
.key_len
== 13)
4075 ieee
->pairwise_key_type
= KEY_TYPE_WEP104
;
4076 else if (ipw
->u
.crypt
.key_len
== 5)
4077 ieee
->pairwise_key_type
= KEY_TYPE_WEP40
;
4080 ieee
->pairwise_key_type
= KEY_TYPE_NA
;
4082 if (ieee
->pairwise_key_type
)
4084 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
4085 EnableHWSecurityConfig8192(dev
);
4086 //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!
4088 setKey(dev
, 4, ipw
->u
.crypt
.idx
, ieee
->pairwise_key_type
, (u8
*)ieee
->ap_mac_addr
, 0, key
);
4089 if (ieee
->auth_mode
!= 2) //LEAP WEP will never set this.
4090 setKey(dev
, ipw
->u
.crypt
.idx
, ipw
->u
.crypt
.idx
, ieee
->pairwise_key_type
, (u8
*)ieee
->ap_mac_addr
, 0, key
);
4092 if ((ieee
->pairwise_key_type
== KEY_TYPE_CCMP
) && ieee
->pHTInfo
->bCurrentHTSupport
){
4093 write_nic_byte(priv
, 0x173, 1); //fix aes bug
4097 else //if (ipw->u.crypt.idx) //group key use idx > 0
4099 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
4100 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
4101 ieee
->group_key_type
= KEY_TYPE_CCMP
;
4102 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
4103 ieee
->group_key_type
= KEY_TYPE_TKIP
;
4104 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0)
4106 if (ipw
->u
.crypt
.key_len
== 13)
4107 ieee
->group_key_type
= KEY_TYPE_WEP104
;
4108 else if (ipw
->u
.crypt
.key_len
== 5)
4109 ieee
->group_key_type
= KEY_TYPE_WEP40
;
4112 ieee
->group_key_type
= KEY_TYPE_NA
;
4114 if (ieee
->group_key_type
)
4118 ipw
->u
.crypt
.idx
, //KeyIndex
4119 ieee
->group_key_type
, //KeyType
4120 broadcast_addr
, //MacAddr
4126 ret
= ieee80211_wpa_supplicant_ioctl(priv
->ieee80211
, &wrq
->u
.data
);
4141 static u8
HwRateToMRate90(bool bIsHT
, u8 rate
)
4147 case DESC90_RATE1M
: ret_rate
= MGN_1M
; break;
4148 case DESC90_RATE2M
: ret_rate
= MGN_2M
; break;
4149 case DESC90_RATE5_5M
: ret_rate
= MGN_5_5M
; break;
4150 case DESC90_RATE11M
: ret_rate
= MGN_11M
; break;
4151 case DESC90_RATE6M
: ret_rate
= MGN_6M
; break;
4152 case DESC90_RATE9M
: ret_rate
= MGN_9M
; break;
4153 case DESC90_RATE12M
: ret_rate
= MGN_12M
; break;
4154 case DESC90_RATE18M
: ret_rate
= MGN_18M
; break;
4155 case DESC90_RATE24M
: ret_rate
= MGN_24M
; break;
4156 case DESC90_RATE36M
: ret_rate
= MGN_36M
; break;
4157 case DESC90_RATE48M
: ret_rate
= MGN_48M
; break;
4158 case DESC90_RATE54M
: ret_rate
= MGN_54M
; break;
4161 RT_TRACE(COMP_RECV
, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate
, bIsHT
);
4167 case DESC90_RATEMCS0
: ret_rate
= MGN_MCS0
; break;
4168 case DESC90_RATEMCS1
: ret_rate
= MGN_MCS1
; break;
4169 case DESC90_RATEMCS2
: ret_rate
= MGN_MCS2
; break;
4170 case DESC90_RATEMCS3
: ret_rate
= MGN_MCS3
; break;
4171 case DESC90_RATEMCS4
: ret_rate
= MGN_MCS4
; break;
4172 case DESC90_RATEMCS5
: ret_rate
= MGN_MCS5
; break;
4173 case DESC90_RATEMCS6
: ret_rate
= MGN_MCS6
; break;
4174 case DESC90_RATEMCS7
: ret_rate
= MGN_MCS7
; break;
4175 case DESC90_RATEMCS8
: ret_rate
= MGN_MCS8
; break;
4176 case DESC90_RATEMCS9
: ret_rate
= MGN_MCS9
; break;
4177 case DESC90_RATEMCS10
: ret_rate
= MGN_MCS10
; break;
4178 case DESC90_RATEMCS11
: ret_rate
= MGN_MCS11
; break;
4179 case DESC90_RATEMCS12
: ret_rate
= MGN_MCS12
; break;
4180 case DESC90_RATEMCS13
: ret_rate
= MGN_MCS13
; break;
4181 case DESC90_RATEMCS14
: ret_rate
= MGN_MCS14
; break;
4182 case DESC90_RATEMCS15
: ret_rate
= MGN_MCS15
; break;
4183 case DESC90_RATEMCS32
: ret_rate
= (0x80|0x20); break;
4186 RT_TRACE(COMP_RECV
, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate
, bIsHT
);
4194 /* Record the TSF time stamp when receiving a packet */
4195 static void UpdateRxPktTimeStamp8190 (struct net_device
*dev
, struct ieee80211_rx_stats
*stats
)
4197 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4199 if(stats
->bIsAMPDU
&& !stats
->bFirstMPDU
) {
4200 stats
->mac_time
[0] = priv
->LastRxDescTSFLow
;
4201 stats
->mac_time
[1] = priv
->LastRxDescTSFHigh
;
4203 priv
->LastRxDescTSFLow
= stats
->mac_time
[0];
4204 priv
->LastRxDescTSFHigh
= stats
->mac_time
[1];
4208 static long rtl819x_translate_todbm(u8 signal_strength_index
)// 0-100 index.
4210 long signal_power
; // in dBm.
4212 // Translate to dBm (x=0.5y-95).
4213 signal_power
= (long)((signal_strength_index
+ 1) >> 1);
4216 return signal_power
;
4219 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
4220 be a local static. Otherwise, it may increase when we return from S3/S4. The
4221 value will be kept in memory or disk. We must delcare the value in adapter
4222 and it will be reinitialized when return from S3/S4. */
4223 static void rtl8192_process_phyinfo(struct r8192_priv
* priv
, u8
* buffer
,struct ieee80211_rx_stats
* pprevious_stats
, struct ieee80211_rx_stats
* pcurrent_stats
)
4225 bool bcheck
= false;
4227 u32 nspatial_stream
, tmp_val
;
4228 static u32 slide_rssi_index
=0, slide_rssi_statistics
=0;
4229 static u32 slide_evm_index
=0, slide_evm_statistics
=0;
4230 static u32 last_rssi
=0, last_evm
=0;
4231 //cosa add for beacon rssi smoothing
4232 static u32 slide_beacon_adc_pwdb_index
=0, slide_beacon_adc_pwdb_statistics
=0;
4233 static u32 last_beacon_adc_pwdb
=0;
4235 struct ieee80211_hdr_3addr
*hdr
;
4237 unsigned int frag
,seq
;
4238 hdr
= (struct ieee80211_hdr_3addr
*)buffer
;
4239 sc
= le16_to_cpu(hdr
->seq_ctl
);
4240 frag
= WLAN_GET_SEQ_FRAG(sc
);
4241 seq
= WLAN_GET_SEQ_SEQ(sc
);
4242 //cosa add 04292008 to record the sequence number
4243 pcurrent_stats
->Seq_Num
= seq
;
4245 // Check whether we should take the previous packet into accounting
4247 if(!pprevious_stats
->bIsAMPDU
)
4249 // if previous packet is not aggregated packet
4253 if(slide_rssi_statistics
++ >= PHY_RSSI_SLID_WIN_MAX
)
4255 slide_rssi_statistics
= PHY_RSSI_SLID_WIN_MAX
;
4256 last_rssi
= priv
->stats
.slide_signal_strength
[slide_rssi_index
];
4257 priv
->stats
.slide_rssi_total
-= last_rssi
;
4259 priv
->stats
.slide_rssi_total
+= pprevious_stats
->SignalStrength
;
4261 priv
->stats
.slide_signal_strength
[slide_rssi_index
++] = pprevious_stats
->SignalStrength
;
4262 if(slide_rssi_index
>= PHY_RSSI_SLID_WIN_MAX
)
4263 slide_rssi_index
= 0;
4265 // <1> Showed on UI for user, in dbm
4266 tmp_val
= priv
->stats
.slide_rssi_total
/slide_rssi_statistics
;
4267 priv
->stats
.signal_strength
= rtl819x_translate_todbm((u8
)tmp_val
);
4268 pcurrent_stats
->rssi
= priv
->stats
.signal_strength
;
4270 // If the previous packet does not match the criteria, neglect it
4272 if(!pprevious_stats
->bPacketMatchBSSID
)
4274 if(!pprevious_stats
->bToSelfBA
)
4281 // <2> Showed on UI for engineering
4282 // hardware does not provide rssi information for each rf path in CCK
4283 if(!pprevious_stats
->bIsCCK
&& pprevious_stats
->bPacketToSelf
)
4285 for (rfpath
= RF90_PATH_A
; rfpath
< RF90_PATH_C
; rfpath
++)
4287 if (!rtl8192_phy_CheckIsLegalRFPath(priv
->ieee80211
->dev
, rfpath
))
4289 RT_TRACE(COMP_DBG
,"Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d \n" ,pprevious_stats
->RxMIMOSignalStrength
[rfpath
] );
4290 //Fixed by Jacken 2008-03-20
4291 if(priv
->stats
.rx_rssi_percentage
[rfpath
] == 0)
4293 priv
->stats
.rx_rssi_percentage
[rfpath
] = pprevious_stats
->RxMIMOSignalStrength
[rfpath
];
4295 if(pprevious_stats
->RxMIMOSignalStrength
[rfpath
] > priv
->stats
.rx_rssi_percentage
[rfpath
])
4297 priv
->stats
.rx_rssi_percentage
[rfpath
] =
4298 ( (priv
->stats
.rx_rssi_percentage
[rfpath
]*(Rx_Smooth_Factor
-1)) +
4299 (pprevious_stats
->RxMIMOSignalStrength
[rfpath
])) /(Rx_Smooth_Factor
);
4300 priv
->stats
.rx_rssi_percentage
[rfpath
] = priv
->stats
.rx_rssi_percentage
[rfpath
] + 1;
4304 priv
->stats
.rx_rssi_percentage
[rfpath
] =
4305 ( (priv
->stats
.rx_rssi_percentage
[rfpath
]*(Rx_Smooth_Factor
-1)) +
4306 (pprevious_stats
->RxMIMOSignalStrength
[rfpath
])) /(Rx_Smooth_Factor
);
4308 RT_TRACE(COMP_DBG
,"Jacken -> priv->RxStats.RxRSSIPercentage[rfPath] = %d \n" ,priv
->stats
.rx_rssi_percentage
[rfpath
] );
4316 //cosa add for beacon rssi smoothing by average.
4317 if(pprevious_stats
->bPacketBeacon
)
4319 /* record the beacon pwdb to the sliding window. */
4320 if(slide_beacon_adc_pwdb_statistics
++ >= PHY_Beacon_RSSI_SLID_WIN_MAX
)
4322 slide_beacon_adc_pwdb_statistics
= PHY_Beacon_RSSI_SLID_WIN_MAX
;
4323 last_beacon_adc_pwdb
= priv
->stats
.Slide_Beacon_pwdb
[slide_beacon_adc_pwdb_index
];
4324 priv
->stats
.Slide_Beacon_Total
-= last_beacon_adc_pwdb
;
4325 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
4327 priv
->stats
.Slide_Beacon_Total
+= pprevious_stats
->RxPWDBAll
;
4328 priv
->stats
.Slide_Beacon_pwdb
[slide_beacon_adc_pwdb_index
] = pprevious_stats
->RxPWDBAll
;
4329 slide_beacon_adc_pwdb_index
++;
4330 if(slide_beacon_adc_pwdb_index
>= PHY_Beacon_RSSI_SLID_WIN_MAX
)
4331 slide_beacon_adc_pwdb_index
= 0;
4332 pprevious_stats
->RxPWDBAll
= priv
->stats
.Slide_Beacon_Total
/slide_beacon_adc_pwdb_statistics
;
4333 if(pprevious_stats
->RxPWDBAll
>= 3)
4334 pprevious_stats
->RxPWDBAll
-= 3;
4337 RT_TRACE(COMP_RXDESC
, "Smooth %s PWDB = %d\n",
4338 pprevious_stats
->bIsCCK
? "CCK": "OFDM",
4339 pprevious_stats
->RxPWDBAll
);
4341 if(pprevious_stats
->bPacketToSelf
|| pprevious_stats
->bPacketBeacon
|| pprevious_stats
->bToSelfBA
)
4343 if(priv
->undecorated_smoothed_pwdb
< 0) // initialize
4345 priv
->undecorated_smoothed_pwdb
= pprevious_stats
->RxPWDBAll
;
4348 if(pprevious_stats
->RxPWDBAll
> (u32
)priv
->undecorated_smoothed_pwdb
)
4350 priv
->undecorated_smoothed_pwdb
=
4351 ( ((priv
->undecorated_smoothed_pwdb
)*(Rx_Smooth_Factor
-1)) +
4352 (pprevious_stats
->RxPWDBAll
)) /(Rx_Smooth_Factor
);
4353 priv
->undecorated_smoothed_pwdb
= priv
->undecorated_smoothed_pwdb
+ 1;
4357 priv
->undecorated_smoothed_pwdb
=
4358 ( ((priv
->undecorated_smoothed_pwdb
)*(Rx_Smooth_Factor
-1)) +
4359 (pprevious_stats
->RxPWDBAll
)) /(Rx_Smooth_Factor
);
4366 /* record the general EVM to the sliding window. */
4367 if(pprevious_stats
->SignalQuality
== 0)
4372 if(pprevious_stats
->bPacketToSelf
|| pprevious_stats
->bPacketBeacon
|| pprevious_stats
->bToSelfBA
){
4373 if(slide_evm_statistics
++ >= PHY_RSSI_SLID_WIN_MAX
){
4374 slide_evm_statistics
= PHY_RSSI_SLID_WIN_MAX
;
4375 last_evm
= priv
->stats
.slide_evm
[slide_evm_index
];
4376 priv
->stats
.slide_evm_total
-= last_evm
;
4379 priv
->stats
.slide_evm_total
+= pprevious_stats
->SignalQuality
;
4381 priv
->stats
.slide_evm
[slide_evm_index
++] = pprevious_stats
->SignalQuality
;
4382 if(slide_evm_index
>= PHY_RSSI_SLID_WIN_MAX
)
4383 slide_evm_index
= 0;
4385 // <1> Showed on UI for user, in percentage.
4386 tmp_val
= priv
->stats
.slide_evm_total
/slide_evm_statistics
;
4387 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
4390 // <2> Showed on UI for engineering
4391 if(pprevious_stats
->bPacketToSelf
|| pprevious_stats
->bPacketBeacon
|| pprevious_stats
->bToSelfBA
)
4393 for(nspatial_stream
= 0; nspatial_stream
<2 ; nspatial_stream
++) // 2 spatial stream
4395 if(pprevious_stats
->RxMIMOSignalQuality
[nspatial_stream
] != -1)
4397 if(priv
->stats
.rx_evm_percentage
[nspatial_stream
] == 0) // initialize
4399 priv
->stats
.rx_evm_percentage
[nspatial_stream
] = pprevious_stats
->RxMIMOSignalQuality
[nspatial_stream
];
4401 priv
->stats
.rx_evm_percentage
[nspatial_stream
] =
4402 ( (priv
->stats
.rx_evm_percentage
[nspatial_stream
]* (Rx_Smooth_Factor
-1)) +
4403 (pprevious_stats
->RxMIMOSignalQuality
[nspatial_stream
]* 1)) / (Rx_Smooth_Factor
);
4411 static u8
rtl819x_query_rxpwrpercentage(
4415 if ((antpower
<= -100) || (antpower
>= 20))
4419 else if (antpower
>= 0)
4425 return (100+antpower
);
4431 rtl819x_evm_dbtopercentage(
4443 ret_val
= 0 - ret_val
;
4450 /* We want good-looking for signal strength/quality */
4451 static long rtl819x_signal_scale_mapping(long currsig
)
4455 // Step 1. Scale mapping.
4456 if(currsig
>= 61 && currsig
<= 100)
4458 retsig
= 90 + ((currsig
- 60) / 4);
4460 else if(currsig
>= 41 && currsig
<= 60)
4462 retsig
= 78 + ((currsig
- 40) / 2);
4464 else if(currsig
>= 31 && currsig
<= 40)
4466 retsig
= 66 + (currsig
- 30);
4468 else if(currsig
>= 21 && currsig
<= 30)
4470 retsig
= 54 + (currsig
- 20);
4472 else if(currsig
>= 5 && currsig
<= 20)
4474 retsig
= 42 + (((currsig
- 5) * 2) / 3);
4476 else if(currsig
== 4)
4480 else if(currsig
== 3)
4484 else if(currsig
== 2)
4488 else if(currsig
== 1)
4500 static void rtl8192_query_rxphystatus(
4501 struct r8192_priv
* priv
,
4502 struct ieee80211_rx_stats
* pstats
,
4503 prx_desc_819x_pci pdesc
,
4504 prx_fwinfo_819x_pci pdrvinfo
,
4505 struct ieee80211_rx_stats
* precord_stats
,
4506 bool bpacket_match_bssid
,
4507 bool bpacket_toself
,
4512 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
4513 phy_sts_ofdm_819xpci_t
* pofdm_buf
;
4514 phy_sts_cck_819xpci_t
* pcck_buf
;
4515 phy_ofdm_rx_status_rxsc_sgien_exintfflag
* prxsc
;
4517 u8 i
,max_spatial_stream
, tmp_rxsnr
, tmp_rxevm
, rxsc_sgien_exflg
;
4518 char rx_pwr
[4], rx_pwr_all
=0;
4519 //long rx_avg_pwr = 0;
4520 char rx_snrX
, rx_evmX
;
4522 u32 RSSI
, total_rssi
=0;//, total_evm=0;
4523 // long signal_strength_index = 0;
4527 is_cck_rate
= rx_hal_is_cck_rate(pdrvinfo
);
4529 // Record it for next packet processing
4530 memset(precord_stats
, 0, sizeof(struct ieee80211_rx_stats
));
4531 pstats
->bPacketMatchBSSID
= precord_stats
->bPacketMatchBSSID
= bpacket_match_bssid
;
4532 pstats
->bPacketToSelf
= precord_stats
->bPacketToSelf
= bpacket_toself
;
4533 pstats
->bIsCCK
= precord_stats
->bIsCCK
= is_cck_rate
;//RX_HAL_IS_CCK_RATE(pDrvInfo);
4534 pstats
->bPacketBeacon
= precord_stats
->bPacketBeacon
= bPacketBeacon
;
4535 pstats
->bToSelfBA
= precord_stats
->bToSelfBA
= bToSelfBA
;
4536 /*2007.08.30 requested by SD3 Jerry */
4537 if (priv
->phy_check_reg824
== 0)
4539 priv
->phy_reg824_bit9
= rtl8192_QueryBBReg(priv
->ieee80211
->dev
, rFPGA0_XA_HSSIParameter2
, 0x200);
4540 priv
->phy_check_reg824
= 1;
4544 prxpkt
= (u8
*)pdrvinfo
;
4546 /* Move pointer to the 16th bytes. Phy status start address. */
4547 prxpkt
+= sizeof(rx_fwinfo_819x_pci
);
4549 /* Initial the cck and ofdm buffer pointer */
4550 pcck_buf
= (phy_sts_cck_819xpci_t
*)prxpkt
;
4551 pofdm_buf
= (phy_sts_ofdm_819xpci_t
*)prxpkt
;
4553 pstats
->RxMIMOSignalQuality
[0] = -1;
4554 pstats
->RxMIMOSignalQuality
[1] = -1;
4555 precord_stats
->RxMIMOSignalQuality
[0] = -1;
4556 precord_stats
->RxMIMOSignalQuality
[1] = -1;
4561 // (1)Hardware does not provide RSSI for CCK
4565 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4567 u8 report
;//, cck_agc_rpt;
4569 if (!priv
->phy_reg824_bit9
)
4571 report
= pcck_buf
->cck_agc_rpt
& 0xc0;
4575 //Fixed by Jacken from Bryant 2008-03-20
4576 //Original value is -38 , -26 , -14 , -2
4577 //Fixed value is -35 , -23 , -11 , 6
4579 rx_pwr_all
= -35 - (pcck_buf
->cck_agc_rpt
& 0x3e);
4582 rx_pwr_all
= -23 - (pcck_buf
->cck_agc_rpt
& 0x3e);
4585 rx_pwr_all
= -11 - (pcck_buf
->cck_agc_rpt
& 0x3e);
4588 rx_pwr_all
= 8 - (pcck_buf
->cck_agc_rpt
& 0x3e);
4594 report
= pcck_buf
->cck_agc_rpt
& 0x60;
4599 rx_pwr_all
= -35 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1) ;
4602 rx_pwr_all
= -23 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1);
4605 rx_pwr_all
= -11 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1) ;
4608 rx_pwr_all
= -8 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1) ;
4613 pwdb_all
= rtl819x_query_rxpwrpercentage(rx_pwr_all
);
4614 pstats
->RxPWDBAll
= precord_stats
->RxPWDBAll
= pwdb_all
;
4615 pstats
->RecvSignalPower
= rx_pwr_all
;
4618 // (3) Get Signal Quality (EVM)
4620 if(bpacket_match_bssid
)
4624 if(pstats
->RxPWDBAll
> 40)
4629 sq
= pcck_buf
->sq_rpt
;
4631 if(pcck_buf
->sq_rpt
> 64)
4633 else if (pcck_buf
->sq_rpt
< 20)
4636 sq
= ((64-sq
) * 100) / 44;
4638 pstats
->SignalQuality
= precord_stats
->SignalQuality
= sq
;
4639 pstats
->RxMIMOSignalQuality
[0] = precord_stats
->RxMIMOSignalQuality
[0] = sq
;
4640 pstats
->RxMIMOSignalQuality
[1] = precord_stats
->RxMIMOSignalQuality
[1] = -1;
4646 // (1)Get RSSI for HT rate
4648 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
4650 // 2008/01/30 MH we will judge RF RX path now.
4651 if (priv
->brfpath_rxenable
[i
])
4656 //Fixed by Jacken from Bryant 2008-03-20
4657 //Original value is 106
4658 rx_pwr
[i
] = ((pofdm_buf
->trsw_gain_X
[i
]&0x3F)*2) - 110;
4660 //Get Rx snr value in DB
4661 tmp_rxsnr
= pofdm_buf
->rxsnr_X
[i
];
4662 rx_snrX
= (char)(tmp_rxsnr
);
4665 /* Translate DBM to percentage. */
4666 RSSI
= rtl819x_query_rxpwrpercentage(rx_pwr
[i
]);
4667 if (priv
->brfpath_rxenable
[i
])
4670 /* Record Signal Strength for next packet */
4671 if(bpacket_match_bssid
)
4673 pstats
->RxMIMOSignalStrength
[i
] =(u8
) RSSI
;
4674 precord_stats
->RxMIMOSignalStrength
[i
] =(u8
) RSSI
;
4680 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4682 //Fixed by Jacken from Bryant 2008-03-20
4683 //Original value is 106
4684 rx_pwr_all
= (((pofdm_buf
->pwdb_all
) >> 1 )& 0x7f) -106;
4685 pwdb_all
= rtl819x_query_rxpwrpercentage(rx_pwr_all
);
4687 pstats
->RxPWDBAll
= precord_stats
->RxPWDBAll
= pwdb_all
;
4688 pstats
->RxPower
= precord_stats
->RxPower
= rx_pwr_all
;
4689 pstats
->RecvSignalPower
= rx_pwr_all
;
4691 // (3)EVM of HT rate
4693 if(pdrvinfo
->RxHT
&& pdrvinfo
->RxRate
>=DESC90_RATEMCS8
&&
4694 pdrvinfo
->RxRate
<=DESC90_RATEMCS15
)
4695 max_spatial_stream
= 2; //both spatial stream make sense
4697 max_spatial_stream
= 1; //only spatial stream 1 makes sense
4699 for(i
=0; i
<max_spatial_stream
; i
++)
4701 tmp_rxevm
= pofdm_buf
->rxevm_X
[i
];
4702 rx_evmX
= (char)(tmp_rxevm
);
4704 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
4705 // fill most significant bit to "zero" when doing shifting operation which may change a negative
4706 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
4709 evm
= rtl819x_evm_dbtopercentage(rx_evmX
);
4710 if(bpacket_match_bssid
)
4712 if(i
==0) // Fill value in RFD, Get the first spatial stream only
4713 pstats
->SignalQuality
= precord_stats
->SignalQuality
= (u8
)(evm
& 0xff);
4714 pstats
->RxMIMOSignalQuality
[i
] = precord_stats
->RxMIMOSignalQuality
[i
] = (u8
)(evm
& 0xff);
4719 /* record rx statistics for debug */
4720 rxsc_sgien_exflg
= pofdm_buf
->rxsc_sgien_exflg
;
4721 prxsc
= (phy_ofdm_rx_status_rxsc_sgien_exintfflag
*)&rxsc_sgien_exflg
;
4724 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
4725 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
4728 pstats
->SignalStrength
= precord_stats
->SignalStrength
= (u8
)(rtl819x_signal_scale_mapping((long)pwdb_all
));//PWDB_ALL;
4733 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u1Byte)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u1Byte)(total_rssi/=RF90_PATH_MAX);
4734 // We can judge RX path number now.
4736 pstats
->SignalStrength
= precord_stats
->SignalStrength
= (u8
)(rtl819x_signal_scale_mapping((long)(total_rssi
/=rf_rx_num
)));
4741 rtl8192_record_rxdesc_forlateruse(
4742 struct ieee80211_rx_stats
* psrc_stats
,
4743 struct ieee80211_rx_stats
* ptarget_stats
4746 ptarget_stats
->bIsAMPDU
= psrc_stats
->bIsAMPDU
;
4747 ptarget_stats
->bFirstMPDU
= psrc_stats
->bFirstMPDU
;
4748 //ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
4753 static void TranslateRxSignalStuff819xpci(struct net_device
*dev
,
4754 struct sk_buff
*skb
,
4755 struct ieee80211_rx_stats
* pstats
,
4756 prx_desc_819x_pci pdesc
,
4757 prx_fwinfo_819x_pci pdrvinfo
)
4759 // TODO: We must only check packet for current MAC address. Not finish
4760 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4761 bool bpacket_match_bssid
, bpacket_toself
;
4762 bool bPacketBeacon
=false, bToSelfBA
=false;
4763 struct ieee80211_hdr_3addr
*hdr
;
4766 // Get Signal Quality for only RX data queue (but not command queue)
4771 /* Get MAC frame start address. */
4772 tmp_buf
= skb
->data
;
4774 hdr
= (struct ieee80211_hdr_3addr
*)tmp_buf
;
4775 fc
= le16_to_cpu(hdr
->frame_ctl
);
4776 type
= WLAN_FC_GET_TYPE(fc
);
4777 praddr
= hdr
->addr1
;
4779 /* Check if the received packet is acceptabe. */
4780 bpacket_match_bssid
= ((IEEE80211_FTYPE_CTL
!= type
) &&
4781 (!compare_ether_addr(priv
->ieee80211
->current_network
.bssid
, (fc
& IEEE80211_FCTL_TODS
)? hdr
->addr1
: (fc
& IEEE80211_FCTL_FROMDS
)? hdr
->addr2
: hdr
->addr3
))
4782 && (!pstats
->bHwError
) && (!pstats
->bCRC
)&& (!pstats
->bICV
));
4783 bpacket_toself
= bpacket_match_bssid
& (!compare_ether_addr(praddr
, priv
->ieee80211
->dev
->dev_addr
));
4785 if(WLAN_FC_GET_FRAMETYPE(fc
)== IEEE80211_STYPE_BEACON
)
4787 bPacketBeacon
= true;
4789 if(WLAN_FC_GET_FRAMETYPE(fc
) == IEEE80211_STYPE_BLOCKACK
)
4791 if((!compare_ether_addr(praddr
,dev
->dev_addr
)))
4796 // Process PHY information for previous packet (RSSI/PWDB/EVM)
4798 // Because phy information is contained in the last packet of AMPDU only, so driver
4799 // should process phy information of previous packet
4800 rtl8192_process_phyinfo(priv
, tmp_buf
, &priv
->previous_stats
, pstats
);
4801 rtl8192_query_rxphystatus(priv
, pstats
, pdesc
, pdrvinfo
, &priv
->previous_stats
, bpacket_match_bssid
,
4802 bpacket_toself
,bPacketBeacon
, bToSelfBA
);
4803 rtl8192_record_rxdesc_forlateruse(pstats
, &priv
->previous_stats
);
4808 static void rtl8192_tx_resume(struct net_device
*dev
)
4810 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4811 struct ieee80211_device
*ieee
= priv
->ieee80211
;
4812 struct sk_buff
*skb
;
4815 for(queue_index
= BK_QUEUE
; queue_index
< TXCMD_QUEUE
;queue_index
++) {
4816 while((!skb_queue_empty(&ieee
->skb_waitQ
[queue_index
]))&&
4817 (priv
->ieee80211
->check_nic_enough_desc(dev
,queue_index
) > 0)) {
4818 /* 1. dequeue the packet from the wait queue */
4819 skb
= skb_dequeue(&ieee
->skb_waitQ
[queue_index
]);
4820 /* 2. tx the packet directly */
4821 ieee
->softmac_data_hard_start_xmit(skb
,dev
,0/* rate useless now*/);
4826 static void rtl8192_irq_tx_tasklet(unsigned long arg
)
4828 struct r8192_priv
*priv
= (struct r8192_priv
*) arg
;
4829 struct rtl8192_tx_ring
*mgnt_ring
= &priv
->tx_ring
[MGNT_QUEUE
];
4830 struct net_device
*dev
= priv
->ieee80211
->dev
;
4831 unsigned long flags
;
4833 /* check if we need to report that the management queue is drained */
4834 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
4836 if (!skb_queue_len(&mgnt_ring
->queue
) &&
4837 priv
->ieee80211
->ack_tx_to_ieee
&&
4838 rtl8192_is_tx_queue_empty(dev
)) {
4839 priv
->ieee80211
->ack_tx_to_ieee
= 0;
4840 ieee80211_ps_tx_ack(priv
->ieee80211
, 1);
4843 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
4845 rtl8192_tx_resume(dev
);
4848 /* Record the received data rate */
4849 static void UpdateReceivedRateHistogramStatistics8190(
4850 struct net_device
*dev
,
4851 struct ieee80211_rx_stats
* pstats
4854 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4855 u32 rcvType
=1; //0: Total, 1:OK, 2:CRC, 3:ICV
4857 u32 preamble_guardinterval
; //1: short preamble/GI, 0: long preamble/GI
4861 else if(pstats
->bICV
)
4864 if(pstats
->bShortPreamble
)
4865 preamble_guardinterval
= 1;// short
4867 preamble_guardinterval
= 0;// long
4869 switch(pstats
->rate
)
4874 case MGN_1M
: rateIndex
= 0; break;
4875 case MGN_2M
: rateIndex
= 1; break;
4876 case MGN_5_5M
: rateIndex
= 2; break;
4877 case MGN_11M
: rateIndex
= 3; break;
4881 case MGN_6M
: rateIndex
= 4; break;
4882 case MGN_9M
: rateIndex
= 5; break;
4883 case MGN_12M
: rateIndex
= 6; break;
4884 case MGN_18M
: rateIndex
= 7; break;
4885 case MGN_24M
: rateIndex
= 8; break;
4886 case MGN_36M
: rateIndex
= 9; break;
4887 case MGN_48M
: rateIndex
= 10; break;
4888 case MGN_54M
: rateIndex
= 11; break;
4890 // 11n High throughput rate
4892 case MGN_MCS0
: rateIndex
= 12; break;
4893 case MGN_MCS1
: rateIndex
= 13; break;
4894 case MGN_MCS2
: rateIndex
= 14; break;
4895 case MGN_MCS3
: rateIndex
= 15; break;
4896 case MGN_MCS4
: rateIndex
= 16; break;
4897 case MGN_MCS5
: rateIndex
= 17; break;
4898 case MGN_MCS6
: rateIndex
= 18; break;
4899 case MGN_MCS7
: rateIndex
= 19; break;
4900 case MGN_MCS8
: rateIndex
= 20; break;
4901 case MGN_MCS9
: rateIndex
= 21; break;
4902 case MGN_MCS10
: rateIndex
= 22; break;
4903 case MGN_MCS11
: rateIndex
= 23; break;
4904 case MGN_MCS12
: rateIndex
= 24; break;
4905 case MGN_MCS13
: rateIndex
= 25; break;
4906 case MGN_MCS14
: rateIndex
= 26; break;
4907 case MGN_MCS15
: rateIndex
= 27; break;
4908 default: rateIndex
= 28; break;
4910 priv
->stats
.received_rate_histogram
[0][rateIndex
]++; //total
4911 priv
->stats
.received_rate_histogram
[rcvType
][rateIndex
]++;
4914 static void rtl8192_rx(struct net_device
*dev
)
4916 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4917 struct ieee80211_hdr_1addr
*ieee80211_hdr
= NULL
;
4918 bool unicast_packet
= false;
4919 struct ieee80211_rx_stats stats
= {
4923 .freq
= IEEE80211_24GHZ_BAND
,
4925 unsigned int count
= priv
->rxringcount
;
4926 prx_fwinfo_819x_pci pDrvInfo
= NULL
;
4927 struct sk_buff
*new_skb
;
4930 rx_desc_819x_pci
*pdesc
= &priv
->rx_ring
[priv
->rx_idx
];//rx descriptor
4931 struct sk_buff
*skb
= priv
->rx_buf
[priv
->rx_idx
];//rx pkt
4934 /* wait data to be filled by hardware */
4937 stats
.bICV
= pdesc
->ICV
;
4938 stats
.bCRC
= pdesc
->CRC32
;
4939 stats
.bHwError
= pdesc
->CRC32
| pdesc
->ICV
;
4941 stats
.Length
= pdesc
->Length
;
4942 if(stats
.Length
< 24)
4943 stats
.bHwError
|= 1;
4945 if(stats
.bHwError
) {
4946 stats
.bShift
= false;
4950 new_skb
= dev_alloc_skb(priv
->rxbuffersize
);
4952 if (unlikely(!new_skb
))
4955 stats
.RxDrvInfoSize
= pdesc
->RxDrvInfoSize
;
4956 stats
.RxBufShift
= ((pdesc
->Shift
)&0x03);
4957 stats
.Decrypted
= !pdesc
->SWDec
;
4959 pci_dma_sync_single_for_cpu(priv
->pdev
,
4960 *((dma_addr_t
*)skb
->cb
),
4962 PCI_DMA_FROMDEVICE
);
4963 skb_put(skb
, pdesc
->Length
);
4964 pDrvInfo
= (rx_fwinfo_819x_pci
*)(skb
->data
+ stats
.RxBufShift
);
4965 skb_reserve(skb
, stats
.RxDrvInfoSize
+ stats
.RxBufShift
);
4967 stats
.rate
= HwRateToMRate90((bool)pDrvInfo
->RxHT
, (u8
)pDrvInfo
->RxRate
);
4968 stats
.bShortPreamble
= pDrvInfo
->SPLCP
;
4970 /* it is debug only. It should be disabled in released driver.
4971 * 2007.1.11 by Emily
4973 UpdateReceivedRateHistogramStatistics8190(dev
, &stats
);
4975 stats
.bIsAMPDU
= (pDrvInfo
->PartAggr
==1);
4976 stats
.bFirstMPDU
= (pDrvInfo
->PartAggr
==1) && (pDrvInfo
->FirstAGGR
==1);
4978 stats
.TimeStampLow
= pDrvInfo
->TSFL
;
4979 stats
.TimeStampHigh
= read_nic_dword(priv
, TSFR
+4);
4981 UpdateRxPktTimeStamp8190(dev
, &stats
);
4984 // Get Total offset of MPDU Frame Body
4986 if((stats
.RxBufShift
+ stats
.RxDrvInfoSize
) > 0)
4989 stats
.RxIs40MHzPacket
= pDrvInfo
->BW
;
4992 TranslateRxSignalStuff819xpci(dev
,skb
, &stats
, pdesc
, pDrvInfo
);
4995 if(pDrvInfo
->FirstAGGR
==1 || pDrvInfo
->PartAggr
== 1)
4996 RT_TRACE(COMP_RXDESC
, "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
4997 pDrvInfo
->FirstAGGR
, pDrvInfo
->PartAggr
);
4998 skb_trim(skb
, skb
->len
- 4/*sCrcLng*/);
4999 /* rx packets statistics */
5000 ieee80211_hdr
= (struct ieee80211_hdr_1addr
*)skb
->data
;
5001 unicast_packet
= false;
5003 if(is_broadcast_ether_addr(ieee80211_hdr
->addr1
)) {
5005 }else if(is_multicast_ether_addr(ieee80211_hdr
->addr1
)){
5008 /* unicast packet */
5009 unicast_packet
= true;
5012 stats
.packetlength
= stats
.Length
-4;
5013 stats
.fraglength
= stats
.packetlength
;
5014 stats
.fragoffset
= 0;
5015 stats
.ntotalfrag
= 1;
5017 if(!ieee80211_rtl_rx(priv
->ieee80211
, skb
, &stats
)){
5018 dev_kfree_skb_any(skb
);
5021 if(unicast_packet
) {
5022 priv
->stats
.rxbytesunicast
+= skb
->len
;
5026 pci_unmap_single(priv
->pdev
, *((dma_addr_t
*) skb
->cb
),
5027 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
5030 priv
->rx_buf
[priv
->rx_idx
] = skb
;
5031 *((dma_addr_t
*) skb
->cb
) = pci_map_single(priv
->pdev
, skb_tail_pointer(skb
), priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
5034 pdesc
->BufferAddress
= cpu_to_le32(*((dma_addr_t
*)skb
->cb
));
5036 pdesc
->Length
= priv
->rxbuffersize
;
5037 if (priv
->rx_idx
== priv
->rxringcount
-1)
5039 priv
->rx_idx
= (priv
->rx_idx
+ 1) % priv
->rxringcount
;
5044 static void rtl8192_irq_rx_tasklet(unsigned long arg
)
5046 struct r8192_priv
*priv
= (struct r8192_priv
*) arg
;
5047 rtl8192_rx(priv
->ieee80211
->dev
);
5049 write_nic_dword(priv
, INTA_MASK
, read_nic_dword(priv
, INTA_MASK
) | IMR_RDU
);
5052 static const struct net_device_ops rtl8192_netdev_ops
= {
5053 .ndo_open
= rtl8192_open
,
5054 .ndo_stop
= rtl8192_close
,
5055 .ndo_tx_timeout
= tx_timeout
,
5056 .ndo_do_ioctl
= rtl8192_ioctl
,
5057 .ndo_set_multicast_list
= r8192_set_multicast
,
5058 .ndo_set_mac_address
= r8192_set_mac_adr
,
5059 .ndo_start_xmit
= ieee80211_rtl_xmit
,
5062 static int __devinit
rtl8192_pci_probe(struct pci_dev
*pdev
,
5063 const struct pci_device_id
*id
)
5065 unsigned long ioaddr
= 0;
5066 struct net_device
*dev
= NULL
;
5067 struct r8192_priv
*priv
= NULL
;
5071 #ifdef CONFIG_RTL8192_IO_MAP
5072 unsigned long pio_start
, pio_len
, pio_flags
;
5074 unsigned long pmem_start
, pmem_len
, pmem_flags
;
5075 #endif //end #ifdef RTL_IO_MAP
5077 RT_TRACE(COMP_INIT
,"Configuring chip resources");
5079 if( pci_enable_device (pdev
) ){
5080 RT_TRACE(COMP_ERR
,"Failed to enable PCI device");
5084 pci_set_master(pdev
);
5085 //pci_set_wmi(pdev);
5086 pci_set_dma_mask(pdev
, 0xffffff00ULL
);
5087 pci_set_consistent_dma_mask(pdev
,0xffffff00ULL
);
5088 dev
= alloc_ieee80211(sizeof(struct r8192_priv
));
5094 pci_set_drvdata(pdev
, dev
);
5095 SET_NETDEV_DEV(dev
, &pdev
->dev
);
5096 priv
= ieee80211_priv(dev
);
5097 priv
->ieee80211
= netdev_priv(dev
);
5099 if((pdev
->subsystem_vendor
== PCI_VENDOR_ID_DLINK
)&&(pdev
->subsystem_device
== 0x3304)){
5100 priv
->ieee80211
->bSupportRemoteWakeUp
= 1;
5103 priv
->ieee80211
->bSupportRemoteWakeUp
= 0;
5106 #ifdef CONFIG_RTL8192_IO_MAP
5108 pio_start
= (unsigned long)pci_resource_start (pdev
, 0);
5109 pio_len
= (unsigned long)pci_resource_len (pdev
, 0);
5110 pio_flags
= (unsigned long)pci_resource_flags (pdev
, 0);
5112 if (!(pio_flags
& IORESOURCE_IO
)) {
5113 RT_TRACE(COMP_ERR
,"region #0 not a PIO resource, aborting");
5117 //DMESG("IO space @ 0x%08lx", pio_start );
5118 if( ! request_region( pio_start
, pio_len
, RTL819xE_MODULE_NAME
) ){
5119 RT_TRACE(COMP_ERR
,"request_region failed!");
5124 dev
->base_addr
= ioaddr
; // device I/O address
5128 pmem_start
= pci_resource_start(pdev
, 1);
5129 pmem_len
= pci_resource_len(pdev
, 1);
5130 pmem_flags
= pci_resource_flags (pdev
, 1);
5132 if (!(pmem_flags
& IORESOURCE_MEM
)) {
5133 RT_TRACE(COMP_ERR
,"region #1 not a MMIO resource, aborting");
5137 //DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
5138 if( ! request_mem_region(pmem_start
, pmem_len
, RTL819xE_MODULE_NAME
)) {
5139 RT_TRACE(COMP_ERR
,"request_mem_region failed!");
5144 ioaddr
= (unsigned long)ioremap_nocache( pmem_start
, pmem_len
);
5145 if( ioaddr
== (unsigned long)NULL
){
5146 RT_TRACE(COMP_ERR
,"ioremap failed!");
5147 // release_mem_region( pmem_start, pmem_len );
5151 dev
->mem_start
= ioaddr
; // shared mem start
5152 dev
->mem_end
= ioaddr
+ pci_resource_len(pdev
, 0); // shared mem end
5154 #endif //end #ifdef RTL_IO_MAP
5156 /* We disable the RETRY_TIMEOUT register (0x41) to keep
5157 * PCI Tx retries from interfering with C3 CPU state */
5158 pci_write_config_byte(pdev
, 0x41, 0x00);
5161 pci_read_config_byte(pdev
, 0x05, &unit
);
5162 pci_write_config_byte(pdev
, 0x05, unit
& (~0x04));
5164 dev
->irq
= pdev
->irq
;
5167 dev
->netdev_ops
= &rtl8192_netdev_ops
;
5169 dev
->wireless_handlers
= &r8192_wx_handlers_def
;
5170 dev
->type
=ARPHRD_ETHER
;
5172 dev
->watchdog_timeo
= HZ
*3;
5174 if (dev_alloc_name(dev
, ifname
) < 0){
5175 RT_TRACE(COMP_INIT
, "Oops: devname already taken! Trying wlan%%d...\n");
5176 strcpy(ifname
, "wlan%d");
5177 dev_alloc_name(dev
, ifname
);
5180 RT_TRACE(COMP_INIT
, "Driver probe completed1\n");
5181 if(rtl8192_init(dev
)!=0){
5182 RT_TRACE(COMP_ERR
, "Initialization failed");
5186 register_netdev(dev
);
5187 RT_TRACE(COMP_INIT
, "dev name=======> %s\n",dev
->name
);
5188 rtl8192_proc_init_one(dev
);
5191 RT_TRACE(COMP_INIT
, "Driver probe completed\n");
5196 #ifdef CONFIG_RTL8180_IO_MAP
5198 if( dev
->base_addr
!= 0 ){
5200 release_region(dev
->base_addr
,
5201 pci_resource_len(pdev
, 0) );
5204 if( dev
->mem_start
!= (unsigned long)NULL
){
5205 iounmap( (void *)dev
->mem_start
);
5206 release_mem_region( pci_resource_start(pdev
, 1),
5207 pci_resource_len(pdev
, 1) );
5209 #endif //end #ifdef RTL_IO_MAP
5215 free_irq(dev
->irq
, dev
);
5218 free_ieee80211(dev
);
5222 pci_disable_device(pdev
);
5224 DMESG("wlan driver load failed\n");
5225 pci_set_drvdata(pdev
, NULL
);
5230 /* detach all the work and timer structure declared or inititialized
5231 * in r8192_init function.
5233 static void rtl8192_cancel_deferred_work(struct r8192_priv
* priv
)
5235 /* call cancel_work_sync instead of cancel_delayed_work if and only if Linux_version_code
5236 * is or is newer than 2.6.20 and work structure is defined to be struct work_struct.
5237 * Otherwise call cancel_delayed_work is enough.
5238 * FIXME (2.6.20 should 2.6.22, work_struct should not cancel)
5240 cancel_delayed_work(&priv
->watch_dog_wq
);
5241 cancel_delayed_work(&priv
->update_beacon_wq
);
5242 cancel_delayed_work(&priv
->ieee80211
->hw_wakeup_wq
);
5243 cancel_delayed_work(&priv
->ieee80211
->hw_sleep_wq
);
5244 cancel_delayed_work(&priv
->gpio_change_rf_wq
);
5245 cancel_work_sync(&priv
->reset_wq
);
5246 cancel_work_sync(&priv
->qos_activate
);
5250 static void __devexit
rtl8192_pci_disconnect(struct pci_dev
*pdev
)
5252 struct net_device
*dev
= pci_get_drvdata(pdev
);
5253 struct r8192_priv
*priv
;
5258 unregister_netdev(dev
);
5260 priv
= ieee80211_priv(dev
);
5262 rtl8192_proc_remove_one(dev
);
5265 if (priv
->pFirmware
)
5267 vfree(priv
->pFirmware
);
5268 priv
->pFirmware
= NULL
;
5270 destroy_workqueue(priv
->priv_wq
);
5272 /* free tx/rx rings */
5273 rtl8192_free_rx_ring(dev
);
5274 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
5275 rtl8192_free_tx_ring(dev
, i
);
5278 printk("Freeing irq %d\n",dev
->irq
);
5279 free_irq(dev
->irq
, dev
);
5283 #ifdef CONFIG_RTL8180_IO_MAP
5285 if( dev
->base_addr
!= 0 ){
5287 release_region(dev
->base_addr
,
5288 pci_resource_len(pdev
, 0) );
5291 if( dev
->mem_start
!= (unsigned long)NULL
){
5292 iounmap( (void *)dev
->mem_start
);
5293 release_mem_region( pci_resource_start(pdev
, 1),
5294 pci_resource_len(pdev
, 1) );
5296 #endif /*end #ifdef RTL_IO_MAP*/
5297 free_ieee80211(dev
);
5301 pci_disable_device(pdev
);
5302 RT_TRACE(COMP_DOWN
, "wlan driver removed\n");
5305 extern int ieee80211_rtl_init(void);
5306 extern void ieee80211_rtl_exit(void);
5308 static int __init
rtl8192_pci_module_init(void)
5312 retval
= ieee80211_rtl_init();
5316 printk(KERN_INFO
"\nLinux kernel driver for RTL8192 based WLAN cards\n");
5317 printk(KERN_INFO
"Copyright (c) 2007-2008, Realsil Wlan\n");
5318 RT_TRACE(COMP_INIT
, "Initializing module");
5319 rtl8192_proc_module_init();
5320 if(0!=pci_register_driver(&rtl8192_pci_driver
))
5322 DMESG("No device found");
5323 /*pci_unregister_driver (&rtl8192_pci_driver);*/
5330 static void __exit
rtl8192_pci_module_exit(void)
5332 pci_unregister_driver(&rtl8192_pci_driver
);
5334 RT_TRACE(COMP_DOWN
, "Exiting");
5335 rtl8192_proc_module_remove();
5336 ieee80211_rtl_exit();
5339 static irqreturn_t
rtl8192_interrupt(int irq
, void *netdev
)
5341 struct net_device
*dev
= (struct net_device
*) netdev
;
5342 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5343 unsigned long flags
;
5345 irqreturn_t ret
= IRQ_HANDLED
;
5347 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
5349 /* We should return IRQ_NONE, but for now let me keep this */
5350 if (priv
->irq_enabled
== 0)
5355 inta
= read_nic_dword(priv
, ISR
); /* & priv->IntrMask; */
5356 write_nic_dword(priv
, ISR
, inta
); /* reset int situation */
5360 * most probably we can safely return IRQ_NONE,
5361 * but for now is better to avoid problems
5366 if (inta
== 0xffff) {
5371 if (!netif_running(dev
))
5374 if (inta
& IMR_TBDOK
) {
5375 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
5376 rtl8192_tx_isr(dev
, BEACON_QUEUE
);
5377 priv
->stats
.txbeaconokint
++;
5380 if (inta
& IMR_TBDER
) {
5381 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
5382 rtl8192_tx_isr(dev
, BEACON_QUEUE
);
5383 priv
->stats
.txbeaconerr
++;
5386 if (inta
& IMR_MGNTDOK
) {
5387 RT_TRACE(COMP_INTR
, "Manage ok interrupt!\n");
5388 priv
->stats
.txmanageokint
++;
5389 rtl8192_tx_isr(dev
,MGNT_QUEUE
);
5392 if (inta
& IMR_COMDOK
)
5394 priv
->stats
.txcmdpktokint
++;
5395 rtl8192_tx_isr(dev
, TXCMD_QUEUE
);
5398 if (inta
& IMR_ROK
) {
5399 priv
->stats
.rxint
++;
5400 tasklet_schedule(&priv
->irq_rx_tasklet
);
5403 if (inta
& IMR_BcnInt
) {
5404 RT_TRACE(COMP_INTR
, "prepare beacon for interrupt!\n");
5405 tasklet_schedule(&priv
->irq_prepare_beacon_tasklet
);
5408 if (inta
& IMR_RDU
) {
5409 RT_TRACE(COMP_INTR
, "rx descriptor unavailable!\n");
5410 priv
->stats
.rxrdu
++;
5411 /* reset int situation */
5412 write_nic_dword(priv
, INTA_MASK
, read_nic_dword(priv
, INTA_MASK
) & ~IMR_RDU
);
5413 tasklet_schedule(&priv
->irq_rx_tasklet
);
5416 if (inta
& IMR_RXFOVW
) {
5417 RT_TRACE(COMP_INTR
, "rx overflow !\n");
5418 priv
->stats
.rxoverflow
++;
5419 tasklet_schedule(&priv
->irq_rx_tasklet
);
5422 if (inta
& IMR_TXFOVW
)
5423 priv
->stats
.txoverflow
++;
5425 if (inta
& IMR_BKDOK
) {
5426 RT_TRACE(COMP_INTR
, "BK Tx OK interrupt!\n");
5427 priv
->stats
.txbkokint
++;
5428 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
5429 rtl8192_tx_isr(dev
, BK_QUEUE
);
5432 if (inta
& IMR_BEDOK
) {
5433 RT_TRACE(COMP_INTR
, "BE TX OK interrupt!\n");
5434 priv
->stats
.txbeokint
++;
5435 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
5436 rtl8192_tx_isr(dev
, BE_QUEUE
);
5439 if (inta
& IMR_VIDOK
) {
5440 RT_TRACE(COMP_INTR
, "VI TX OK interrupt!\n");
5441 priv
->stats
.txviokint
++;
5442 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
5443 rtl8192_tx_isr(dev
, VI_QUEUE
);
5446 if (inta
& IMR_VODOK
) {
5447 priv
->stats
.txvookint
++;
5448 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
5449 rtl8192_tx_isr(dev
, VO_QUEUE
);
5453 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
5458 void EnableHWSecurityConfig8192(struct net_device
*dev
)
5460 u8 SECR_value
= 0x0;
5461 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5462 struct ieee80211_device
* ieee
= priv
->ieee80211
;
5464 SECR_value
= SCR_TxEncEnable
| SCR_RxDecEnable
;
5466 if (((KEY_TYPE_WEP40
== ieee
->pairwise_key_type
) || (KEY_TYPE_WEP104
== ieee
->pairwise_key_type
)) && (priv
->ieee80211
->auth_mode
!= 2))
5468 SECR_value
|= SCR_RxUseDK
;
5469 SECR_value
|= SCR_TxUseDK
;
5471 else if ((ieee
->iw_mode
== IW_MODE_ADHOC
) && (ieee
->pairwise_key_type
& (KEY_TYPE_CCMP
| KEY_TYPE_TKIP
)))
5473 SECR_value
|= SCR_RxUseDK
;
5474 SECR_value
|= SCR_TxUseDK
;
5477 //add HWSec active enable here.
5478 //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
5479 ieee
->hwsec_active
= 1;
5481 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
5483 ieee
->hwsec_active
= 0;
5484 SECR_value
&= ~SCR_RxDecEnable
;
5487 RT_TRACE(COMP_SEC
,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__
,
5488 ieee
->hwsec_active
, ieee
->pairwise_key_type
, SECR_value
);
5490 write_nic_byte(priv
, SECR
, SECR_value
);//SECR_value | SCR_UseDK );
5494 #define TOTAL_CAM_ENTRY 32
5495 //#define CAM_CONTENT_COUNT 8
5496 void setKey( struct net_device
*dev
,
5504 u32 TargetCommand
= 0;
5505 u32 TargetContent
= 0;
5509 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5510 RT_RF_POWER_STATE rtState
;
5511 rtState
= priv
->ieee80211
->eRFPowerState
;
5512 if(priv
->ieee80211
->PowerSaveControl
.bInactivePs
){
5513 if(rtState
== eRfOff
){
5514 if(priv
->ieee80211
->RfOffReason
> RF_CHANGE_BY_IPS
)
5516 RT_TRACE(COMP_ERR
, "%s(): RF is OFF.\n",__FUNCTION__
);
5517 //up(&priv->wx_sem);
5521 down(&priv
->ieee80211
->ips_sem
);
5523 up(&priv
->ieee80211
->ips_sem
);
5527 priv
->ieee80211
->is_set_key
= true;
5529 if (EntryNo
>= TOTAL_CAM_ENTRY
)
5530 RT_TRACE(COMP_ERR
, "cam entry exceeds in setKey()\n");
5532 RT_TRACE(COMP_SEC
, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev
,EntryNo
, KeyIndex
, KeyType
, MacAddr
);
5535 usConfig
|= BIT15
| (KeyType
<<2);
5537 usConfig
|= BIT15
| (KeyType
<<2) | KeyIndex
;
5538 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
5541 for(i
=0 ; i
<CAM_CONTENT_COUNT
; i
++){
5542 TargetCommand
= i
+CAM_CONTENT_COUNT
*EntryNo
;
5543 TargetCommand
|= BIT31
|BIT16
;
5545 if(i
==0){//MAC|Config
5546 TargetContent
= (u32
)(*(MacAddr
+0)) << 16|
5547 (u32
)(*(MacAddr
+1)) << 24|
5550 write_nic_dword(priv
, WCAMI
, TargetContent
);
5551 write_nic_dword(priv
, RWCAM
, TargetCommand
);
5554 TargetContent
= (u32
)(*(MacAddr
+2)) |
5555 (u32
)(*(MacAddr
+3)) << 8|
5556 (u32
)(*(MacAddr
+4)) << 16|
5557 (u32
)(*(MacAddr
+5)) << 24;
5558 write_nic_dword(priv
, WCAMI
, TargetContent
);
5559 write_nic_dword(priv
, RWCAM
, TargetCommand
);
5561 else { //Key Material
5562 if(KeyContent
!= NULL
)
5564 write_nic_dword(priv
, WCAMI
, (u32
)(*(KeyContent
+i
-2)) );
5565 write_nic_dword(priv
, RWCAM
, TargetCommand
);
5569 RT_TRACE(COMP_SEC
,"=========>after set key, usconfig:%x\n", usConfig
);
5572 bool NicIFEnableNIC(struct net_device
* dev
)
5574 RT_STATUS init_status
= RT_STATUS_SUCCESS
;
5575 struct r8192_priv
* priv
= ieee80211_priv(dev
);
5576 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
5580 RT_TRACE(COMP_ERR
, "ERR!!! %s(): Driver is already down!\n",__FUNCTION__
);
5581 priv
->bdisable_nic
= false; //YJ,add,091111
5584 // <1> Reset memory: descriptor, buffer,..
5585 //NicIFResetMemory(Adapter);
5587 // <2> Enable Adapter
5588 //priv->bfirst_init = true;
5589 init_status
= rtl8192_adapter_start(dev
);
5590 if (init_status
!= RT_STATUS_SUCCESS
) {
5591 RT_TRACE(COMP_ERR
,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__
);
5592 priv
->bdisable_nic
= false; //YJ,add,091111
5595 RT_CLEAR_PS_LEVEL(pPSC
, RT_RF_OFF_LEVL_HALT_NIC
);
5596 //priv->bfirst_init = false;
5598 // <3> Enable Interrupt
5599 rtl8192_irq_enable(dev
);
5600 priv
->bdisable_nic
= false;
5602 return (init_status
== RT_STATUS_SUCCESS
);
5605 bool NicIFDisableNIC(struct net_device
* dev
)
5608 struct r8192_priv
* priv
= ieee80211_priv(dev
);
5610 // <1> Disable Interrupt
5612 priv
->bdisable_nic
= true; //YJ,move,091109
5613 tmp_state
= priv
->ieee80211
->state
;
5615 ieee80211_softmac_stop_protocol(priv
->ieee80211
, false);
5617 priv
->ieee80211
->state
= tmp_state
;
5618 rtl8192_cancel_deferred_work(priv
);
5619 rtl8192_irq_disable(dev
);
5620 // <2> Stop all timer
5622 // <3> Disable Adapter
5623 rtl8192_halt_adapter(dev
, false);
5624 // priv->bdisable_nic = true;
5629 module_init(rtl8192_pci_module_init
);
5630 module_exit(rtl8192_pci_module_exit
);