1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 * Linux device driver for RTL8190P / RTL8192E
5 * Based on the r8180 driver, which is:
6 * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 * The full GNU General Public License is included in this distribution in the
21 * file called LICENSE.
23 * Contact Information:
24 * Jerry chuang <wlanfae@realtek.com>
28 #undef RX_DONT_PASS_UL
30 #undef DEBUG_RX_VERBOSE
36 #undef DEBUG_TX_FILLDESC
41 #undef DEBUG_REGISTERS
43 #undef DEBUG_IRQ_TASKLET
47 //#define CONFIG_RTL8192_IO_MAP
48 #include <linux/vmalloc.h>
49 #include <linux/slab.h>
50 #include <asm/uaccess.h>
51 #include "r8192E_hw.h"
53 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
54 #include "r8180_93cx6.h" /* Card EEPROM */
55 #include "r8192E_wx.h"
56 #include "r819xE_phy.h" //added by WB 4.30.2008
57 #include "r819xE_phyreg.h"
58 #include "r819xE_cmdpkt.h"
59 #include "r8192E_dm.h"
66 #include "ieee80211/dot11d.h"
69 //set here to open your trace code. //WB
70 u32 rt_global_debug_component
=
88 // COMP_POWER_TRACKING |
90 COMP_ERR
; //always open err flags on
92 static const struct pci_device_id rtl8192_pci_id_tbl
[] __devinitdata
= {
96 { PCI_DEVICE(0x10ec, 0x8190) },
98 { PCI_DEVICE(0x07aa, 0x0045) },
99 { PCI_DEVICE(0x07aa, 0x0046) },
102 { PCI_DEVICE(0x10ec, 0x8192) },
105 { PCI_DEVICE(0x07aa, 0x0044) },
106 { PCI_DEVICE(0x07aa, 0x0047) },
111 static char ifname
[IFNAMSIZ
] = "wlan%d";
112 static int hwwep
= 1; //default use hw. set 0 to use software security
113 static int channels
= 0x3fff;
115 MODULE_LICENSE("GPL");
116 MODULE_VERSION("V 1.1");
117 MODULE_DEVICE_TABLE(pci
, rtl8192_pci_id_tbl
);
118 //MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
119 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
122 module_param_string(ifname
, ifname
, sizeof(ifname
), S_IRUGO
|S_IWUSR
);
123 module_param(hwwep
,int, S_IRUGO
|S_IWUSR
);
124 module_param(channels
,int, S_IRUGO
|S_IWUSR
);
126 MODULE_PARM_DESC(ifname
," Net interface name, wlan%d=default");
127 MODULE_PARM_DESC(hwwep
," Try to use hardware WEP support. Still broken and not available on all cards");
128 MODULE_PARM_DESC(channels
," Channel bitmask for specific locales. NYI");
130 static int __devinit
rtl8192_pci_probe(struct pci_dev
*pdev
,
131 const struct pci_device_id
*id
);
132 static void __devexit
rtl8192_pci_disconnect(struct pci_dev
*pdev
);
134 static struct pci_driver rtl8192_pci_driver
= {
135 .name
= RTL819xE_MODULE_NAME
, /* Driver name */
136 .id_table
= rtl8192_pci_id_tbl
, /* PCI_ID table */
137 .probe
= rtl8192_pci_probe
, /* probe fn */
138 .remove
= __devexit_p(rtl8192_pci_disconnect
), /* remove fn */
140 .suspend
= rtl8192E_suspend
, /* PM suspend fn */
141 .resume
= rtl8192E_resume
, /* PM resume fn */
143 .suspend
= NULL
, /* PM suspend fn */
144 .resume
= NULL
, /* PM resume fn */
148 static void rtl8192_start_beacon(struct net_device
*dev
);
149 static void rtl8192_stop_beacon(struct net_device
*dev
);
150 static void rtl819x_watchdog_wqcallback(struct work_struct
*work
);
151 static void rtl8192_irq_rx_tasklet(struct r8192_priv
*priv
);
152 static void rtl8192_irq_tx_tasklet(struct r8192_priv
*priv
);
153 static void rtl8192_prepare_beacon(struct r8192_priv
*priv
);
154 static irqreturn_t
rtl8192_interrupt(int irq
, void *netdev
);
155 static void rtl8192_try_wake_queue(struct net_device
*dev
, int pri
);
156 static void rtl819xE_tx_cmd(struct net_device
*dev
, struct sk_buff
*skb
);
157 static void rtl8192_update_ratr_table(struct net_device
* dev
);
158 static void rtl8192_restart(struct work_struct
*work
);
159 static void watch_dog_timer_callback(unsigned long data
);
160 static int _rtl8192_up(struct net_device
*dev
);
161 static void rtl8192_cancel_deferred_work(struct r8192_priv
* priv
);
165 typedef struct _CHANNEL_LIST
169 }CHANNEL_LIST
, *PCHANNEL_LIST
;
171 static const CHANNEL_LIST ChannelPlan
[] = {
172 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64,149,153,157,161,165},24}, //FCC
173 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
174 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
175 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
176 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, //MKK //MKK
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
179 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
180 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, // For 11a , TELEC
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
182 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14},14} //For Global Domain. 1-11:active scan, 12-14 passive scan. //+YJ, 080626
185 static void rtl819x_set_channel_map(u8 channel_plan
, struct r8192_priv
* priv
)
187 int i
, max_chan
=-1, min_chan
=-1;
188 struct ieee80211_device
* ieee
= priv
->ieee80211
;
189 switch (channel_plan
)
191 case COUNTRY_CODE_FCC
:
192 case COUNTRY_CODE_IC
:
193 case COUNTRY_CODE_ETSI
:
194 case COUNTRY_CODE_SPAIN
:
195 case COUNTRY_CODE_FRANCE
:
196 case COUNTRY_CODE_MKK
:
197 case COUNTRY_CODE_MKK1
:
198 case COUNTRY_CODE_ISRAEL
:
199 case COUNTRY_CODE_TELEC
:
200 case COUNTRY_CODE_MIC
:
203 ieee
->bGlobalDomain
= false;
204 //acturally 8225 & 8256 rf chip only support B,G,24N mode
205 if ((priv
->rf_chip
== RF_8225
) || (priv
->rf_chip
== RF_8256
))
212 RT_TRACE(COMP_ERR
, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__
);
214 if (ChannelPlan
[channel_plan
].Len
!= 0){
215 // Clear old channel map
216 memset(GET_DOT11D_INFO(ieee
)->channel_map
, 0, sizeof(GET_DOT11D_INFO(ieee
)->channel_map
));
217 // Set new channel map
218 for (i
=0;i
<ChannelPlan
[channel_plan
].Len
;i
++)
220 if (ChannelPlan
[channel_plan
].Channel
[i
] < min_chan
|| ChannelPlan
[channel_plan
].Channel
[i
] > max_chan
)
222 GET_DOT11D_INFO(ieee
)->channel_map
[ChannelPlan
[channel_plan
].Channel
[i
]] = 1;
227 case COUNTRY_CODE_GLOBAL_DOMAIN
:
229 GET_DOT11D_INFO(ieee
)->bEnabled
= 0; //this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain setting
231 ieee
->bGlobalDomain
= true;
241 #define eqMacAddr(a,b) ( ((a)[0]==(b)[0] && (a)[1]==(b)[1] && (a)[2]==(b)[2] && (a)[3]==(b)[3] && (a)[4]==(b)[4] && (a)[5]==(b)[5]) ? 1:0 )
244 #define rx_hal_is_cck_rate(_pdrvinfo)\
245 (_pdrvinfo->RxRate == DESC90_RATE1M ||\
246 _pdrvinfo->RxRate == DESC90_RATE2M ||\
247 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
248 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
252 void CamResetAllEntry(struct net_device *dev)
254 write_nic_dword(dev
, RWCAM
, BIT31
|BIT30
);
258 void write_cam(struct net_device
*dev
, u8 addr
, u32 data
)
260 write_nic_dword(dev
, WCAMI
, data
);
261 write_nic_dword(dev
, RWCAM
, BIT31
|BIT16
|(addr
&0xff) );
263 u32
read_cam(struct net_device
*dev
, u8 addr
)
265 write_nic_dword(dev
, RWCAM
, 0x80000000|(addr
&0xff) );
266 return read_nic_dword(dev
, 0xa8);
269 #ifdef CONFIG_RTL8180_IO_MAP
271 u8
read_nic_byte(struct net_device
*dev
, int x
)
273 return 0xff&inb(dev
->base_addr
+x
);
276 u32
read_nic_dword(struct net_device
*dev
, int x
)
278 return inl(dev
->base_addr
+x
);
281 u16
read_nic_word(struct net_device
*dev
, int x
)
283 return inw(dev
->base_addr
+x
);
286 void write_nic_byte(struct net_device
*dev
, int x
,u8 y
)
288 outb(y
&0xff,dev
->base_addr
+x
);
291 void write_nic_word(struct net_device
*dev
, int x
,u16 y
)
293 outw(y
,dev
->base_addr
+x
);
296 void write_nic_dword(struct net_device
*dev
, int x
,u32 y
)
298 outl(y
,dev
->base_addr
+x
);
301 #else /* RTL_IO_MAP */
303 u8
read_nic_byte(struct net_device
*dev
, int x
)
305 return 0xff&readb((u8
*)dev
->mem_start
+x
);
308 u32
read_nic_dword(struct net_device
*dev
, int x
)
310 return readl((u8
*)dev
->mem_start
+x
);
313 u16
read_nic_word(struct net_device
*dev
, int x
)
315 return readw((u8
*)dev
->mem_start
+x
);
318 void write_nic_byte(struct net_device
*dev
, int x
,u8 y
)
320 writeb(y
,(u8
*)dev
->mem_start
+x
);
324 void write_nic_dword(struct net_device
*dev
, int x
,u32 y
)
326 writel(y
,(u8
*)dev
->mem_start
+x
);
330 void write_nic_word(struct net_device
*dev
, int x
,u16 y
)
332 writew(y
,(u8
*)dev
->mem_start
+x
);
336 #endif /* RTL_IO_MAP */
338 u8
rtl8192e_ap_sec_type(struct ieee80211_device
*ieee
)
340 static const u8 ccmp_ie
[4] = {0x00,0x50,0xf2,0x04};
341 static const u8 ccmp_rsn_ie
[4] = {0x00, 0x0f, 0xac, 0x04};
342 int wpa_ie_len
= ieee
->wpa_ie_len
;
343 struct ieee80211_crypt_data
* crypt
;
346 crypt
= ieee
->crypt
[ieee
->tx_keyidx
];
348 encrypt
= (ieee
->current_network
.capability
& WLAN_CAPABILITY_PRIVACY
) ||
349 (ieee
->host_encrypt
&& crypt
&& crypt
->ops
&&
350 (0 == strcmp(crypt
->ops
->name
,"WEP")));
353 if(encrypt
&& (wpa_ie_len
== 0)) {
354 // wep encryption, no N mode setting */
356 } else if((wpa_ie_len
!= 0)) {
357 // parse pairwise key type */
358 if (((ieee
->wpa_ie
[0] == 0xdd) && (!memcmp(&(ieee
->wpa_ie
[14]),ccmp_ie
,4))) ||
359 ((ieee
->wpa_ie
[0] == 0x30) && (!memcmp(&ieee
->wpa_ie
[10],ccmp_rsn_ie
, 4))))
369 rtl8192e_SetHwReg(struct net_device
*dev
,u8 variable
,u8
* val
)
371 struct r8192_priv
* priv
= ieee80211_priv(dev
);
377 write_nic_dword(dev
, BSSIDR
, ((u32
*)(val
))[0]);
378 write_nic_word(dev
, BSSIDR
+2, ((u16
*)(val
+2))[0]);
381 case HW_VAR_MEDIA_STATUS
:
383 RT_OP_MODE OpMode
= *((RT_OP_MODE
*)(val
));
384 u8 btMsr
= read_nic_byte(dev
, MSR
);
390 case RT_OP_MODE_INFRASTRUCTURE
:
394 case RT_OP_MODE_IBSS
:
407 write_nic_byte(dev
, MSR
, btMsr
);
411 case HW_VAR_CECHK_BSSID
:
415 Type
= ((u8
*)(val
))[0];
416 RegRCR
= read_nic_dword(dev
,RCR
);
417 priv
->ReceiveConfig
= RegRCR
;
420 RegRCR
|= (RCR_CBSSID
);
421 else if (Type
== false)
422 RegRCR
&= (~RCR_CBSSID
);
424 write_nic_dword(dev
, RCR
,RegRCR
);
425 priv
->ReceiveConfig
= RegRCR
;
430 case HW_VAR_SLOT_TIME
:
432 priv
->slot_time
= val
[0];
433 write_nic_byte(dev
, SLOT_TIME
, val
[0]);
438 case HW_VAR_ACK_PREAMBLE
:
441 priv
->short_preamble
= (bool)(*(u8
*)val
);
442 regTmp
= priv
->basic_rate
;
443 if (priv
->short_preamble
)
444 regTmp
|= BRSR_AckShortPmb
;
445 write_nic_dword(dev
, RRSR
, regTmp
);
450 write_nic_dword(dev
, CPU_GEN
, ((u32
*)(val
))[0]);
459 static struct proc_dir_entry
*rtl8192_proc
= NULL
;
461 static int proc_get_stats_ap(char *page
, char **start
,
462 off_t offset
, int count
,
463 int *eof
, void *data
)
465 struct net_device
*dev
= data
;
466 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
467 struct ieee80211_device
*ieee
= priv
->ieee80211
;
468 struct ieee80211_network
*target
;
471 list_for_each_entry(target
, &ieee
->network_list
, list
) {
473 len
+= snprintf(page
+ len
, count
- len
,
474 "%s ", target
->ssid
);
476 if(target
->wpa_ie_len
>0 || target
->rsn_ie_len
>0){
477 len
+= snprintf(page
+ len
, count
- len
,
481 len
+= snprintf(page
+ len
, count
- len
,
491 static int proc_get_registers(char *page
, char **start
,
492 off_t offset
, int count
,
493 int *eof
, void *data
)
495 struct net_device
*dev
= data
;
500 /* This dump the current register page */
501 len
+= snprintf(page
+ len
, count
- len
,
502 "\n####################page 0##################\n ");
506 len
+= snprintf(page
+ len
, count
- len
,
509 for(i
=0;i
<16 && n
<=max
;i
++,n
++)
510 len
+= snprintf(page
+ len
, count
- len
,
511 "%2x ",read_nic_byte(dev
,n
));
513 len
+= snprintf(page
+ len
, count
- len
,"\n");
514 len
+= snprintf(page
+ len
, count
- len
,
515 "\n####################page 1##################\n ");
518 len
+= snprintf(page
+ len
, count
- len
,
521 for(i
=0;i
<16 && n
<=max
;i
++,n
++)
522 len
+= snprintf(page
+ len
, count
- len
,
523 "%2x ",read_nic_byte(dev
,0x100|n
));
526 len
+= snprintf(page
+ len
, count
- len
,
527 "\n####################page 3##################\n ");
530 len
+= snprintf(page
+ len
, count
- len
,
533 for(i
=0;i
<16 && n
<=max
;i
++,n
++)
534 len
+= snprintf(page
+ len
, count
- len
,
535 "%2x ",read_nic_byte(dev
,0x300|n
));
543 static int proc_get_stats_tx(char *page
, char **start
,
544 off_t offset
, int count
,
545 int *eof
, void *data
)
547 struct net_device
*dev
= data
;
548 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
552 len
+= snprintf(page
+ len
, count
- len
,
553 "TX VI priority ok int: %lu\n"
554 // "TX VI priority error int: %lu\n"
555 "TX VO priority ok int: %lu\n"
556 // "TX VO priority error int: %lu\n"
557 "TX BE priority ok int: %lu\n"
558 // "TX BE priority error int: %lu\n"
559 "TX BK priority ok int: %lu\n"
560 // "TX BK priority error int: %lu\n"
561 "TX MANAGE priority ok int: %lu\n"
562 // "TX MANAGE priority error int: %lu\n"
563 "TX BEACON priority ok int: %lu\n"
564 "TX BEACON priority error int: %lu\n"
565 "TX CMDPKT priority ok int: %lu\n"
566 // "TX high priority ok int: %lu\n"
567 // "TX high priority failed error int: %lu\n"
568 // "TX queue resume: %lu\n"
569 "TX queue stopped?: %d\n"
570 "TX fifo overflow: %lu\n"
571 // "TX beacon: %lu\n"
572 // "TX VI queue: %d\n"
573 // "TX VO queue: %d\n"
574 // "TX BE queue: %d\n"
575 // "TX BK queue: %d\n"
576 // "TX HW queue: %d\n"
577 // "TX VI dropped: %lu\n"
578 // "TX VO dropped: %lu\n"
579 // "TX BE dropped: %lu\n"
580 // "TX BK dropped: %lu\n"
581 "TX total data packets %lu\n"
582 "TX total data bytes :%lu\n",
583 // "TX beacon aborted: %lu\n",
584 priv
->stats
.txviokint
,
585 // priv->stats.txvierr,
586 priv
->stats
.txvookint
,
587 // priv->stats.txvoerr,
588 priv
->stats
.txbeokint
,
589 // priv->stats.txbeerr,
590 priv
->stats
.txbkokint
,
591 // priv->stats.txbkerr,
592 priv
->stats
.txmanageokint
,
593 // priv->stats.txmanageerr,
594 priv
->stats
.txbeaconokint
,
595 priv
->stats
.txbeaconerr
,
596 priv
->stats
.txcmdpktokint
,
597 // priv->stats.txhpokint,
598 // priv->stats.txhperr,
599 // priv->stats.txresumed,
600 netif_queue_stopped(dev
),
601 priv
->stats
.txoverflow
,
602 // priv->stats.txbeacon,
603 // atomic_read(&(priv->tx_pending[VI_QUEUE])),
604 // atomic_read(&(priv->tx_pending[VO_QUEUE])),
605 // atomic_read(&(priv->tx_pending[BE_QUEUE])),
606 // atomic_read(&(priv->tx_pending[BK_QUEUE])),
607 // read_nic_byte(dev, TXFIFOCOUNT),
608 // priv->stats.txvidrop,
609 // priv->stats.txvodrop,
610 priv
->ieee80211
->stats
.tx_packets
,
611 priv
->ieee80211
->stats
.tx_bytes
614 // priv->stats.txbedrop,
615 // priv->stats.txbkdrop
616 // priv->stats.txdatapkt
617 // priv->stats.txbeaconerr
626 static int proc_get_stats_rx(char *page
, char **start
,
627 off_t offset
, int count
,
628 int *eof
, void *data
)
630 struct net_device
*dev
= data
;
631 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
635 len
+= snprintf(page
+ len
, count
- len
,
638 "RX rx overflow error: %lu\n"
639 "RX invalid urb error: %lu\n",
642 priv
->stats
.rxoverflow
,
643 priv
->stats
.rxurberr
);
649 static void rtl8192_proc_module_init(void)
651 RT_TRACE(COMP_INIT
, "Initializing proc filesystem");
652 rtl8192_proc
=create_proc_entry(RTL819xE_MODULE_NAME
, S_IFDIR
, init_net
.proc_net
);
656 static void rtl8192_proc_module_remove(void)
658 remove_proc_entry(RTL819xE_MODULE_NAME
, init_net
.proc_net
);
662 static void rtl8192_proc_remove_one(struct net_device
*dev
)
664 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
666 printk("dev name=======> %s\n",dev
->name
);
669 // remove_proc_entry("stats-hw", priv->dir_dev);
670 remove_proc_entry("stats-tx", priv
->dir_dev
);
671 remove_proc_entry("stats-rx", priv
->dir_dev
);
672 // remove_proc_entry("stats-ieee", priv->dir_dev);
673 remove_proc_entry("stats-ap", priv
->dir_dev
);
674 remove_proc_entry("registers", priv
->dir_dev
);
675 // remove_proc_entry("cck-registers",priv->dir_dev);
676 // remove_proc_entry("ofdm-registers",priv->dir_dev);
677 //remove_proc_entry(dev->name, rtl8192_proc);
678 remove_proc_entry("wlan0", rtl8192_proc
);
679 priv
->dir_dev
= NULL
;
684 static void rtl8192_proc_init_one(struct net_device
*dev
)
686 struct proc_dir_entry
*e
;
687 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
688 priv
->dir_dev
= create_proc_entry(dev
->name
,
689 S_IFDIR
| S_IRUGO
| S_IXUGO
,
691 if (!priv
->dir_dev
) {
692 RT_TRACE(COMP_ERR
, "Unable to initialize /proc/net/rtl8192/%s\n",
696 e
= create_proc_read_entry("stats-rx", S_IFREG
| S_IRUGO
,
697 priv
->dir_dev
, proc_get_stats_rx
, dev
);
700 RT_TRACE(COMP_ERR
,"Unable to initialize "
701 "/proc/net/rtl8192/%s/stats-rx\n",
706 e
= create_proc_read_entry("stats-tx", S_IFREG
| S_IRUGO
,
707 priv
->dir_dev
, proc_get_stats_tx
, dev
);
710 RT_TRACE(COMP_ERR
, "Unable to initialize "
711 "/proc/net/rtl8192/%s/stats-tx\n",
715 e
= create_proc_read_entry("stats-ap", S_IFREG
| S_IRUGO
,
716 priv
->dir_dev
, proc_get_stats_ap
, dev
);
719 RT_TRACE(COMP_ERR
, "Unable to initialize "
720 "/proc/net/rtl8192/%s/stats-ap\n",
724 e
= create_proc_read_entry("registers", S_IFREG
| S_IRUGO
,
725 priv
->dir_dev
, proc_get_registers
, dev
);
727 RT_TRACE(COMP_ERR
, "Unable to initialize "
728 "/proc/net/rtl8192/%s/registers\n",
733 short check_nic_enough_desc(struct net_device
*dev
, int prio
)
735 struct r8192_priv
*priv
= ieee80211_priv(dev
);
736 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
738 /* for now we reserve two free descriptor as a safety boundary
739 * between the tail and the head
741 return (ring
->entries
- skb_queue_len(&ring
->queue
) >= 2);
744 static void tx_timeout(struct net_device
*dev
)
746 struct r8192_priv
*priv
= ieee80211_priv(dev
);
748 schedule_work(&priv
->reset_wq
);
752 static void rtl8192_irq_enable(struct net_device
*dev
)
754 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
755 priv
->irq_enabled
= 1;
756 write_nic_dword(dev
,INTA_MASK
, priv
->irq_mask
);
759 void rtl8192_irq_disable(struct net_device
*dev
)
761 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
763 write_nic_dword(dev
,INTA_MASK
,0);
764 priv
->irq_enabled
= 0;
767 void rtl8192_update_msr(struct net_device
*dev
)
769 struct r8192_priv
*priv
= ieee80211_priv(dev
);
772 msr
= read_nic_byte(dev
, MSR
);
773 msr
&= ~ MSR_LINK_MASK
;
775 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
776 * msr must be updated if the state is ASSOCIATING.
777 * this is intentional and make sense for ad-hoc and
778 * master (see the create BSS/IBSS func)
780 if (priv
->ieee80211
->state
== IEEE80211_LINKED
){
782 if (priv
->ieee80211
->iw_mode
== IW_MODE_INFRA
)
783 msr
|= (MSR_LINK_MANAGED
<<MSR_LINK_SHIFT
);
784 else if (priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
785 msr
|= (MSR_LINK_ADHOC
<<MSR_LINK_SHIFT
);
786 else if (priv
->ieee80211
->iw_mode
== IW_MODE_MASTER
)
787 msr
|= (MSR_LINK_MASTER
<<MSR_LINK_SHIFT
);
790 msr
|= (MSR_LINK_NONE
<<MSR_LINK_SHIFT
);
792 write_nic_byte(dev
, MSR
, msr
);
795 void rtl8192_set_chan(struct net_device
*dev
,short ch
)
797 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
801 /* need to implement rf set channel here WB */
803 if (priv
->rf_set_chan
)
804 priv
->rf_set_chan(dev
, priv
->chan
);
807 void rtl8192_rx_enable(struct net_device
*dev
)
809 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
811 write_nic_dword(dev
, RDQDA
,priv
->rx_ring_dma
);
814 /* the TX_DESC_BASE setting is according to the following queue index
823 * BEACON_QUEUE ===> 8
825 static const u32 TX_DESC_BASE
[] = {BKQDA
, BEQDA
, VIQDA
, VOQDA
, HCCAQDA
, CQDA
, MQDA
, HQDA
, BQDA
};
826 void rtl8192_tx_enable(struct net_device
*dev
)
828 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
831 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
832 write_nic_dword(dev
, TX_DESC_BASE
[i
], priv
->tx_ring
[i
].dma
);
834 ieee80211_reset_queue(priv
->ieee80211
);
838 static void rtl8192_free_rx_ring(struct net_device
*dev
)
840 struct r8192_priv
*priv
= ieee80211_priv(dev
);
843 for (i
= 0; i
< priv
->rxringcount
; i
++) {
844 struct sk_buff
*skb
= priv
->rx_buf
[i
];
848 pci_unmap_single(priv
->pdev
,
849 *((dma_addr_t
*)skb
->cb
),
850 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
854 pci_free_consistent(priv
->pdev
, sizeof(*priv
->rx_ring
) * priv
->rxringcount
,
855 priv
->rx_ring
, priv
->rx_ring_dma
);
856 priv
->rx_ring
= NULL
;
859 static void rtl8192_free_tx_ring(struct net_device
*dev
, unsigned int prio
)
861 struct r8192_priv
*priv
= ieee80211_priv(dev
);
862 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
864 while (skb_queue_len(&ring
->queue
)) {
865 tx_desc_819x_pci
*entry
= &ring
->desc
[ring
->idx
];
866 struct sk_buff
*skb
= __skb_dequeue(&ring
->queue
);
868 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
869 skb
->len
, PCI_DMA_TODEVICE
);
871 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
874 pci_free_consistent(priv
->pdev
, sizeof(*ring
->desc
)*ring
->entries
,
875 ring
->desc
, ring
->dma
);
879 void PHY_SetRtl8192eRfOff(struct net_device
* dev
)
881 //disable RF-Chip A/B
882 rtl8192_setBBreg(dev
, rFPGA0_XA_RFInterfaceOE
, BIT4
, 0x0);
883 //analog to digital off, for power save
884 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter4
, 0x300, 0x0);
885 //digital to analog off, for power save
886 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter1
, 0x18, 0x0);
888 rtl8192_setBBreg(dev
, rOFDM0_TRxPathEnable
, 0xf, 0x0);
890 rtl8192_setBBreg(dev
, rOFDM1_TRxPathEnable
, 0xf, 0x0);
891 //analog to digital part2 off, for power save
892 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter1
, 0x60, 0x0);
893 rtl8192_setBBreg(dev
, rFPGA0_AnalogParameter1
, 0x4, 0x0);
894 // Analog parameter!!Change bias and Lbus control.
895 write_nic_byte(dev
, ANAPAR_FOR_8192PciE
, 0x07);
899 void rtl8192_halt_adapter(struct net_device
*dev
, bool reset
)
901 struct r8192_priv
*priv
= ieee80211_priv(dev
);
906 OpMode
= RT_OP_MODE_NO_LINK
;
907 priv
->ieee80211
->SetHwRegHandler(dev
, HW_VAR_MEDIA_STATUS
, &OpMode
);
909 if (!priv
->ieee80211
->bSupportRemoteWakeUp
) {
911 * disable tx/rx. In 8185 we write 0x10 (Reset bit),
912 * but here we make reference to WMAC and wirte 0x0
914 write_nic_byte(dev
, CMDR
, 0);
923 priv
->bHwRfOffAction
= 2;
927 * Call MgntActSet_RF_State instead to
928 * prevent RF config race condition.
930 if (!priv
->ieee80211
->bSupportRemoteWakeUp
) {
931 PHY_SetRtl8192eRfOff(dev
);
932 ulRegRead
= read_nic_dword(dev
,CPU_GEN
);
933 ulRegRead
|= CPU_GEN_SYSTEM_RESET
;
934 write_nic_dword(dev
,CPU_GEN
, ulRegRead
);
937 write_nic_dword(dev
, WFCRC0
, 0xffffffff);
938 write_nic_dword(dev
, WFCRC1
, 0xffffffff);
939 write_nic_dword(dev
, WFCRC2
, 0xffffffff);
941 /* Write PMR register */
942 write_nic_byte(dev
, PMR
, 0x5);
943 /* Disable tx, enanble rx */
944 write_nic_byte(dev
, MacBlkCtrl
, 0xa);
948 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
949 skb_queue_purge(&priv
->ieee80211
->skb_waitQ
[i
]);
951 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
952 skb_queue_purge(&priv
->ieee80211
->skb_aggQ
[i
]);
955 skb_queue_purge(&priv
->skb_queue
);
958 static const u16 rtl_rate
[] = {10,20,55,110,60,90,120,180,240,360,480,540};
959 inline u16
rtl8192_rate2rate(short rate
)
961 if (rate
>11) return 0;
962 return rtl_rate
[rate
];
965 static void rtl8192_data_hard_stop(struct net_device
*dev
)
969 static void rtl8192_data_hard_resume(struct net_device
*dev
)
974 * this function TX data frames when the ieee80211 stack requires this.
975 * It checks also if we need to stop the ieee tx queue, eventually do it
977 static void rtl8192_hard_data_xmit(struct sk_buff
*skb
, struct net_device
*dev
, int rate
)
979 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
981 cb_desc
*tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
982 u8 queue_index
= tcb_desc
->queue_index
;
984 /* shall not be referred by command packet */
985 assert(queue_index
!= TXCMD_QUEUE
);
987 if (priv
->bHwRadioOff
|| (!priv
->up
))
993 memcpy(skb
->cb
, &dev
, sizeof(dev
));
995 skb_push(skb
, priv
->ieee80211
->tx_headroom
);
996 ret
= rtl8192_tx(dev
, skb
);
1001 if (queue_index
!= MGNT_QUEUE
) {
1002 priv
->ieee80211
->stats
.tx_bytes
+= (skb
->len
- priv
->ieee80211
->tx_headroom
);
1003 priv
->ieee80211
->stats
.tx_packets
++;
1008 * This is a rough attempt to TX a frame
1009 * This is called by the ieee 80211 stack to TX management frames.
1010 * If the ring is full packet are dropped (for data frame the queue
1011 * is stopped before this can happen).
1013 static int rtl8192_hard_start_xmit(struct sk_buff
*skb
,struct net_device
*dev
)
1015 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
1017 cb_desc
*tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
1018 u8 queue_index
= tcb_desc
->queue_index
;
1020 if (queue_index
!= TXCMD_QUEUE
) {
1021 if (priv
->bHwRadioOff
|| (!priv
->up
))
1028 memcpy(skb
->cb
, &dev
, sizeof(dev
));
1029 if (queue_index
== TXCMD_QUEUE
) {
1030 rtl819xE_tx_cmd(dev
, skb
);
1034 tcb_desc
->RATRIndex
= 7;
1035 tcb_desc
->bTxDisableRateFallBack
= 1;
1036 tcb_desc
->bTxUseDriverAssingedRate
= 1;
1037 tcb_desc
->bTxEnableFwCalcDur
= 1;
1038 skb_push(skb
, priv
->ieee80211
->tx_headroom
);
1039 ret
= rtl8192_tx(dev
, skb
);
1049 static void rtl8192_tx_isr(struct net_device
*dev
, int prio
)
1051 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
1053 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
1055 while (skb_queue_len(&ring
->queue
)) {
1056 tx_desc_819x_pci
*entry
= &ring
->desc
[ring
->idx
];
1057 struct sk_buff
*skb
;
1059 /* beacon packet will only use the first descriptor defaultly,
1060 * and the OWN may not be cleared by the hardware
1062 if(prio
!= BEACON_QUEUE
) {
1065 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
1068 skb
= __skb_dequeue(&ring
->queue
);
1069 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
1070 skb
->len
, PCI_DMA_TODEVICE
);
1074 if (prio
== MGNT_QUEUE
){
1075 if (priv
->ieee80211
->ack_tx_to_ieee
){
1076 if (rtl8192_is_tx_queue_empty(dev
)){
1077 priv
->ieee80211
->ack_tx_to_ieee
= 0;
1078 ieee80211_ps_tx_ack(priv
->ieee80211
, 1);
1083 if(prio
!= BEACON_QUEUE
) {
1084 /* try to deal with the pending packets */
1085 tasklet_schedule(&priv
->irq_tx_tasklet
);
1090 static void rtl8192_stop_beacon(struct net_device
*dev
)
1094 static void rtl8192_config_rate(struct net_device
* dev
, u16
* rate_config
)
1096 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1097 struct ieee80211_network
*net
;
1098 u8 i
=0, basic_rate
= 0;
1099 net
= & priv
->ieee80211
->current_network
;
1101 for (i
=0; i
<net
->rates_len
; i
++)
1103 basic_rate
= net
->rates
[i
]&0x7f;
1106 case MGN_1M
: *rate_config
|= RRSR_1M
; break;
1107 case MGN_2M
: *rate_config
|= RRSR_2M
; break;
1108 case MGN_5_5M
: *rate_config
|= RRSR_5_5M
; break;
1109 case MGN_11M
: *rate_config
|= RRSR_11M
; break;
1110 case MGN_6M
: *rate_config
|= RRSR_6M
; break;
1111 case MGN_9M
: *rate_config
|= RRSR_9M
; break;
1112 case MGN_12M
: *rate_config
|= RRSR_12M
; break;
1113 case MGN_18M
: *rate_config
|= RRSR_18M
; break;
1114 case MGN_24M
: *rate_config
|= RRSR_24M
; break;
1115 case MGN_36M
: *rate_config
|= RRSR_36M
; break;
1116 case MGN_48M
: *rate_config
|= RRSR_48M
; break;
1117 case MGN_54M
: *rate_config
|= RRSR_54M
; break;
1120 for (i
=0; i
<net
->rates_ex_len
; i
++)
1122 basic_rate
= net
->rates_ex
[i
]&0x7f;
1125 case MGN_1M
: *rate_config
|= RRSR_1M
; break;
1126 case MGN_2M
: *rate_config
|= RRSR_2M
; break;
1127 case MGN_5_5M
: *rate_config
|= RRSR_5_5M
; break;
1128 case MGN_11M
: *rate_config
|= RRSR_11M
; break;
1129 case MGN_6M
: *rate_config
|= RRSR_6M
; break;
1130 case MGN_9M
: *rate_config
|= RRSR_9M
; break;
1131 case MGN_12M
: *rate_config
|= RRSR_12M
; break;
1132 case MGN_18M
: *rate_config
|= RRSR_18M
; break;
1133 case MGN_24M
: *rate_config
|= RRSR_24M
; break;
1134 case MGN_36M
: *rate_config
|= RRSR_36M
; break;
1135 case MGN_48M
: *rate_config
|= RRSR_48M
; break;
1136 case MGN_54M
: *rate_config
|= RRSR_54M
; break;
1142 #define SHORT_SLOT_TIME 9
1143 #define NON_SHORT_SLOT_TIME 20
1145 static void rtl8192_update_cap(struct net_device
* dev
, u16 cap
)
1148 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1149 struct ieee80211_network
*net
= &priv
->ieee80211
->current_network
;
1150 priv
->short_preamble
= cap
& WLAN_CAPABILITY_SHORT_PREAMBLE
;
1151 tmp
= priv
->basic_rate
;
1152 if (priv
->short_preamble
)
1153 tmp
|= BRSR_AckShortPmb
;
1154 write_nic_dword(dev
, RRSR
, tmp
);
1156 if (net
->mode
& (IEEE_G
|IEEE_N_24G
))
1159 if ((cap
& WLAN_CAPABILITY_SHORT_SLOT
)&&(!priv
->ieee80211
->pHTInfo
->bCurrentRT2RTLongSlotTime
))
1161 slot_time
= SHORT_SLOT_TIME
;
1163 else //long slot time
1164 slot_time
= NON_SHORT_SLOT_TIME
;
1165 priv
->slot_time
= slot_time
;
1166 write_nic_byte(dev
, SLOT_TIME
, slot_time
);
1171 static void rtl8192_net_update(struct net_device
*dev
)
1173 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1174 struct ieee80211_network
*net
;
1175 u16 BcnTimeCfg
= 0, BcnCW
= 6, BcnIFS
= 0xf;
1176 u16 rate_config
= 0;
1177 net
= &priv
->ieee80211
->current_network
;
1179 /* update Basic rate: RR, BRSR */
1180 rtl8192_config_rate(dev
, &rate_config
);
1183 * Select RRSR (in Legacy-OFDM and CCK)
1184 * For 8190, we select only 24M, 12M, 6M, 11M, 5.5M,
1185 * 2M, and 1M from the Basic rate.
1186 * We do not use other rates.
1188 priv
->basic_rate
= rate_config
&= 0x15f;
1191 write_nic_dword(dev
, BSSIDR
, ((u32
*)net
->bssid
)[0]);
1192 write_nic_word(dev
, BSSIDR
+4, ((u16
*)net
->bssid
)[2]);
1194 if (priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
1196 write_nic_word(dev
, ATIMWND
, 2);
1197 write_nic_word(dev
, BCN_DMATIME
, 256);
1198 write_nic_word(dev
, BCN_INTERVAL
, net
->beacon_interval
);
1200 * BIT15 of BCN_DRV_EARLY_INT will indicate
1201 * whether software beacon or hw beacon is applied.
1203 write_nic_word(dev
, BCN_DRV_EARLY_INT
, 10);
1204 write_nic_byte(dev
, BCN_ERR_THRESH
, 100);
1206 BcnTimeCfg
|= (BcnCW
<<BCN_TCFG_CW_SHIFT
);
1207 /* TODO: BcnIFS may required to be changed on ASIC */
1208 BcnTimeCfg
|= BcnIFS
<<BCN_TCFG_IFS
;
1209 write_nic_word(dev
, BCN_TCFG
, BcnTimeCfg
);
1213 void rtl819xE_tx_cmd(struct net_device
*dev
, struct sk_buff
*skb
)
1215 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1216 struct rtl8192_tx_ring
*ring
;
1217 tx_desc_819x_pci
*entry
;
1221 unsigned long flags
;
1223 ring
= &priv
->tx_ring
[TXCMD_QUEUE
];
1224 mapping
= pci_map_single(priv
->pdev
, skb
->data
, skb
->len
, PCI_DMA_TODEVICE
);
1226 spin_lock_irqsave(&priv
->irq_th_lock
,flags
);
1227 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
1228 entry
= &ring
->desc
[idx
];
1230 tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
1232 entry
->LINIP
= tcb_desc
->bLastIniPkt
;
1233 entry
->FirstSeg
= 1;//first segment
1234 entry
->LastSeg
= 1; //last segment
1235 if(tcb_desc
->bCmdOrInit
== DESC_PACKET_TYPE_INIT
) {
1236 entry
->CmdInit
= DESC_PACKET_TYPE_INIT
;
1238 entry
->CmdInit
= DESC_PACKET_TYPE_NORMAL
;
1239 entry
->Offset
= sizeof(TX_FWINFO_8190PCI
) + 8;
1240 entry
->PktSize
= (u16
)(tcb_desc
->pkt_size
+ entry
->Offset
);
1241 entry
->QueueSelect
= QSLT_CMD
;
1242 entry
->TxFWInfoSize
= 0x08;
1243 entry
->RATid
= (u8
)DESC_PACKET_TYPE_INIT
;
1245 entry
->TxBufferSize
= skb
->len
;
1246 entry
->TxBuffAddr
= cpu_to_le32(mapping
);
1249 #ifdef JOHN_DUMP_TXDESC
1251 tx_desc_819x_pci
*entry1
= &ring
->desc
[0];
1252 unsigned int *ptr
= (unsigned int *)entry1
;
1253 printk("<Tx descriptor>:\n");
1254 for (i
= 0; i
< 8; i
++)
1255 printk("%8x ", ptr
[i
]);
1259 __skb_queue_tail(&ring
->queue
, skb
);
1260 spin_unlock_irqrestore(&priv
->irq_th_lock
,flags
);
1262 write_nic_byte(dev
, TPPoll
, TPPoll_CQ
);
1268 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1269 * in TxFwInfo data structure
1271 static u8
MapHwQueueToFirmwareQueue(u8 QueueID
)
1277 QueueSelect
= QSLT_BE
;
1281 QueueSelect
= QSLT_BK
;
1285 QueueSelect
= QSLT_VO
;
1289 QueueSelect
= QSLT_VI
;
1293 QueueSelect
= QSLT_MGNT
;
1297 QueueSelect
= QSLT_BEACON
;
1301 QueueSelect
= QSLT_CMD
;
1306 RT_TRACE(COMP_ERR
, "Impossible Queue Selection: %d\n", QueueID
);
1312 static u8
MRateToHwRate8190Pci(u8 rate
)
1314 u8 ret
= DESC90_RATE1M
;
1317 case MGN_1M
: ret
= DESC90_RATE1M
; break;
1318 case MGN_2M
: ret
= DESC90_RATE2M
; break;
1319 case MGN_5_5M
: ret
= DESC90_RATE5_5M
; break;
1320 case MGN_11M
: ret
= DESC90_RATE11M
; break;
1321 case MGN_6M
: ret
= DESC90_RATE6M
; break;
1322 case MGN_9M
: ret
= DESC90_RATE9M
; break;
1323 case MGN_12M
: ret
= DESC90_RATE12M
; break;
1324 case MGN_18M
: ret
= DESC90_RATE18M
; break;
1325 case MGN_24M
: ret
= DESC90_RATE24M
; break;
1326 case MGN_36M
: ret
= DESC90_RATE36M
; break;
1327 case MGN_48M
: ret
= DESC90_RATE48M
; break;
1328 case MGN_54M
: ret
= DESC90_RATE54M
; break;
1330 // HT rate since here
1331 case MGN_MCS0
: ret
= DESC90_RATEMCS0
; break;
1332 case MGN_MCS1
: ret
= DESC90_RATEMCS1
; break;
1333 case MGN_MCS2
: ret
= DESC90_RATEMCS2
; break;
1334 case MGN_MCS3
: ret
= DESC90_RATEMCS3
; break;
1335 case MGN_MCS4
: ret
= DESC90_RATEMCS4
; break;
1336 case MGN_MCS5
: ret
= DESC90_RATEMCS5
; break;
1337 case MGN_MCS6
: ret
= DESC90_RATEMCS6
; break;
1338 case MGN_MCS7
: ret
= DESC90_RATEMCS7
; break;
1339 case MGN_MCS8
: ret
= DESC90_RATEMCS8
; break;
1340 case MGN_MCS9
: ret
= DESC90_RATEMCS9
; break;
1341 case MGN_MCS10
: ret
= DESC90_RATEMCS10
; break;
1342 case MGN_MCS11
: ret
= DESC90_RATEMCS11
; break;
1343 case MGN_MCS12
: ret
= DESC90_RATEMCS12
; break;
1344 case MGN_MCS13
: ret
= DESC90_RATEMCS13
; break;
1345 case MGN_MCS14
: ret
= DESC90_RATEMCS14
; break;
1346 case MGN_MCS15
: ret
= DESC90_RATEMCS15
; break;
1347 case (0x80|0x20): ret
= DESC90_RATEMCS32
; break;
1355 static u8
QueryIsShort(u8 TxHT
, u8 TxRate
, cb_desc
*tcb_desc
)
1359 tmp_Short
= (TxHT
==1)?((tcb_desc
->bUseShortGI
)?1:0):((tcb_desc
->bUseShortPreamble
)?1:0);
1361 if(TxHT
==1 && TxRate
!= DESC90_RATEMCS15
)
1368 * The tx procedure is just as following,
1369 * skb->cb will contain all the following information,
1370 * priority, morefrag, rate, &dev.
1372 short rtl8192_tx(struct net_device
*dev
, struct sk_buff
* skb
)
1374 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1375 struct rtl8192_tx_ring
*ring
;
1376 unsigned long flags
;
1377 cb_desc
*tcb_desc
= (cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
1378 tx_desc_819x_pci
*pdesc
= NULL
;
1379 TX_FWINFO_8190PCI
*pTxFwInfo
= NULL
;
1381 bool multi_addr
= false, broad_addr
= false, uni_addr
= false;
1382 u8
*pda_addr
= NULL
;
1385 if (priv
->bdisable_nic
) {
1386 RT_TRACE(COMP_ERR
, "Nic is disabled! Can't tx packet len=%d qidx=%d!!!\n",
1387 skb
->len
, tcb_desc
->queue_index
);
1392 priv
->ieee80211
->bAwakePktSent
= true;
1395 mapping
= pci_map_single(priv
->pdev
, skb
->data
, skb
->len
, PCI_DMA_TODEVICE
);
1397 /* collect the tx packets statitcs */
1398 pda_addr
= ((u8
*)skb
->data
) + sizeof(TX_FWINFO_8190PCI
);
1399 if (is_multicast_ether_addr(pda_addr
))
1401 else if (is_broadcast_ether_addr(pda_addr
))
1407 priv
->stats
.txbytesunicast
+= (u8
)(skb
->len
) - sizeof(TX_FWINFO_8190PCI
);
1408 else if (multi_addr
)
1409 priv
->stats
.txbytesmulticast
+= (u8
)(skb
->len
) - sizeof(TX_FWINFO_8190PCI
);
1411 priv
->stats
.txbytesbroadcast
+= (u8
)(skb
->len
) - sizeof(TX_FWINFO_8190PCI
);
1413 /* fill tx firmware */
1414 pTxFwInfo
= (PTX_FWINFO_8190PCI
)skb
->data
;
1415 memset(pTxFwInfo
, 0, sizeof(TX_FWINFO_8190PCI
));
1416 pTxFwInfo
->TxHT
= (tcb_desc
->data_rate
&0x80) ? 1 : 0;
1417 pTxFwInfo
->TxRate
= MRateToHwRate8190Pci((u8
)tcb_desc
->data_rate
);
1418 pTxFwInfo
->EnableCPUDur
= tcb_desc
->bTxEnableFwCalcDur
;
1419 pTxFwInfo
->Short
= QueryIsShort(pTxFwInfo
->TxHT
, pTxFwInfo
->TxRate
, tcb_desc
);
1421 /* Aggregation related */
1422 if (tcb_desc
->bAMPDUEnable
) {
1423 pTxFwInfo
->AllowAggregation
= 1;
1424 pTxFwInfo
->RxMF
= tcb_desc
->ampdu_factor
;
1425 pTxFwInfo
->RxAMD
= tcb_desc
->ampdu_density
;
1427 pTxFwInfo
->AllowAggregation
= 0;
1428 pTxFwInfo
->RxMF
= 0;
1429 pTxFwInfo
->RxAMD
= 0;
1432 /* Protection mode related */
1433 pTxFwInfo
->RtsEnable
= (tcb_desc
->bRTSEnable
) ? 1 : 0;
1434 pTxFwInfo
->CtsEnable
= (tcb_desc
->bCTSEnable
) ? 1 : 0;
1435 pTxFwInfo
->RtsSTBC
= (tcb_desc
->bRTSSTBC
) ? 1 : 0;
1436 pTxFwInfo
->RtsHT
= (tcb_desc
->rts_rate
&0x80) ? 1 : 0;
1437 pTxFwInfo
->RtsRate
= MRateToHwRate8190Pci((u8
)tcb_desc
->rts_rate
);
1438 pTxFwInfo
->RtsBandwidth
= 0;
1439 pTxFwInfo
->RtsSubcarrier
= tcb_desc
->RTSSC
;
1440 pTxFwInfo
->RtsShort
= (pTxFwInfo
->RtsHT
== 0) ? (tcb_desc
->bRTSUseShortPreamble
? 1 : 0) : (tcb_desc
->bRTSUseShortGI
? 1 : 0);
1442 /* Set Bandwidth and sub-channel settings. */
1443 if (priv
->CurrentChannelBW
== HT_CHANNEL_WIDTH_20_40
) {
1444 if (tcb_desc
->bPacketBW
) {
1445 pTxFwInfo
->TxBandwidth
= 1;
1447 pTxFwInfo
->TxSubCarrier
= 3;
1449 /* use duplicated mode */
1450 pTxFwInfo
->TxSubCarrier
= 0;
1453 pTxFwInfo
->TxBandwidth
= 0;
1454 pTxFwInfo
->TxSubCarrier
= priv
->nCur40MhzPrimeSC
;
1457 pTxFwInfo
->TxBandwidth
= 0;
1458 pTxFwInfo
->TxSubCarrier
= 0;
1461 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
1462 ring
= &priv
->tx_ring
[tcb_desc
->queue_index
];
1463 if (tcb_desc
->queue_index
!= BEACON_QUEUE
)
1464 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
1468 pdesc
= &ring
->desc
[idx
];
1469 if ((pdesc
->OWN
== 1) && (tcb_desc
->queue_index
!= BEACON_QUEUE
)) {
1470 RT_TRACE(COMP_ERR
, "No more TX desc@%d, ring->idx = %d,idx = %d,%x",
1471 tcb_desc
->queue_index
, ring
->idx
, idx
, skb
->len
);
1472 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
1476 /* fill tx descriptor */
1477 memset(pdesc
, 0, 12);
1482 pdesc
->Offset
= sizeof(TX_FWINFO_8190PCI
) + 8; /* We must add 8!! */
1483 pdesc
->PktSize
= (u16
)skb
->len
-sizeof(TX_FWINFO_8190PCI
);
1486 pdesc
->SecCAMID
= 0;
1487 pdesc
->RATid
= tcb_desc
->RATRIndex
;
1490 pdesc
->SecType
= 0x0;
1491 if (tcb_desc
->bHwSec
) {
1492 switch (priv
->ieee80211
->pairwise_key_type
) {
1493 case KEY_TYPE_WEP40
:
1494 case KEY_TYPE_WEP104
:
1495 pdesc
->SecType
= 0x1;
1499 pdesc
->SecType
= 0x2;
1503 pdesc
->SecType
= 0x3;
1507 pdesc
->SecType
= 0x0;
1516 pdesc
->QueueSelect
= MapHwQueueToFirmwareQueue(tcb_desc
->queue_index
);
1517 pdesc
->TxFWInfoSize
= sizeof(TX_FWINFO_8190PCI
);
1519 pdesc
->DISFB
= tcb_desc
->bTxDisableRateFallBack
;
1520 pdesc
->USERATE
= tcb_desc
->bTxUseDriverAssingedRate
;
1522 pdesc
->FirstSeg
= 1;
1524 pdesc
->TxBufferSize
= skb
->len
;
1526 pdesc
->TxBuffAddr
= cpu_to_le32(mapping
);
1527 __skb_queue_tail(&ring
->queue
, skb
);
1529 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
1530 dev
->trans_start
= jiffies
;
1531 write_nic_word(dev
, TPPoll
, 0x01<<tcb_desc
->queue_index
);
1535 static short rtl8192_alloc_rx_desc_ring(struct net_device
*dev
)
1537 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1538 rx_desc_819x_pci
*entry
= NULL
;
1541 priv
->rx_ring
= pci_alloc_consistent(priv
->pdev
,
1542 sizeof(*priv
->rx_ring
) * priv
->rxringcount
, &priv
->rx_ring_dma
);
1544 if (!priv
->rx_ring
|| (unsigned long)priv
->rx_ring
& 0xFF) {
1545 RT_TRACE(COMP_ERR
,"Cannot allocate RX ring\n");
1549 memset(priv
->rx_ring
, 0, sizeof(*priv
->rx_ring
) * priv
->rxringcount
);
1552 for (i
= 0; i
< priv
->rxringcount
; i
++) {
1553 struct sk_buff
*skb
= dev_alloc_skb(priv
->rxbuffersize
);
1554 dma_addr_t
*mapping
;
1555 entry
= &priv
->rx_ring
[i
];
1558 priv
->rx_buf
[i
] = skb
;
1559 mapping
= (dma_addr_t
*)skb
->cb
;
1560 *mapping
= pci_map_single(priv
->pdev
, skb_tail_pointer(skb
),
1561 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
1563 entry
->BufferAddress
= cpu_to_le32(*mapping
);
1565 entry
->Length
= priv
->rxbuffersize
;
1573 static int rtl8192_alloc_tx_desc_ring(struct net_device
*dev
,
1574 unsigned int prio
, unsigned int entries
)
1576 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
1577 tx_desc_819x_pci
*ring
;
1581 ring
= pci_alloc_consistent(priv
->pdev
, sizeof(*ring
) * entries
, &dma
);
1582 if (!ring
|| (unsigned long)ring
& 0xFF) {
1583 RT_TRACE(COMP_ERR
, "Cannot allocate TX ring (prio = %d)\n", prio
);
1587 memset(ring
, 0, sizeof(*ring
)*entries
);
1588 priv
->tx_ring
[prio
].desc
= ring
;
1589 priv
->tx_ring
[prio
].dma
= dma
;
1590 priv
->tx_ring
[prio
].idx
= 0;
1591 priv
->tx_ring
[prio
].entries
= entries
;
1592 skb_queue_head_init(&priv
->tx_ring
[prio
].queue
);
1594 for (i
= 0; i
< entries
; i
++)
1595 ring
[i
].NextDescAddress
=
1596 cpu_to_le32((u32
)dma
+ ((i
+ 1) % entries
) * sizeof(*ring
));
1602 static short rtl8192_pci_initdescring(struct net_device
*dev
)
1606 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1608 ret
= rtl8192_alloc_rx_desc_ring(dev
);
1614 /* general process for other queue */
1615 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
1616 ret
= rtl8192_alloc_tx_desc_ring(dev
, i
, priv
->txringcount
);
1618 goto err_free_rings
;
1622 /* specific process for hardware beacon process */
1623 ret
= rtl8192_alloc_tx_desc_ring(dev
, MAX_TX_QUEUE_COUNT
- 1, 2);
1625 goto err_free_rings
;
1631 rtl8192_free_rx_ring(dev
);
1632 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
1633 if (priv
->tx_ring
[i
].desc
)
1634 rtl8192_free_tx_ring(dev
, i
);
1638 static void rtl8192_pci_resetdescring(struct net_device
*dev
)
1640 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1643 /* force the rx_idx to the first one */
1645 rx_desc_819x_pci
*entry
= NULL
;
1646 for (i
= 0; i
< priv
->rxringcount
; i
++) {
1647 entry
= &priv
->rx_ring
[i
];
1653 /* after reset, release previous pending packet, and force the
1654 * tx idx to the first one */
1655 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
1656 if (priv
->tx_ring
[i
].desc
) {
1657 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[i
];
1659 while (skb_queue_len(&ring
->queue
)) {
1660 tx_desc_819x_pci
*entry
= &ring
->desc
[ring
->idx
];
1661 struct sk_buff
*skb
= __skb_dequeue(&ring
->queue
);
1663 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
1664 skb
->len
, PCI_DMA_TODEVICE
);
1666 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
1673 static void rtl8192_link_change(struct net_device
*dev
)
1675 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1676 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1677 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
1678 if (ieee
->state
== IEEE80211_LINKED
)
1680 rtl8192_net_update(dev
);
1681 rtl8192_update_ratr_table(dev
);
1683 //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
1684 if ((KEY_TYPE_WEP40
== ieee
->pairwise_key_type
) || (KEY_TYPE_WEP104
== ieee
->pairwise_key_type
))
1685 EnableHWSecurityConfig8192(dev
);
1690 write_nic_byte(dev
, 0x173, 0);
1692 /*update timing params*/
1693 //rtl8192_set_chan(dev, priv->chan);
1695 rtl8192_update_msr(dev
);
1697 // 2007/10/16 MH MAC Will update TSF according to all received beacon, so we have
1698 // // To set CBSSID bit when link with any AP or STA.
1699 if (ieee
->iw_mode
== IW_MODE_INFRA
|| ieee
->iw_mode
== IW_MODE_ADHOC
)
1702 reg
= read_nic_dword(dev
, RCR
);
1703 if (priv
->ieee80211
->state
== IEEE80211_LINKED
)
1704 priv
->ReceiveConfig
= reg
|= RCR_CBSSID
;
1706 priv
->ReceiveConfig
= reg
&= ~RCR_CBSSID
;
1707 write_nic_dword(dev
, RCR
, reg
);
1712 static const struct ieee80211_qos_parameters def_qos_parameters
= {
1713 {3,3,3,3},/* cw_min */
1714 {7,7,7,7},/* cw_max */
1715 {2,2,2,2},/* aifs */
1716 {0,0,0,0},/* flags */
1717 {0,0,0,0} /* tx_op_limit */
1720 static void rtl8192_update_beacon(struct work_struct
* work
)
1722 struct r8192_priv
*priv
= container_of(work
, struct r8192_priv
, update_beacon_wq
.work
);
1723 struct net_device
*dev
= priv
->ieee80211
->dev
;
1724 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1725 struct ieee80211_network
* net
= &ieee
->current_network
;
1727 if (ieee
->pHTInfo
->bCurrentHTSupport
)
1728 HTUpdateSelfAndPeerSetting(ieee
, net
);
1729 ieee
->pHTInfo
->bCurrentRT2RTLongSlotTime
= net
->bssht
.bdRT2RTLongSlotTime
;
1730 rtl8192_update_cap(dev
, net
->capability
);
1734 * background support to run QoS activate functionality
1736 static const int WDCAPARA_ADD
[] = {EDCAPARA_BE
,EDCAPARA_BK
,EDCAPARA_VI
,EDCAPARA_VO
};
1737 static void rtl8192_qos_activate(struct work_struct
* work
)
1739 struct r8192_priv
*priv
= container_of(work
, struct r8192_priv
, qos_activate
);
1740 struct net_device
*dev
= priv
->ieee80211
->dev
;
1741 struct ieee80211_qos_parameters
*qos_parameters
= &priv
->ieee80211
->current_network
.qos_data
.parameters
;
1742 u8 mode
= priv
->ieee80211
->current_network
.mode
;
1747 mutex_lock(&priv
->mutex
);
1748 if(priv
->ieee80211
->state
!= IEEE80211_LINKED
)
1750 RT_TRACE(COMP_QOS
,"qos active process with associate response received\n");
1751 /* It better set slot time at first */
1752 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
1753 /* update the ac parameter to related registers */
1754 for(i
= 0; i
< QOS_QUEUE_NUM
; i
++) {
1755 //Mode G/A: slotTimeTimer = 9; Mode B: 20
1756 u1bAIFS
= qos_parameters
->aifs
[i
] * ((mode
&(IEEE_G
|IEEE_N_24G
)) ?9:20) + aSifsTime
;
1757 u4bAcParam
= ((((u32
)(qos_parameters
->tx_op_limit
[i
]))<< AC_PARAM_TXOP_LIMIT_OFFSET
)|
1758 (((u32
)(qos_parameters
->cw_max
[i
]))<< AC_PARAM_ECW_MAX_OFFSET
)|
1759 (((u32
)(qos_parameters
->cw_min
[i
]))<< AC_PARAM_ECW_MIN_OFFSET
)|
1760 ((u32
)u1bAIFS
<< AC_PARAM_AIFS_OFFSET
));
1761 //printk("===>u4bAcParam:%x, ", u4bAcParam);
1762 write_nic_dword(dev
, WDCAPARA_ADD
[i
], u4bAcParam
);
1763 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
1767 mutex_unlock(&priv
->mutex
);
1770 static int rtl8192_qos_handle_probe_response(struct r8192_priv
*priv
,
1772 struct ieee80211_network
*network
)
1775 u32 size
= sizeof(struct ieee80211_qos_parameters
);
1777 if(priv
->ieee80211
->state
!=IEEE80211_LINKED
)
1780 if ((priv
->ieee80211
->iw_mode
!= IW_MODE_INFRA
))
1783 if (network
->flags
& NETWORK_HAS_QOS_MASK
) {
1784 if (active_network
&&
1785 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
))
1786 network
->qos_data
.active
= network
->qos_data
.supported
;
1788 if ((network
->qos_data
.active
== 1) && (active_network
== 1) &&
1789 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) &&
1790 (network
->qos_data
.old_param_count
!=
1791 network
->qos_data
.param_count
)) {
1792 network
->qos_data
.old_param_count
=
1793 network
->qos_data
.param_count
;
1794 queue_work(priv
->priv_wq
, &priv
->qos_activate
);
1795 RT_TRACE (COMP_QOS
, "QoS parameters change call "
1799 memcpy(&priv
->ieee80211
->current_network
.qos_data
.parameters
,
1800 &def_qos_parameters
, size
);
1802 if ((network
->qos_data
.active
== 1) && (active_network
== 1)) {
1803 queue_work(priv
->priv_wq
, &priv
->qos_activate
);
1804 RT_TRACE(COMP_QOS
, "QoS was disabled call qos_activate \n");
1806 network
->qos_data
.active
= 0;
1807 network
->qos_data
.supported
= 0;
1813 /* handle manage frame frame beacon and probe response */
1814 static int rtl8192_handle_beacon(struct net_device
* dev
,
1815 struct ieee80211_beacon
* beacon
,
1816 struct ieee80211_network
* network
)
1818 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1820 rtl8192_qos_handle_probe_response(priv
,1,network
);
1822 queue_delayed_work(priv
->priv_wq
, &priv
->update_beacon_wq
, 0);
1828 * handling the beaconing responses. if we get different QoS setting
1829 * off the network from the associated setting, adjust the QoS setting
1831 static int rtl8192_qos_association_resp(struct r8192_priv
*priv
,
1832 struct ieee80211_network
*network
)
1835 unsigned long flags
;
1836 u32 size
= sizeof(struct ieee80211_qos_parameters
);
1837 int set_qos_param
= 0;
1839 if ((priv
== NULL
) || (network
== NULL
))
1842 if (priv
->ieee80211
->state
!= IEEE80211_LINKED
)
1845 if ((priv
->ieee80211
->iw_mode
!= IW_MODE_INFRA
))
1848 spin_lock_irqsave(&priv
->ieee80211
->lock
, flags
);
1849 if (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) {
1850 memcpy(&priv
->ieee80211
->current_network
.qos_data
.parameters
,
1851 &network
->qos_data
.parameters
,
1852 sizeof(struct ieee80211_qos_parameters
));
1853 priv
->ieee80211
->current_network
.qos_data
.active
= 1;
1855 /* update qos parameter for current network */
1856 priv
->ieee80211
->current_network
.qos_data
.old_param_count
=
1857 priv
->ieee80211
->current_network
.qos_data
.param_count
;
1858 priv
->ieee80211
->current_network
.qos_data
.param_count
=
1859 network
->qos_data
.param_count
;
1862 memcpy(&priv
->ieee80211
->current_network
.qos_data
.parameters
,
1863 &def_qos_parameters
, size
);
1864 priv
->ieee80211
->current_network
.qos_data
.active
= 0;
1865 priv
->ieee80211
->current_network
.qos_data
.supported
= 0;
1869 spin_unlock_irqrestore(&priv
->ieee80211
->lock
, flags
);
1871 RT_TRACE(COMP_QOS
, "%s: network->flags = %d,%d\n", __FUNCTION__
,
1872 network
->flags
, priv
->ieee80211
->current_network
.qos_data
.active
);
1873 if (set_qos_param
== 1)
1874 queue_work(priv
->priv_wq
, &priv
->qos_activate
);
1880 static int rtl8192_handle_assoc_response(struct net_device
*dev
,
1881 struct ieee80211_assoc_response_frame
*resp
,
1882 struct ieee80211_network
*network
)
1884 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1885 rtl8192_qos_association_resp(priv
, network
);
1890 /* updateRATRTabel for MCS only. Basic rate is not implemented. */
1891 static void rtl8192_update_ratr_table(struct net_device
* dev
)
1893 struct r8192_priv
* priv
= ieee80211_priv(dev
);
1894 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1895 u8
* pMcsRate
= ieee
->dot11HTOperationalRateSet
;
1899 rtl8192_config_rate(dev
, (u16
*)(&ratr_value
));
1900 ratr_value
|= (*(u16
*)(pMcsRate
)) << 12;
1905 ratr_value
&= 0x00000FF0;
1908 ratr_value
&= 0x0000000F;
1911 ratr_value
&= 0x00000FF7;
1915 if (ieee
->pHTInfo
->PeerMimoPs
== 0) //MIMO_PS_STATIC
1916 ratr_value
&= 0x0007F007;
1918 if (priv
->rf_type
== RF_1T2R
)
1919 ratr_value
&= 0x000FF007;
1921 ratr_value
&= 0x0F81F007;
1927 ratr_value
&= 0x0FFFFFFF;
1928 if(ieee
->pHTInfo
->bCurTxBW40MHz
&& ieee
->pHTInfo
->bCurShortGI40MHz
){
1929 ratr_value
|= 0x80000000;
1930 }else if(!ieee
->pHTInfo
->bCurTxBW40MHz
&& ieee
->pHTInfo
->bCurShortGI20MHz
){
1931 ratr_value
|= 0x80000000;
1933 write_nic_dword(dev
, RATR0
+rate_index
*4, ratr_value
);
1934 write_nic_byte(dev
, UFWP
, 1);
1937 static bool GetNmodeSupportBySecCfg8190Pci(struct net_device
*dev
)
1939 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1940 struct ieee80211_device
*ieee
= priv
->ieee80211
;
1942 return !(ieee
->rtllib_ap_sec_type
&&
1943 (ieee
->rtllib_ap_sec_type(ieee
)&(SEC_ALG_WEP
|SEC_ALG_TKIP
)));
1946 static void rtl8192_refresh_supportrate(struct r8192_priv
* priv
)
1948 struct ieee80211_device
* ieee
= priv
->ieee80211
;
1949 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
1950 if (ieee
->mode
== WIRELESS_MODE_N_24G
|| ieee
->mode
== WIRELESS_MODE_N_5G
)
1952 memcpy(ieee
->Regdot11HTOperationalRateSet
, ieee
->RegHTSuppRateSet
, 16);
1953 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
1954 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
1957 memset(ieee
->Regdot11HTOperationalRateSet
, 0, 16);
1960 static u8
rtl8192_getSupportedWireleeMode(struct net_device
*dev
)
1962 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1964 switch(priv
->rf_chip
)
1969 ret
= (WIRELESS_MODE_N_24G
|WIRELESS_MODE_G
|WIRELESS_MODE_B
);
1972 ret
= (WIRELESS_MODE_A
|WIRELESS_MODE_N_5G
);
1975 ret
= WIRELESS_MODE_B
;
1981 static void rtl8192_SetWirelessMode(struct net_device
* dev
, u8 wireless_mode
)
1983 struct r8192_priv
*priv
= ieee80211_priv(dev
);
1984 u8 bSupportMode
= rtl8192_getSupportedWireleeMode(dev
);
1987 if ((wireless_mode
== WIRELESS_MODE_AUTO
) || ((wireless_mode
&bSupportMode
)==0))
1989 if(bSupportMode
& WIRELESS_MODE_N_24G
)
1991 wireless_mode
= WIRELESS_MODE_N_24G
;
1993 else if(bSupportMode
& WIRELESS_MODE_N_5G
)
1995 wireless_mode
= WIRELESS_MODE_N_5G
;
1997 else if((bSupportMode
& WIRELESS_MODE_A
))
1999 wireless_mode
= WIRELESS_MODE_A
;
2001 else if((bSupportMode
& WIRELESS_MODE_G
))
2003 wireless_mode
= WIRELESS_MODE_G
;
2005 else if((bSupportMode
& WIRELESS_MODE_B
))
2007 wireless_mode
= WIRELESS_MODE_B
;
2010 RT_TRACE(COMP_ERR
, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__
,bSupportMode
);
2011 wireless_mode
= WIRELESS_MODE_B
;
2014 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2015 ActUpdateChannelAccessSetting( pAdapter
, pHalData
->CurrentWirelessMode
, &pAdapter
->MgntInfo
.Info8185
.ChannelAccessSetting
);
2017 priv
->ieee80211
->mode
= wireless_mode
;
2019 if ((wireless_mode
== WIRELESS_MODE_N_24G
) || (wireless_mode
== WIRELESS_MODE_N_5G
))
2020 priv
->ieee80211
->pHTInfo
->bEnableHT
= 1;
2022 priv
->ieee80211
->pHTInfo
->bEnableHT
= 0;
2023 RT_TRACE(COMP_INIT
, "Current Wireless Mode is %x\n", wireless_mode
);
2024 rtl8192_refresh_supportrate(priv
);
2029 static bool GetHalfNmodeSupportByAPs819xPci(struct net_device
* dev
)
2031 struct r8192_priv
* priv
= ieee80211_priv(dev
);
2032 struct ieee80211_device
* ieee
= priv
->ieee80211
;
2034 return ieee
->bHalfWirelessN24GMode
;
2037 short rtl8192_is_tx_queue_empty(struct net_device
*dev
)
2040 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2041 for (i
=0; i
<=MGNT_QUEUE
; i
++)
2043 if ((i
== TXCMD_QUEUE
) || (i
== HCCA_QUEUE
) )
2045 if (skb_queue_len(&(&priv
->tx_ring
[i
])->queue
) > 0){
2046 printk("===>tx queue is not empty:%d, %d\n", i
, skb_queue_len(&(&priv
->tx_ring
[i
])->queue
));
2053 static void rtl8192_hw_sleep_down(struct net_device
*dev
)
2055 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2056 unsigned long flags
= 0;
2058 spin_lock_irqsave(&priv
->rf_ps_lock
,flags
);
2059 if (priv
->RFChangeInProgress
) {
2060 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
2061 RT_TRACE(COMP_RF
, "rtl8192_hw_sleep_down(): RF Change in progress! \n");
2062 printk("rtl8192_hw_sleep_down(): RF Change in progress!\n");
2065 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
2067 MgntActSet_RF_State(dev
, eRfSleep
, RF_CHANGE_BY_PS
);
2070 static void rtl8192_hw_sleep_wq (struct work_struct
*work
)
2072 struct delayed_work
*dwork
= container_of(work
,struct delayed_work
,work
);
2073 struct ieee80211_device
*ieee
= container_of(dwork
,struct ieee80211_device
,hw_sleep_wq
);
2074 struct net_device
*dev
= ieee
->dev
;
2076 rtl8192_hw_sleep_down(dev
);
2079 static void rtl8192_hw_wakeup(struct net_device
* dev
)
2081 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2082 unsigned long flags
= 0;
2084 spin_lock_irqsave(&priv
->rf_ps_lock
,flags
);
2085 if (priv
->RFChangeInProgress
) {
2086 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
2087 RT_TRACE(COMP_RF
, "rtl8192_hw_wakeup(): RF Change in progress! \n");
2088 printk("rtl8192_hw_wakeup(): RF Change in progress! schedule wake up task again\n");
2089 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
2092 spin_unlock_irqrestore(&priv
->rf_ps_lock
,flags
);
2094 MgntActSet_RF_State(dev
, eRfOn
, RF_CHANGE_BY_PS
);
2097 void rtl8192_hw_wakeup_wq (struct work_struct
*work
)
2099 struct delayed_work
*dwork
= container_of(work
,struct delayed_work
,work
);
2100 struct ieee80211_device
*ieee
= container_of(dwork
,struct ieee80211_device
,hw_wakeup_wq
);
2101 struct net_device
*dev
= ieee
->dev
;
2102 rtl8192_hw_wakeup(dev
);
2106 #define MIN_SLEEP_TIME 50
2107 #define MAX_SLEEP_TIME 10000
2108 static void rtl8192_hw_to_sleep(struct net_device
*dev
, u32 th
, u32 tl
)
2110 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2113 unsigned long flags
;
2115 spin_lock_irqsave(&priv
->ps_lock
,flags
);
2117 // Writing HW register with 0 equals to disable
2118 // the timer, that is not really what we want
2120 tl
-= MSECS(8+16+7);
2122 // If the interval in witch we are requested to sleep is too
2123 // short then give up and remain awake
2124 // when we sleep after send null frame, the timer will be too short to sleep.
2126 if(((tl
>=rb
)&& (tl
-rb
) <= MSECS(MIN_SLEEP_TIME
))
2127 ||((rb
>tl
)&& (rb
-tl
) < MSECS(MIN_SLEEP_TIME
))) {
2128 spin_unlock_irqrestore(&priv
->ps_lock
,flags
);
2129 printk("too short to sleep::%x, %x, %lx\n",tl
, rb
, MSECS(MIN_SLEEP_TIME
));
2133 if(((tl
> rb
) && ((tl
-rb
) > MSECS(MAX_SLEEP_TIME
)))||
2134 ((tl
< rb
) && (tl
>MSECS(69)) && ((rb
-tl
) > MSECS(MAX_SLEEP_TIME
)))||
2135 ((tl
<rb
)&&(tl
<MSECS(69))&&((tl
+0xffffffff-rb
)>MSECS(MAX_SLEEP_TIME
)))) {
2136 printk("========>too long to sleep:%x, %x, %lx\n", tl
, rb
, MSECS(MAX_SLEEP_TIME
));
2137 spin_unlock_irqrestore(&priv
->ps_lock
,flags
);
2141 u32 tmp
= (tl
>rb
)?(tl
-rb
):(rb
-tl
);
2142 queue_delayed_work(priv
->ieee80211
->wq
,
2143 &priv
->ieee80211
->hw_wakeup_wq
,tmp
);
2144 //PowerSave not supported when kernel version less 2.6.20
2146 queue_delayed_work(priv
->ieee80211
->wq
,
2147 (void *)&priv
->ieee80211
->hw_sleep_wq
,0);
2148 spin_unlock_irqrestore(&priv
->ps_lock
,flags
);
2152 static void rtl8192_init_priv_variable(struct net_device
* dev
)
2154 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2156 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
2158 // Default Halt the NIC if RF is OFF.
2159 pPSC
->RegRfPsLevel
|= RT_RF_OFF_LEVL_HALT_NIC
;
2160 pPSC
->RegRfPsLevel
|= RT_RF_OFF_LEVL_CLK_REQ
;
2161 pPSC
->RegRfPsLevel
|= RT_RF_OFF_LEVL_ASPM
;
2162 pPSC
->RegRfPsLevel
|= RT_RF_LPS_LEVEL_ASPM
;
2163 pPSC
->bLeisurePs
= true;
2164 pPSC
->RegMaxLPSAwakeIntvl
= 5;
2165 priv
->bHwRadioOff
= false;
2167 priv
->being_init_adapter
= false;
2168 priv
->txbuffsize
= 1600;//1024;
2169 priv
->txfwbuffersize
= 4096;
2170 priv
->txringcount
= 64;//32;
2171 //priv->txbeaconcount = priv->txringcount;
2172 priv
->txbeaconcount
= 2;
2173 priv
->rxbuffersize
= 9100;//2048;//1024;
2174 priv
->rxringcount
= MAX_RX_COUNT
;//64;
2175 priv
->irq_enabled
=0;
2176 priv
->card_8192
= NIC_8192E
;
2177 priv
->rx_skb_complete
= 1;
2178 priv
->chan
= 1; //set to channel 1
2179 priv
->RegWirelessMode
= WIRELESS_MODE_AUTO
;
2180 priv
->RegChannelPlan
= 0xf;
2181 priv
->nrxAMPDU_size
= 0;
2182 priv
->nrxAMPDU_aggr_num
= 0;
2183 priv
->last_rxdesc_tsf_high
= 0;
2184 priv
->last_rxdesc_tsf_low
= 0;
2185 priv
->ieee80211
->mode
= WIRELESS_MODE_AUTO
; //SET AUTO
2186 priv
->ieee80211
->iw_mode
= IW_MODE_INFRA
;
2187 priv
->ieee80211
->ieee_up
=0;
2188 priv
->retry_rts
= DEFAULT_RETRY_RTS
;
2189 priv
->retry_data
= DEFAULT_RETRY_DATA
;
2190 priv
->ieee80211
->rts
= DEFAULT_RTS_THRESHOLD
;
2191 priv
->ieee80211
->rate
= 110; //11 mbps
2192 priv
->ieee80211
->short_slot
= 1;
2193 priv
->promisc
= (dev
->flags
& IFF_PROMISC
) ? 1:0;
2194 priv
->bcck_in_ch14
= false;
2195 priv
->bfsync_processing
= false;
2196 priv
->CCKPresentAttentuation
= 0;
2197 priv
->rfa_txpowertrackingindex
= 0;
2198 priv
->rfc_txpowertrackingindex
= 0;
2200 priv
->ScanDelay
= 50;//for Scan TODO
2201 //added by amy for silent reset
2202 priv
->ResetProgress
= RESET_TYPE_NORESET
;
2203 priv
->bForcedSilentReset
= 0;
2204 priv
->bDisableNormalResetCheck
= false;
2205 priv
->force_reset
= false;
2206 //added by amy for power save
2208 priv
->ieee80211
->RfOffReason
= 0;
2209 priv
->RFChangeInProgress
= false;
2210 priv
->bHwRfOffAction
= 0;
2211 priv
->SetRFPowerStateInProgress
= false;
2212 priv
->ieee80211
->PowerSaveControl
.bInactivePs
= true;
2213 priv
->ieee80211
->PowerSaveControl
.bIPSModeBackup
= false;
2215 priv
->txpower_checkcnt
= 0;
2216 priv
->thermal_readback_index
=0;
2217 priv
->txpower_tracking_callback_cnt
= 0;
2218 priv
->ccktxpower_adjustcnt_ch14
= 0;
2219 priv
->ccktxpower_adjustcnt_not_ch14
= 0;
2221 priv
->ieee80211
->current_network
.beacon_interval
= DEFAULT_BEACONINTERVAL
;
2222 priv
->ieee80211
->iw_mode
= IW_MODE_INFRA
;
2223 priv
->ieee80211
->softmac_features
= IEEE_SOFTMAC_SCAN
|
2224 IEEE_SOFTMAC_ASSOCIATE
| IEEE_SOFTMAC_PROBERQ
|
2225 IEEE_SOFTMAC_PROBERS
| IEEE_SOFTMAC_TX_QUEUE
;/* |
2226 IEEE_SOFTMAC_BEACONS;*///added by amy
080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2228 priv
->ieee80211
->active_scan
= 1;
2229 priv
->ieee80211
->modulation
= IEEE80211_CCK_MODULATION
| IEEE80211_OFDM_MODULATION
;
2230 priv
->ieee80211
->host_encrypt
= 1;
2231 priv
->ieee80211
->host_decrypt
= 1;
2232 //priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2233 //priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2234 priv
->ieee80211
->start_send_beacons
= rtl8192_start_beacon
;//+by david 081107
2235 priv
->ieee80211
->stop_send_beacons
= rtl8192_stop_beacon
;//+by david 081107
2236 priv
->ieee80211
->softmac_hard_start_xmit
= rtl8192_hard_start_xmit
;
2237 priv
->ieee80211
->set_chan
= rtl8192_set_chan
;
2238 priv
->ieee80211
->link_change
= rtl8192_link_change
;
2239 priv
->ieee80211
->softmac_data_hard_start_xmit
= rtl8192_hard_data_xmit
;
2240 priv
->ieee80211
->data_hard_stop
= rtl8192_data_hard_stop
;
2241 priv
->ieee80211
->data_hard_resume
= rtl8192_data_hard_resume
;
2242 priv
->ieee80211
->init_wmmparam_flag
= 0;
2243 priv
->ieee80211
->fts
= DEFAULT_FRAG_THRESHOLD
;
2244 priv
->ieee80211
->check_nic_enough_desc
= check_nic_enough_desc
;
2245 priv
->ieee80211
->tx_headroom
= sizeof(TX_FWINFO_8190PCI
);
2246 priv
->ieee80211
->qos_support
= 1;
2247 priv
->ieee80211
->dot11PowerSaveMode
= 0;
2249 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2250 priv
->ieee80211
->SetBWModeHandler
= rtl8192_SetBWMode
;
2251 priv
->ieee80211
->handle_assoc_response
= rtl8192_handle_assoc_response
;
2252 priv
->ieee80211
->handle_beacon
= rtl8192_handle_beacon
;
2254 priv
->ieee80211
->sta_wake_up
= rtl8192_hw_wakeup
;
2255 // priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
2256 priv
->ieee80211
->enter_sleep_state
= rtl8192_hw_to_sleep
;
2257 priv
->ieee80211
->ps_is_queue_empty
= rtl8192_is_tx_queue_empty
;
2259 priv
->ieee80211
->GetNmodeSupportBySecCfg
= GetNmodeSupportBySecCfg8190Pci
;
2260 priv
->ieee80211
->SetWirelessMode
= rtl8192_SetWirelessMode
;
2261 priv
->ieee80211
->GetHalfNmodeSupportByAPsHandler
= GetHalfNmodeSupportByAPs819xPci
;
2264 priv
->ieee80211
->InitialGainHandler
= InitialGain819xPci
;
2267 priv
->ieee80211
->ieee80211_ips_leave_wq
= ieee80211_ips_leave_wq
;
2268 priv
->ieee80211
->ieee80211_ips_leave
= ieee80211_ips_leave
;
2271 priv
->ieee80211
->LeisurePSLeave
= LeisurePSLeave
;
2274 priv
->ieee80211
->SetHwRegHandler
= rtl8192e_SetHwReg
;
2275 priv
->ieee80211
->rtllib_ap_sec_type
= rtl8192e_ap_sec_type
;
2277 priv
->card_type
= USB
;
2279 priv
->ShortRetryLimit
= 0x30;
2280 priv
->LongRetryLimit
= 0x30;
2282 priv
->EarlyRxThreshold
= 7;
2283 priv
->enable_gpio0
= 0;
2285 priv
->TransmitConfig
= 0;
2287 priv
->ReceiveConfig
= RCR_ADD3
|
2288 RCR_AMF
| RCR_ADF
| //accept management/data
2289 RCR_AICV
| //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2290 RCR_AB
| RCR_AM
| RCR_APM
| //accept BC/MC/UC
2291 RCR_AAP
| ((u32
)7<<RCR_MXDMA_OFFSET
) |
2292 ((u32
)7 << RCR_FIFO_OFFSET
) | RCR_ONLYERLPKT
;
2294 priv
->irq_mask
= (u32
)(IMR_ROK
| IMR_VODOK
| IMR_VIDOK
| IMR_BEDOK
| IMR_BKDOK
|
2295 IMR_HCCADOK
| IMR_MGNTDOK
| IMR_COMDOK
| IMR_HIGHDOK
|
2296 IMR_BDOK
| IMR_RXCMDOK
| IMR_TIMEOUT0
| IMR_RDU
| IMR_RXFOVW
|
2297 IMR_TXFOVW
| IMR_BcnInt
| IMR_TBDOK
| IMR_TBDER
);
2299 priv
->AcmControl
= 0;
2300 priv
->pFirmware
= (rt_firmware
*)vmalloc(sizeof(rt_firmware
));
2301 if (priv
->pFirmware
)
2302 memset(priv
->pFirmware
, 0, sizeof(rt_firmware
));
2304 /* rx related queue */
2305 skb_queue_head_init(&priv
->rx_queue
);
2306 skb_queue_head_init(&priv
->skb_queue
);
2308 /* Tx related queue */
2309 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
2310 skb_queue_head_init(&priv
->ieee80211
->skb_waitQ
[i
]);
2312 for(i
= 0; i
< MAX_QUEUE_SIZE
; i
++) {
2313 skb_queue_head_init(&priv
->ieee80211
->skb_aggQ
[i
]);
2315 priv
->rf_set_chan
= rtl8192_phy_SwChnl
;
2318 static void rtl8192_init_priv_lock(struct r8192_priv
* priv
)
2320 spin_lock_init(&priv
->tx_lock
);
2321 spin_lock_init(&priv
->irq_lock
);//added by thomas
2322 spin_lock_init(&priv
->irq_th_lock
);
2323 spin_lock_init(&priv
->rf_ps_lock
);
2324 spin_lock_init(&priv
->ps_lock
);
2325 //spin_lock_init(&priv->rf_lock);
2326 sema_init(&priv
->wx_sem
,1);
2327 sema_init(&priv
->rf_sem
,1);
2328 mutex_init(&priv
->mutex
);
2331 /* init tasklet and wait_queue here */
2332 #define DRV_NAME "wlan0"
2333 static void rtl8192_init_priv_task(struct net_device
* dev
)
2335 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2337 #ifdef PF_SYNCTHREAD
2338 priv
->priv_wq
= create_workqueue(DRV_NAME
,0);
2340 priv
->priv_wq
= create_workqueue(DRV_NAME
);
2344 INIT_WORK(&priv
->ieee80211
->ips_leave_wq
, (void*)IPSLeave_wq
);
2347 // INIT_WORK(&priv->reset_wq, (void(*)(void*)) rtl8192_restart);
2348 INIT_WORK(&priv
->reset_wq
, rtl8192_restart
);
2349 // INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2350 INIT_DELAYED_WORK(&priv
->watch_dog_wq
, rtl819x_watchdog_wqcallback
);
2351 INIT_DELAYED_WORK(&priv
->txpower_tracking_wq
, dm_txpower_trackingcallback
);
2352 INIT_DELAYED_WORK(&priv
->rfpath_check_wq
, dm_rf_pathcheck_workitemcallback
);
2353 INIT_DELAYED_WORK(&priv
->update_beacon_wq
, rtl8192_update_beacon
);
2354 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2355 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2356 INIT_WORK(&priv
->qos_activate
, rtl8192_qos_activate
);
2357 INIT_DELAYED_WORK(&priv
->ieee80211
->hw_wakeup_wq
,(void*) rtl8192_hw_wakeup_wq
);
2358 INIT_DELAYED_WORK(&priv
->ieee80211
->hw_sleep_wq
,(void*) rtl8192_hw_sleep_wq
);
2360 tasklet_init(&priv
->irq_rx_tasklet
,
2361 (void(*)(unsigned long))rtl8192_irq_rx_tasklet
,
2362 (unsigned long)priv
);
2363 tasklet_init(&priv
->irq_tx_tasklet
,
2364 (void(*)(unsigned long))rtl8192_irq_tx_tasklet
,
2365 (unsigned long)priv
);
2366 tasklet_init(&priv
->irq_prepare_beacon_tasklet
,
2367 (void(*)(unsigned long))rtl8192_prepare_beacon
,
2368 (unsigned long)priv
);
2371 static void rtl8192_get_eeprom_size(struct net_device
* dev
)
2374 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2375 RT_TRACE(COMP_INIT
, "===========>%s()\n", __FUNCTION__
);
2376 curCR
= read_nic_dword(dev
, EPROM_CMD
);
2377 RT_TRACE(COMP_INIT
, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD
, curCR
);
2378 //whether need I consider BIT5?
2379 priv
->epromtype
= (curCR
& EPROM_CMD_9356SEL
) ? EPROM_93c56
: EPROM_93c46
;
2380 RT_TRACE(COMP_INIT
, "<===========%s(), epromtype:%d\n", __FUNCTION__
, priv
->epromtype
);
2384 * used to swap endian. as ntohl & htonl are not
2385 * neccessary to swap endian, so use this instead.
2387 static inline u16
endian_swap(u16
* data
)
2390 *data
= (tmp
>> 8) | (tmp
<< 8);
2395 * Adapter->EEPROMAddressSize should be set before this function call.
2396 * EEPROM address size can be got through GetEEPROMSize8185()
2398 static void rtl8192_read_eeprom_info(struct net_device
* dev
)
2400 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2404 u8 ICVer8192
, ICVer8256
;
2406 u16 i
,usValue
, IC_Version
;
2410 u8 EepromTxPower
[100];
2412 u8 bMac_Tmp_Addr
[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01};
2413 RT_TRACE(COMP_INIT
, "====> rtl8192_read_eeprom_info\n");
2416 // TODO: I don't know if we need to apply EF function to EEPROM read function
2418 //2 Read EEPROM ID to make sure autoload is success
2419 EEPROMId
= eprom_read(dev
, 0);
2420 if( EEPROMId
!= RTL8190_EEPROM_ID
)
2422 RT_TRACE(COMP_ERR
, "EEPROM ID is invalid:%x, %x\n", EEPROMId
, RTL8190_EEPROM_ID
);
2423 priv
->AutoloadFailFlag
=true;
2427 priv
->AutoloadFailFlag
=false;
2431 // Assign Chip Version ID
2433 // Read IC Version && Channel Plan
2434 if(!priv
->AutoloadFailFlag
)
2437 priv
->eeprom_vid
= eprom_read(dev
, (EEPROM_VID
>> 1));
2438 priv
->eeprom_did
= eprom_read(dev
, (EEPROM_DID
>> 1));
2440 usValue
= eprom_read(dev
, (u16
)(EEPROM_Customer_ID
>>1)) >> 8 ;
2441 priv
->eeprom_CustomerID
= (u8
)( usValue
& 0xff);
2442 usValue
= eprom_read(dev
, (EEPROM_ICVersion_ChannelPlan
>>1));
2443 priv
->eeprom_ChannelPlan
= usValue
&0xff;
2444 IC_Version
= ((usValue
&0xff00)>>8);
2447 priv
->card_8192_version
= (VERSION_8190
)(IC_Version
);
2450 ICVer8192
= (IC_Version
&0xf); //bit0~3; 1:A cut, 2:B cut, 3:C cut...
2451 ICVer8256
= ((IC_Version
&0xf0)>>4);//bit4~6, bit7 reserved for other RF chip; 1:A cut, 2:B cut, 3:C cut...
2452 RT_TRACE(COMP_INIT
, "\nICVer8192 = 0x%x\n", ICVer8192
);
2453 RT_TRACE(COMP_INIT
, "\nICVer8256 = 0x%x\n", ICVer8256
);
2454 if(ICVer8192
== 0x2) //B-cut
2456 if(ICVer8256
== 0x5) //E-cut
2457 priv
->card_8192_version
= VERSION_8190_BE
;
2461 switch(priv
->card_8192_version
)
2463 case VERSION_8190_BD
:
2464 case VERSION_8190_BE
:
2467 priv
->card_8192_version
= VERSION_8190_BD
;
2470 RT_TRACE(COMP_INIT
, "\nIC Version = 0x%x\n", priv
->card_8192_version
);
2474 priv
->card_8192_version
= VERSION_8190_BD
;
2475 priv
->eeprom_vid
= 0;
2476 priv
->eeprom_did
= 0;
2477 priv
->eeprom_CustomerID
= 0;
2478 priv
->eeprom_ChannelPlan
= 0;
2479 RT_TRACE(COMP_INIT
, "\nIC Version = 0x%x\n", 0xff);
2482 RT_TRACE(COMP_INIT
, "EEPROM VID = 0x%4x\n", priv
->eeprom_vid
);
2483 RT_TRACE(COMP_INIT
, "EEPROM DID = 0x%4x\n", priv
->eeprom_did
);
2484 RT_TRACE(COMP_INIT
,"EEPROM Customer ID: 0x%2x\n", priv
->eeprom_CustomerID
);
2486 //2 Read Permanent MAC address
2487 if(!priv
->AutoloadFailFlag
)
2489 for(i
= 0; i
< 6; i
+= 2)
2491 usValue
= eprom_read(dev
, (u16
) ((EEPROM_NODE_ADDRESS_BYTE_0
+i
)>>1));
2492 *(u16
*)(&dev
->dev_addr
[i
]) = usValue
;
2495 // when auto load failed, the last address byte set to be a random one.
2496 // added by david woo.2007/11/7
2497 memcpy(dev
->dev_addr
, bMac_Tmp_Addr
, 6);
2500 RT_TRACE(COMP_INIT
, "Permanent Address = %pM\n", dev
->dev_addr
);
2502 //2 TX Power Check EEPROM Fail or not
2503 if(priv
->card_8192_version
> VERSION_8190_BD
) {
2504 priv
->bTXPowerDataReadFromEEPORM
= true;
2506 priv
->bTXPowerDataReadFromEEPORM
= false;
2509 // 2007/11/15 MH 8190PCI Default=2T4R, 8192PCIE default=1T2R
2510 priv
->rf_type
= RTL819X_DEFAULT_RF_TYPE
;
2512 if(priv
->card_8192_version
> VERSION_8190_BD
)
2514 // Read RF-indication and Tx Power gain index diff of legacy to HT OFDM rate.
2515 if(!priv
->AutoloadFailFlag
)
2517 tempval
= (eprom_read(dev
, (EEPROM_RFInd_PowerDiff
>>1))) & 0xff;
2518 priv
->EEPROMLegacyHTTxPowerDiff
= tempval
& 0xf; // bit[3:0]
2520 if (tempval
&0x80) //RF-indication, bit[7]
2521 priv
->rf_type
= RF_1T2R
;
2523 priv
->rf_type
= RF_2T4R
;
2527 priv
->EEPROMLegacyHTTxPowerDiff
= EEPROM_Default_LegacyHTTxPowerDiff
;
2529 RT_TRACE(COMP_INIT
, "EEPROMLegacyHTTxPowerDiff = %d\n",
2530 priv
->EEPROMLegacyHTTxPowerDiff
);
2532 // Read ThermalMeter from EEPROM
2533 if(!priv
->AutoloadFailFlag
)
2535 priv
->EEPROMThermalMeter
= (u8
)(((eprom_read(dev
, (EEPROM_ThermalMeter
>>1))) & 0xff00)>>8);
2539 priv
->EEPROMThermalMeter
= EEPROM_Default_ThermalMeter
;
2541 RT_TRACE(COMP_INIT
, "ThermalMeter = %d\n", priv
->EEPROMThermalMeter
);
2542 //vivi, for tx power track
2543 priv
->TSSI_13dBm
= priv
->EEPROMThermalMeter
*100;
2545 if(priv
->epromtype
== EPROM_93c46
)
2547 // Read antenna tx power offset of B/C/D to A and CrystalCap from EEPROM
2548 if(!priv
->AutoloadFailFlag
)
2550 usValue
= eprom_read(dev
, (EEPROM_TxPwDiff_CrystalCap
>>1));
2551 priv
->EEPROMAntPwDiff
= (usValue
&0x0fff);
2552 priv
->EEPROMCrystalCap
= (u8
)((usValue
&0xf000)>>12);
2556 priv
->EEPROMAntPwDiff
= EEPROM_Default_AntTxPowerDiff
;
2557 priv
->EEPROMCrystalCap
= EEPROM_Default_TxPwDiff_CrystalCap
;
2559 RT_TRACE(COMP_INIT
, "EEPROMAntPwDiff = %d\n", priv
->EEPROMAntPwDiff
);
2560 RT_TRACE(COMP_INIT
, "EEPROMCrystalCap = %d\n", priv
->EEPROMCrystalCap
);
2563 // Get per-channel Tx Power Level
2565 for(i
=0; i
<14; i
+=2)
2567 if(!priv
->AutoloadFailFlag
)
2569 usValue
= eprom_read(dev
, (u16
) ((EEPROM_TxPwIndex_CCK
+i
)>>1) );
2573 usValue
= EEPROM_Default_TxPower
;
2575 *((u16
*)(&priv
->EEPROMTxPowerLevelCCK
[i
])) = usValue
;
2576 RT_TRACE(COMP_INIT
,"CCK Tx Power Level, Index %d = 0x%02x\n", i
, priv
->EEPROMTxPowerLevelCCK
[i
]);
2577 RT_TRACE(COMP_INIT
, "CCK Tx Power Level, Index %d = 0x%02x\n", i
+1, priv
->EEPROMTxPowerLevelCCK
[i
+1]);
2579 for(i
=0; i
<14; i
+=2)
2581 if(!priv
->AutoloadFailFlag
)
2583 usValue
= eprom_read(dev
, (u16
) ((EEPROM_TxPwIndex_OFDM_24G
+i
)>>1) );
2587 usValue
= EEPROM_Default_TxPower
;
2589 *((u16
*)(&priv
->EEPROMTxPowerLevelOFDM24G
[i
])) = usValue
;
2590 RT_TRACE(COMP_INIT
, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i
, priv
->EEPROMTxPowerLevelOFDM24G
[i
]);
2591 RT_TRACE(COMP_INIT
, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i
+1, priv
->EEPROMTxPowerLevelOFDM24G
[i
+1]);
2594 else if(priv
->epromtype
== EPROM_93c56
)
2597 // Read CrystalCap from EEPROM
2598 if(!priv
->AutoloadFailFlag
)
2600 priv
->EEPROMAntPwDiff
= EEPROM_Default_AntTxPowerDiff
;
2601 priv
->EEPROMCrystalCap
= (u8
)(((eprom_read(dev
, (EEPROM_C56_CrystalCap
>>1))) & 0xf000)>>12);
2605 priv
->EEPROMAntPwDiff
= EEPROM_Default_AntTxPowerDiff
;
2606 priv
->EEPROMCrystalCap
= EEPROM_Default_TxPwDiff_CrystalCap
;
2608 RT_TRACE(COMP_INIT
,"EEPROMAntPwDiff = %d\n", priv
->EEPROMAntPwDiff
);
2609 RT_TRACE(COMP_INIT
, "EEPROMCrystalCap = %d\n", priv
->EEPROMCrystalCap
);
2611 // Get Tx Power Level by Channel
2612 if(!priv
->AutoloadFailFlag
)
2614 // Read Tx power of Channel 1 ~ 14 from EEPROM.
2615 for(i
= 0; i
< 12; i
+=2)
2618 offset
= EEPROM_C56_RfA_CCK_Chnl1_TxPwIndex
+ i
;
2620 offset
= EEPROM_C56_RfC_CCK_Chnl1_TxPwIndex
+ i
- 6;
2621 usValue
= eprom_read(dev
, (offset
>>1));
2622 *((u16
*)(&EepromTxPower
[i
])) = usValue
;
2625 for(i
= 0; i
< 12; i
++)
2628 priv
->EEPROMRfACCKChnl1TxPwLevel
[i
] = EepromTxPower
[i
];
2629 else if ((i
>=3 )&&(i
<= 5))
2630 priv
->EEPROMRfAOfdmChnlTxPwLevel
[i
-3] = EepromTxPower
[i
];
2631 else if ((i
>=6 )&&(i
<= 8))
2632 priv
->EEPROMRfCCCKChnl1TxPwLevel
[i
-6] = EepromTxPower
[i
];
2634 priv
->EEPROMRfCOfdmChnlTxPwLevel
[i
-9] = EepromTxPower
[i
];
2639 priv
->EEPROMRfACCKChnl1TxPwLevel
[0] = EEPROM_Default_TxPowerLevel
;
2640 priv
->EEPROMRfACCKChnl1TxPwLevel
[1] = EEPROM_Default_TxPowerLevel
;
2641 priv
->EEPROMRfACCKChnl1TxPwLevel
[2] = EEPROM_Default_TxPowerLevel
;
2643 priv
->EEPROMRfAOfdmChnlTxPwLevel
[0] = EEPROM_Default_TxPowerLevel
;
2644 priv
->EEPROMRfAOfdmChnlTxPwLevel
[1] = EEPROM_Default_TxPowerLevel
;
2645 priv
->EEPROMRfAOfdmChnlTxPwLevel
[2] = EEPROM_Default_TxPowerLevel
;
2647 priv
->EEPROMRfCCCKChnl1TxPwLevel
[0] = EEPROM_Default_TxPowerLevel
;
2648 priv
->EEPROMRfCCCKChnl1TxPwLevel
[1] = EEPROM_Default_TxPowerLevel
;
2649 priv
->EEPROMRfCCCKChnl1TxPwLevel
[2] = EEPROM_Default_TxPowerLevel
;
2651 priv
->EEPROMRfCOfdmChnlTxPwLevel
[0] = EEPROM_Default_TxPowerLevel
;
2652 priv
->EEPROMRfCOfdmChnlTxPwLevel
[1] = EEPROM_Default_TxPowerLevel
;
2653 priv
->EEPROMRfCOfdmChnlTxPwLevel
[2] = EEPROM_Default_TxPowerLevel
;
2655 RT_TRACE(COMP_INIT
, "priv->EEPROMRfACCKChnl1TxPwLevel[0] = 0x%x\n", priv
->EEPROMRfACCKChnl1TxPwLevel
[0]);
2656 RT_TRACE(COMP_INIT
, "priv->EEPROMRfACCKChnl1TxPwLevel[1] = 0x%x\n", priv
->EEPROMRfACCKChnl1TxPwLevel
[1]);
2657 RT_TRACE(COMP_INIT
, "priv->EEPROMRfACCKChnl1TxPwLevel[2] = 0x%x\n", priv
->EEPROMRfACCKChnl1TxPwLevel
[2]);
2658 RT_TRACE(COMP_INIT
, "priv->EEPROMRfAOfdmChnlTxPwLevel[0] = 0x%x\n", priv
->EEPROMRfAOfdmChnlTxPwLevel
[0]);
2659 RT_TRACE(COMP_INIT
, "priv->EEPROMRfAOfdmChnlTxPwLevel[1] = 0x%x\n", priv
->EEPROMRfAOfdmChnlTxPwLevel
[1]);
2660 RT_TRACE(COMP_INIT
, "priv->EEPROMRfAOfdmChnlTxPwLevel[2] = 0x%x\n", priv
->EEPROMRfAOfdmChnlTxPwLevel
[2]);
2661 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCCCKChnl1TxPwLevel[0] = 0x%x\n", priv
->EEPROMRfCCCKChnl1TxPwLevel
[0]);
2662 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCCCKChnl1TxPwLevel[1] = 0x%x\n", priv
->EEPROMRfCCCKChnl1TxPwLevel
[1]);
2663 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCCCKChnl1TxPwLevel[2] = 0x%x\n", priv
->EEPROMRfCCCKChnl1TxPwLevel
[2]);
2664 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCOfdmChnlTxPwLevel[0] = 0x%x\n", priv
->EEPROMRfCOfdmChnlTxPwLevel
[0]);
2665 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCOfdmChnlTxPwLevel[1] = 0x%x\n", priv
->EEPROMRfCOfdmChnlTxPwLevel
[1]);
2666 RT_TRACE(COMP_INIT
, "priv->EEPROMRfCOfdmChnlTxPwLevel[2] = 0x%x\n", priv
->EEPROMRfCOfdmChnlTxPwLevel
[2]);
2671 // Update HAL variables.
2673 if(priv
->epromtype
== EPROM_93c46
)
2677 priv
->TxPowerLevelCCK
[i
] = priv
->EEPROMTxPowerLevelCCK
[i
];
2678 priv
->TxPowerLevelOFDM24G
[i
] = priv
->EEPROMTxPowerLevelOFDM24G
[i
];
2680 priv
->LegacyHTTxPowerDiff
= priv
->EEPROMLegacyHTTxPowerDiff
;
2681 // Antenna B gain offset to antenna A, bit0~3
2682 priv
->AntennaTxPwDiff
[0] = (priv
->EEPROMAntPwDiff
& 0xf);
2683 // Antenna C gain offset to antenna A, bit4~7
2684 priv
->AntennaTxPwDiff
[1] = ((priv
->EEPROMAntPwDiff
& 0xf0)>>4);
2685 // Antenna D gain offset to antenna A, bit8~11
2686 priv
->AntennaTxPwDiff
[2] = ((priv
->EEPROMAntPwDiff
& 0xf00)>>8);
2687 // CrystalCap, bit12~15
2688 priv
->CrystalCap
= priv
->EEPROMCrystalCap
;
2689 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2690 priv
->ThermalMeter
[0] = (priv
->EEPROMThermalMeter
& 0xf);
2691 priv
->ThermalMeter
[1] = ((priv
->EEPROMThermalMeter
& 0xf0)>>4);
2693 else if(priv
->epromtype
== EPROM_93c56
)
2695 //char cck_pwr_diff_a=0, cck_pwr_diff_c=0;
2697 //cck_pwr_diff_a = pHalData->EEPROMRfACCKChnl7TxPwLevel - pHalData->EEPROMRfAOfdmChnlTxPwLevel[1];
2698 //cck_pwr_diff_c = pHalData->EEPROMRfCCCKChnl7TxPwLevel - pHalData->EEPROMRfCOfdmChnlTxPwLevel[1];
2699 for(i
=0; i
<3; i
++) // channel 1~3 use the same Tx Power Level.
2701 priv
->TxPowerLevelCCK_A
[i
] = priv
->EEPROMRfACCKChnl1TxPwLevel
[0];
2702 priv
->TxPowerLevelOFDM24G_A
[i
] = priv
->EEPROMRfAOfdmChnlTxPwLevel
[0];
2703 priv
->TxPowerLevelCCK_C
[i
] = priv
->EEPROMRfCCCKChnl1TxPwLevel
[0];
2704 priv
->TxPowerLevelOFDM24G_C
[i
] = priv
->EEPROMRfCOfdmChnlTxPwLevel
[0];
2706 for(i
=3; i
<9; i
++) // channel 4~9 use the same Tx Power Level
2708 priv
->TxPowerLevelCCK_A
[i
] = priv
->EEPROMRfACCKChnl1TxPwLevel
[1];
2709 priv
->TxPowerLevelOFDM24G_A
[i
] = priv
->EEPROMRfAOfdmChnlTxPwLevel
[1];
2710 priv
->TxPowerLevelCCK_C
[i
] = priv
->EEPROMRfCCCKChnl1TxPwLevel
[1];
2711 priv
->TxPowerLevelOFDM24G_C
[i
] = priv
->EEPROMRfCOfdmChnlTxPwLevel
[1];
2713 for(i
=9; i
<14; i
++) // channel 10~14 use the same Tx Power Level
2715 priv
->TxPowerLevelCCK_A
[i
] = priv
->EEPROMRfACCKChnl1TxPwLevel
[2];
2716 priv
->TxPowerLevelOFDM24G_A
[i
] = priv
->EEPROMRfAOfdmChnlTxPwLevel
[2];
2717 priv
->TxPowerLevelCCK_C
[i
] = priv
->EEPROMRfCCCKChnl1TxPwLevel
[2];
2718 priv
->TxPowerLevelOFDM24G_C
[i
] = priv
->EEPROMRfCOfdmChnlTxPwLevel
[2];
2721 RT_TRACE(COMP_INIT
, "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", i
, priv
->TxPowerLevelCCK_A
[i
]);
2723 RT_TRACE(COMP_INIT
,"priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", i
, priv
->TxPowerLevelOFDM24G_A
[i
]);
2725 RT_TRACE(COMP_INIT
, "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", i
, priv
->TxPowerLevelCCK_C
[i
]);
2727 RT_TRACE(COMP_INIT
, "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", i
, priv
->TxPowerLevelOFDM24G_C
[i
]);
2728 priv
->LegacyHTTxPowerDiff
= priv
->EEPROMLegacyHTTxPowerDiff
;
2729 priv
->AntennaTxPwDiff
[0] = 0;
2730 priv
->AntennaTxPwDiff
[1] = 0;
2731 priv
->AntennaTxPwDiff
[2] = 0;
2732 priv
->CrystalCap
= priv
->EEPROMCrystalCap
;
2733 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2734 priv
->ThermalMeter
[0] = (priv
->EEPROMThermalMeter
& 0xf);
2735 priv
->ThermalMeter
[1] = ((priv
->EEPROMThermalMeter
& 0xf0)>>4);
2739 if(priv
->rf_type
== RF_1T2R
)
2741 RT_TRACE(COMP_INIT
, "\n1T2R config\n");
2743 else if (priv
->rf_type
== RF_2T4R
)
2745 RT_TRACE(COMP_INIT
, "\n2T4R config\n");
2748 // 2008/01/16 MH We can only know RF type in the function. So we have to init
2749 // DIG RATR table again.
2750 init_rate_adaptive(dev
);
2752 //1 Make a copy for following variables and we can change them if we want
2754 priv
->rf_chip
= RF_8256
;
2756 if(priv
->RegChannelPlan
== 0xf)
2758 priv
->ChannelPlan
= priv
->eeprom_ChannelPlan
;
2762 priv
->ChannelPlan
= priv
->RegChannelPlan
;
2766 // Used PID and DID to Set CustomerID
2768 if( priv
->eeprom_vid
== 0x1186 && priv
->eeprom_did
== 0x3304 )
2770 priv
->CustomerID
= RT_CID_DLINK
;
2773 switch(priv
->eeprom_CustomerID
)
2775 case EEPROM_CID_DEFAULT
:
2776 priv
->CustomerID
= RT_CID_DEFAULT
;
2778 case EEPROM_CID_CAMEO
:
2779 priv
->CustomerID
= RT_CID_819x_CAMEO
;
2781 case EEPROM_CID_RUNTOP
:
2782 priv
->CustomerID
= RT_CID_819x_RUNTOP
;
2784 case EEPROM_CID_NetCore
:
2785 priv
->CustomerID
= RT_CID_819x_Netcore
;
2787 case EEPROM_CID_TOSHIBA
: // Merge by Jacken, 2008/01/31
2788 priv
->CustomerID
= RT_CID_TOSHIBA
;
2789 if(priv
->eeprom_ChannelPlan
&0x80)
2790 priv
->ChannelPlan
= priv
->eeprom_ChannelPlan
&0x7f;
2792 priv
->ChannelPlan
= 0x0;
2793 RT_TRACE(COMP_INIT
, "Toshiba ChannelPlan = 0x%x\n",
2796 case EEPROM_CID_Nettronix
:
2797 priv
->ScanDelay
= 100; //cosa add for scan
2798 priv
->CustomerID
= RT_CID_Nettronix
;
2800 case EEPROM_CID_Pronet
:
2801 priv
->CustomerID
= RT_CID_PRONET
;
2803 case EEPROM_CID_DLINK
:
2804 priv
->CustomerID
= RT_CID_DLINK
;
2807 case EEPROM_CID_WHQL
:
2808 //Adapter->bInHctTest = TRUE;//do not supported
2810 //priv->bSupportTurboMode = FALSE;
2811 //priv->bAutoTurboBy8186 = FALSE;
2813 //pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
2814 //pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
2815 //pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
2819 // value from RegCustomerID
2823 //Avoid the channel plan array overflow, by Bruce, 2007-08-27.
2824 if(priv
->ChannelPlan
> CHANNEL_PLAN_LEN
- 1)
2825 priv
->ChannelPlan
= 0; //FCC
2827 switch(priv
->CustomerID
)
2829 case RT_CID_DEFAULT
:
2831 priv
->LedStrategy
= HW_LED
;
2834 priv
->LedStrategy
= SW_LED_MODE1
;
2839 case RT_CID_819x_CAMEO
:
2840 priv
->LedStrategy
= SW_LED_MODE2
;
2843 case RT_CID_819x_RUNTOP
:
2844 priv
->LedStrategy
= SW_LED_MODE3
;
2847 case RT_CID_819x_Netcore
:
2848 priv
->LedStrategy
= SW_LED_MODE4
;
2851 case RT_CID_Nettronix
:
2852 priv
->LedStrategy
= SW_LED_MODE5
;
2856 priv
->LedStrategy
= SW_LED_MODE6
;
2859 case RT_CID_TOSHIBA
: //Modify by Jacken 2008/01/31
2865 priv
->LedStrategy
= HW_LED
;
2868 priv
->LedStrategy
= SW_LED_MODE1
;
2875 if( priv
->eeprom_vid
== 0x1186 && priv
->eeprom_did
== 0x3304)
2876 priv
->ieee80211
->bSupportRemoteWakeUp
= true;
2878 priv
->ieee80211
->bSupportRemoteWakeUp
= false;
2881 RT_TRACE(COMP_INIT
, "RegChannelPlan(%d)\n", priv
->RegChannelPlan
);
2882 RT_TRACE(COMP_INIT
, "ChannelPlan = %d \n", priv
->ChannelPlan
);
2883 RT_TRACE(COMP_INIT
, "LedStrategy = %d \n", priv
->LedStrategy
);
2884 RT_TRACE(COMP_TRACE
, "<==== ReadAdapterInfo\n");
2890 static short rtl8192_get_channel_map(struct net_device
* dev
)
2892 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2893 #ifdef ENABLE_DOT11D
2894 if(priv
->ChannelPlan
> COUNTRY_CODE_GLOBAL_DOMAIN
){
2895 printk("rtl8180_init:Error channel plan! Set to default.\n");
2896 priv
->ChannelPlan
= 0;
2898 RT_TRACE(COMP_INIT
, "Channel plan is %d\n",priv
->ChannelPlan
);
2900 rtl819x_set_channel_map(priv
->ChannelPlan
, priv
);
2903 //Set Default Channel Plan
2905 DMESG("No channels, aborting");
2909 priv
->ChannelPlan
= 0;//hikaru
2910 // set channels 1..14 allowed in given locale
2911 for (i
=1; i
<=14; i
++) {
2912 (priv
->ieee80211
->channel_map
)[i
] = (u8
)(ch
& 0x01);
2919 static short rtl8192_init(struct net_device
*dev
)
2921 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2922 memset(&(priv
->stats
),0,sizeof(struct Stats
));
2923 rtl8192_init_priv_variable(dev
);
2924 rtl8192_init_priv_lock(priv
);
2925 rtl8192_init_priv_task(dev
);
2926 rtl8192_get_eeprom_size(dev
);
2927 rtl8192_read_eeprom_info(dev
);
2928 rtl8192_get_channel_map(dev
);
2930 init_timer(&priv
->watch_dog_timer
);
2931 priv
->watch_dog_timer
.data
= (unsigned long)dev
;
2932 priv
->watch_dog_timer
.function
= watch_dog_timer_callback
;
2933 #if defined(IRQF_SHARED)
2934 if(request_irq(dev
->irq
, (void*)rtl8192_interrupt
, IRQF_SHARED
, dev
->name
, dev
)){
2936 if(request_irq(dev
->irq
, (void *)rtl8192_interrupt
, SA_SHIRQ
, dev
->name
, dev
)){
2938 printk("Error allocating IRQ %d",dev
->irq
);
2942 printk("IRQ %d",dev
->irq
);
2944 if(rtl8192_pci_initdescring(dev
)!=0){
2945 printk("Endopoints initialization failed");
2949 //rtl8192_rx_enable(dev);
2950 //rtl8192_adapter_start(dev);
2955 * Actually only set RRSR, RATR and BW_OPMODE registers
2956 * not to do all the hw config as its name says
2957 * This part need to modified according to the rate set we filtered
2959 static void rtl8192_hwconfig(struct net_device
* dev
)
2961 u32 regRATR
= 0, regRRSR
= 0;
2962 u8 regBwOpMode
= 0, regTmp
= 0;
2963 struct r8192_priv
*priv
= ieee80211_priv(dev
);
2965 // Set RRSR, RATR, and BW_OPMODE registers
2967 switch(priv
->ieee80211
->mode
)
2969 case WIRELESS_MODE_B
:
2970 regBwOpMode
= BW_OPMODE_20MHZ
;
2971 regRATR
= RATE_ALL_CCK
;
2972 regRRSR
= RATE_ALL_CCK
;
2974 case WIRELESS_MODE_A
:
2975 regBwOpMode
= BW_OPMODE_5G
|BW_OPMODE_20MHZ
;
2976 regRATR
= RATE_ALL_OFDM_AG
;
2977 regRRSR
= RATE_ALL_OFDM_AG
;
2979 case WIRELESS_MODE_G
:
2980 regBwOpMode
= BW_OPMODE_20MHZ
;
2981 regRATR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
2982 regRRSR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
2984 case WIRELESS_MODE_AUTO
:
2985 case WIRELESS_MODE_N_24G
:
2986 // It support CCK rate by default.
2987 // CCK rate will be filtered out only when associated AP does not support it.
2988 regBwOpMode
= BW_OPMODE_20MHZ
;
2989 regRATR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
| RATE_ALL_OFDM_1SS
| RATE_ALL_OFDM_2SS
;
2990 regRRSR
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
2992 case WIRELESS_MODE_N_5G
:
2993 regBwOpMode
= BW_OPMODE_5G
;
2994 regRATR
= RATE_ALL_OFDM_AG
| RATE_ALL_OFDM_1SS
| RATE_ALL_OFDM_2SS
;
2995 regRRSR
= RATE_ALL_OFDM_AG
;
2999 write_nic_byte(dev
, BW_OPMODE
, regBwOpMode
);
3002 ratr_value
= regRATR
;
3003 if (priv
->rf_type
== RF_1T2R
)
3005 ratr_value
&= ~(RATE_ALL_OFDM_2SS
);
3007 write_nic_dword(dev
, RATR0
, ratr_value
);
3008 write_nic_byte(dev
, UFWP
, 1);
3010 regTmp
= read_nic_byte(dev
, 0x313);
3011 regRRSR
= ((regTmp
) << 24) | (regRRSR
& 0x00ffffff);
3012 write_nic_dword(dev
, RRSR
, regRRSR
);
3015 // Set Retry Limit here
3017 write_nic_word(dev
, RETRY_LIMIT
,
3018 priv
->ShortRetryLimit
<< RETRY_LIMIT_SHORT_SHIFT
|
3019 priv
->LongRetryLimit
<< RETRY_LIMIT_LONG_SHIFT
);
3020 // Set Contention Window here
3024 // Set Tx Antenna including Feedback control
3026 // Set Auto Rate fallback control
3032 static RT_STATUS
rtl8192_adapter_start(struct net_device
*dev
)
3034 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3035 // struct ieee80211_device *ieee = priv->ieee80211;
3037 RT_STATUS rtStatus
= RT_STATUS_SUCCESS
;
3041 u8 ICVersion
,SwitchingRegulatorOutput
;
3043 bool bfirmwareok
= true;
3047 u32 tmpRegA
, tmpRegC
, TempCCk
;
3050 RT_TRACE(COMP_INIT
, "====>%s()\n", __FUNCTION__
);
3051 priv
->being_init_adapter
= true;
3052 rtl8192_pci_resetdescring(dev
);
3053 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
3054 priv
->Rf_Mode
= RF_OP_By_SW_3wire
;
3057 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3059 write_nic_byte(dev
, ANAPAR
, 0x37);
3060 // Accordign to designer's explain, LBUS active will never > 10ms. We delay 10ms
3061 // Joseph increae the time to prevent firmware download fail
3065 //PlatformSleepUs(10000);
3066 // For any kind of InitializeAdapter process, we shall use system now!!
3067 priv
->pFirmware
->firmware_status
= FW_STATUS_0_INIT
;
3069 // Set to eRfoff in order not to count receive count.
3070 if(priv
->RegRfOff
== TRUE
)
3071 priv
->ieee80211
->eRFPowerState
= eRfOff
;
3074 //3 //Config CPUReset Register
3076 //3 Firmware Reset Or Not
3077 ulRegRead
= read_nic_dword(dev
, CPU_GEN
);
3078 if(priv
->pFirmware
->firmware_status
== FW_STATUS_0_INIT
)
3079 { //called from MPInitialized. do nothing
3080 ulRegRead
|= CPU_GEN_SYSTEM_RESET
;
3081 }else if(priv
->pFirmware
->firmware_status
== FW_STATUS_5_READY
)
3082 ulRegRead
|= CPU_GEN_FIRMWARE_RESET
; // Called from MPReset
3084 RT_TRACE(COMP_ERR
, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__
, priv
->pFirmware
->firmware_status
);
3087 //2008.06.03, for WOL 90 hw bug
3088 ulRegRead
&= (~(CPU_GEN_GPIO_UART
));
3091 write_nic_dword(dev
, CPU_GEN
, ulRegRead
);
3097 //3 //Fix the issue of E-cut high temperature issue
3100 ICVersion
= read_nic_byte(dev
, IC_VERRSION
);
3101 if(ICVersion
>= 0x4) //E-cut only
3103 // HW SD suggest that we should not wirte this register too often, so driver
3104 // should readback this register. This register will be modified only when
3106 SwitchingRegulatorOutput
= read_nic_byte(dev
, SWREGULATOR
);
3107 if(SwitchingRegulatorOutput
!= 0xb8)
3109 write_nic_byte(dev
, SWREGULATOR
, 0xa8);
3111 write_nic_byte(dev
, SWREGULATOR
, 0xb8);
3118 //3// Initialize BB before MAC
3120 RT_TRACE(COMP_INIT
, "BB Config Start!\n");
3121 rtStatus
= rtl8192_BBConfig(dev
);
3122 if(rtStatus
!= RT_STATUS_SUCCESS
)
3124 RT_TRACE(COMP_ERR
, "BB Config failed\n");
3127 RT_TRACE(COMP_INIT
,"BB Config Finished!\n");
3129 //3//Set Loopback mode or Normal mode
3131 //2006.12.13 by emily. Note!We should not merge these two CPU_GEN register writings
3132 // because setting of System_Reset bit reset MAC to default transmission mode.
3133 //Loopback mode or not
3134 priv
->LoopbackMode
= RTL819X_NO_LOOPBACK
;
3135 //priv->LoopbackMode = RTL819X_MAC_LOOPBACK;
3136 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3138 ulRegRead
= read_nic_dword(dev
, CPU_GEN
);
3139 if(priv
->LoopbackMode
== RTL819X_NO_LOOPBACK
)
3141 ulRegRead
= ((ulRegRead
& CPU_GEN_NO_LOOPBACK_MSK
) | CPU_GEN_NO_LOOPBACK_SET
);
3143 else if (priv
->LoopbackMode
== RTL819X_MAC_LOOPBACK
)
3145 ulRegRead
|= CPU_CCK_LOOPBACK
;
3149 RT_TRACE(COMP_ERR
,"Serious error: wrong loopback mode setting\n");
3152 //2008.06.03, for WOL
3153 //ulRegRead &= (~(CPU_GEN_GPIO_UART));
3154 write_nic_dword(dev
, CPU_GEN
, ulRegRead
);
3156 // 2006.11.29. After reset cpu, we sholud wait for a second, otherwise, it may fail to write registers. Emily
3159 //3Set Hardware(Do nothing now)
3160 rtl8192_hwconfig(dev
);
3161 //2=======================================================
3162 // Common Setting for all of the FPGA platform. (part 1)
3163 //2=======================================================
3164 // If there is changes, please make sure it applies to all of the FPGA version
3166 write_nic_byte(dev
, CMDR
, CR_RE
|CR_TE
);
3170 write_nic_byte(dev
, PCIF
, ((MXDMA2_NoLimit
<<MXDMA2_RX_SHIFT
) |
3171 (MXDMA2_NoLimit
<<MXDMA2_TX_SHIFT
) |
3175 write_nic_byte(dev
, PCIF
, ((MXDMA2_NoLimit
<<MXDMA2_RX_SHIFT
) |
3176 (MXDMA2_NoLimit
<<MXDMA2_TX_SHIFT
) ));
3180 write_nic_dword(dev
, MAC0
, ((u32
*)dev
->dev_addr
)[0]);
3181 write_nic_word(dev
, MAC4
, ((u16
*)(dev
->dev_addr
+ 4))[0]);
3183 write_nic_dword(dev
, RCR
, priv
->ReceiveConfig
);
3185 //3 Initialize Number of Reserved Pages in Firmware Queue
3187 if(priv
->bInHctTest
)
3189 PlatformEFIOWrite4Byte(Adapter
, RQPN1
, NUM_OF_PAGE_IN_FW_QUEUE_BK_DTM
<< RSVD_FW_QUEUE_PAGE_BK_SHIFT
|
3190 NUM_OF_PAGE_IN_FW_QUEUE_BE_DTM
<< RSVD_FW_QUEUE_PAGE_BE_SHIFT
|
3191 NUM_OF_PAGE_IN_FW_QUEUE_VI_DTM
<< RSVD_FW_QUEUE_PAGE_VI_SHIFT
|
3192 NUM_OF_PAGE_IN_FW_QUEUE_VO_DTM
<<RSVD_FW_QUEUE_PAGE_VO_SHIFT
);
3193 PlatformEFIOWrite4Byte(Adapter
, RQPN2
, NUM_OF_PAGE_IN_FW_QUEUE_MGNT
<< RSVD_FW_QUEUE_PAGE_MGNT_SHIFT
);
3194 PlatformEFIOWrite4Byte(Adapter
, RQPN3
, APPLIED_RESERVED_QUEUE_IN_FW
|
3195 NUM_OF_PAGE_IN_FW_QUEUE_BCN
<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
|
3196 NUM_OF_PAGE_IN_FW_QUEUE_PUB_DTM
<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
);
3201 write_nic_dword(dev
, RQPN1
, NUM_OF_PAGE_IN_FW_QUEUE_BK
<< RSVD_FW_QUEUE_PAGE_BK_SHIFT
|
3202 NUM_OF_PAGE_IN_FW_QUEUE_BE
<< RSVD_FW_QUEUE_PAGE_BE_SHIFT
|
3203 NUM_OF_PAGE_IN_FW_QUEUE_VI
<< RSVD_FW_QUEUE_PAGE_VI_SHIFT
|
3204 NUM_OF_PAGE_IN_FW_QUEUE_VO
<<RSVD_FW_QUEUE_PAGE_VO_SHIFT
);
3205 write_nic_dword(dev
, RQPN2
, NUM_OF_PAGE_IN_FW_QUEUE_MGNT
<< RSVD_FW_QUEUE_PAGE_MGNT_SHIFT
);
3206 write_nic_dword(dev
, RQPN3
, APPLIED_RESERVED_QUEUE_IN_FW
|
3207 NUM_OF_PAGE_IN_FW_QUEUE_BCN
<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
|
3208 NUM_OF_PAGE_IN_FW_QUEUE_PUB
<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
);
3211 rtl8192_tx_enable(dev
);
3212 rtl8192_rx_enable(dev
);
3213 //3Set Response Rate Setting Register
3214 // CCK rate is supported by default.
3215 // CCK rate will be filtered out only when associated AP does not support it.
3216 ulRegRead
= (0xFFF00000 & read_nic_dword(dev
, RRSR
)) | RATE_ALL_OFDM_AG
| RATE_ALL_CCK
;
3217 write_nic_dword(dev
, RRSR
, ulRegRead
);
3218 write_nic_dword(dev
, RATR0
+4*7, (RATE_ALL_OFDM_AG
| RATE_ALL_CCK
));
3221 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3222 write_nic_byte(dev
, ACK_TIMEOUT
, 0x30);
3224 //rtl8192_actset_wirelessmode(dev,priv->RegWirelessMode);
3225 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3226 rtl8192_SetWirelessMode(dev
, priv
->ieee80211
->mode
);
3227 //-----------------------------------------------------------------------------
3228 // Set up security related. 070106, by rcnjko:
3229 // 1. Clear all H/W keys.
3230 // 2. Enable H/W encryption/decryption.
3231 //-----------------------------------------------------------------------------
3232 CamResetAllEntry(dev
);
3234 u8 SECR_value
= 0x0;
3235 SECR_value
|= SCR_TxEncEnable
;
3236 SECR_value
|= SCR_RxDecEnable
;
3237 SECR_value
|= SCR_NoSKMC
;
3238 write_nic_byte(dev
, SECR
, SECR_value
);
3241 write_nic_word(dev
, ATIMWND
, 2);
3242 write_nic_word(dev
, BCN_INTERVAL
, 100);
3243 for (i
=0; i
<QOS_QUEUE_NUM
; i
++)
3244 write_nic_dword(dev
, WDCAPARA_ADD
[i
], 0x005e4332);
3246 // Switching regulator controller: This is set temporarily.
3247 // It's not sure if this can be removed in the future.
3248 // PJ advised to leave it by default.
3250 write_nic_byte(dev
, 0xbe, 0xc0);
3252 //2=======================================================
3253 // Set PHY related configuration defined in MAC register bank
3254 //2=======================================================
3255 rtl8192_phy_configmac(dev
);
3257 if (priv
->card_8192_version
> (u8
) VERSION_8190_BD
) {
3258 rtl8192_phy_getTxPower(dev
);
3259 rtl8192_phy_setTxPower(dev
, priv
->chan
);
3263 tmpvalue
= read_nic_byte(dev
, IC_VERRSION
);
3264 priv
->IC_Cut
= tmpvalue
;
3265 RT_TRACE(COMP_INIT
, "priv->IC_Cut = 0x%x\n", priv
->IC_Cut
);
3266 if(priv
->IC_Cut
>= IC_VersionCut_D
)
3268 //pHalData->bDcut = TRUE;
3269 if(priv
->IC_Cut
== IC_VersionCut_D
)
3270 RT_TRACE(COMP_INIT
, "D-cut\n");
3271 if(priv
->IC_Cut
== IC_VersionCut_E
)
3273 RT_TRACE(COMP_INIT
, "E-cut\n");
3274 // HW SD suggest that we should not wirte this register too often, so driver
3275 // should readback this register. This register will be modified only when
3281 //pHalData->bDcut = FALSE;
3282 RT_TRACE(COMP_INIT
, "Before C-cut\n");
3287 RT_TRACE(COMP_INIT
, "Load Firmware!\n");
3288 bfirmwareok
= init_firmware(dev
);
3289 if(bfirmwareok
!= true) {
3290 rtStatus
= RT_STATUS_FAILURE
;
3293 RT_TRACE(COMP_INIT
, "Load Firmware finished!\n");
3296 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3298 RT_TRACE(COMP_INIT
, "RF Config Started!\n");
3299 rtStatus
= rtl8192_phy_RFConfig(dev
);
3300 if(rtStatus
!= RT_STATUS_SUCCESS
)
3302 RT_TRACE(COMP_ERR
, "RF Config failed\n");
3305 RT_TRACE(COMP_INIT
, "RF Config Finished!\n");
3307 rtl8192_phy_updateInitGain(dev
);
3309 /*---- Set CCK and OFDM Block "ON"----*/
3310 rtl8192_setBBreg(dev
, rFPGA0_RFMOD
, bCCKEn
, 0x1);
3311 rtl8192_setBBreg(dev
, rFPGA0_RFMOD
, bOFDMEn
, 0x1);
3315 write_nic_byte(dev
, 0x87, 0x0);
3318 //2008.06.03, for WOL
3319 ucRegRead
= read_nic_byte(dev
, GPE
);
3321 write_nic_byte(dev
, GPE
, ucRegRead
);
3323 ucRegRead
= read_nic_byte(dev
, GPO
);
3325 write_nic_byte(dev
, GPO
, ucRegRead
);
3328 //2=======================================================
3330 //2=======================================================
3334 if(priv
->RegRfOff
== TRUE
)
3335 { // User disable RF via registry.
3336 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): Turn off RF for RegRfOff ----------\n",__FUNCTION__
);
3337 MgntActSet_RF_State(dev
, eRfOff
, RF_CHANGE_BY_SW
);
3338 #if 0//cosa, ask SD3 willis and he doesn't know what is this for
3339 // Those action will be discard in MgntActSet_RF_State because off the same state
3340 for(eRFPath
= 0; eRFPath
<pHalData
->NumTotalRFPath
; eRFPath
++)
3341 PHY_SetRFReg(Adapter
, (RF90_RADIO_PATH_E
)eRFPath
, 0x4, 0xC00, 0x0);
3344 else if(priv
->ieee80211
->RfOffReason
> RF_CHANGE_BY_PS
)
3345 { // H/W or S/W RF OFF before sleep.
3346 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__
,priv
->ieee80211
->RfOffReason
);
3347 MgntActSet_RF_State(dev
, eRfOff
, priv
->ieee80211
->RfOffReason
);
3349 else if(priv
->ieee80211
->RfOffReason
>= RF_CHANGE_BY_IPS
)
3350 { // H/W or S/W RF OFF before sleep.
3351 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__
,priv
->ieee80211
->RfOffReason
);
3352 MgntActSet_RF_State(dev
, eRfOff
, priv
->ieee80211
->RfOffReason
);
3356 RT_TRACE((COMP_INIT
|COMP_RF
|COMP_POWER
), "%s(): RF-ON \n",__FUNCTION__
);
3357 priv
->ieee80211
->eRFPowerState
= eRfOn
;
3358 priv
->ieee80211
->RfOffReason
= 0;
3359 //DrvIFIndicateCurrentPhyStatus(Adapter);
3361 //Adapter->HalFunc.LedControlHandler(Adapter, LED_CTL_POWER_ON);
3364 // If inactive power mode is enabled, disable rf while in disconnected state.
3365 // But we should still tell upper layer we are in rf on state.
3366 // 2007.07.16, by shien chang.
3368 //if(!Adapter->bInHctTest)
3369 //IPSEnter(Adapter);
3376 // We can force firmware to do RF-R/W
3377 if(priv
->ieee80211
->FwRWRF
)
3378 priv
->Rf_Mode
= RF_OP_By_FW
;
3380 priv
->Rf_Mode
= RF_OP_By_SW_3wire
;
3382 priv
->Rf_Mode
= RF_OP_By_SW_3wire
;
3386 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3388 dm_initialize_txpower_tracking(dev
);
3390 tmpRegA
= rtl8192_QueryBBReg(dev
,rOFDM0_XATxIQImbalance
,bMaskDWord
);
3391 tmpRegC
= rtl8192_QueryBBReg(dev
,rOFDM0_XCTxIQImbalance
,bMaskDWord
);
3393 if(priv
->rf_type
== RF_2T4R
){
3394 for(i
= 0; i
<TxBBGainTableLength
; i
++)
3396 if(tmpRegA
== priv
->txbbgain_table
[i
].txbbgain_value
)
3398 priv
->rfa_txpowertrackingindex
= (u8
)i
;
3399 priv
->rfa_txpowertrackingindex_real
= (u8
)i
;
3400 priv
->rfa_txpowertracking_default
= priv
->rfa_txpowertrackingindex
;
3405 for(i
= 0; i
<TxBBGainTableLength
; i
++)
3407 if(tmpRegC
== priv
->txbbgain_table
[i
].txbbgain_value
)
3409 priv
->rfc_txpowertrackingindex
= (u8
)i
;
3410 priv
->rfc_txpowertrackingindex_real
= (u8
)i
;
3411 priv
->rfc_txpowertracking_default
= priv
->rfc_txpowertrackingindex
;
3415 TempCCk
= rtl8192_QueryBBReg(dev
, rCCK0_TxFilter1
, bMaskByte2
);
3417 for(i
=0 ; i
<CCKTxBBGainTableLength
; i
++)
3419 if(TempCCk
== priv
->cck_txbbgain_table
[i
].ccktxbb_valuearray
[0])
3421 priv
->CCKPresentAttentuation_20Mdefault
=(u8
) i
;
3425 priv
->CCKPresentAttentuation_40Mdefault
= 0;
3426 priv
->CCKPresentAttentuation_difference
= 0;
3427 priv
->CCKPresentAttentuation
= priv
->CCKPresentAttentuation_20Mdefault
;
3428 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_initial = %d\n", priv
->rfa_txpowertrackingindex
);
3429 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv
->rfa_txpowertrackingindex_real
);
3430 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfc_txpowertrackingindex_initial = %d\n", priv
->rfc_txpowertrackingindex
);
3431 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfc_txpowertrackingindex_real_initial = %d\n", priv
->rfc_txpowertrackingindex_real
);
3432 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv
->CCKPresentAttentuation_difference
);
3433 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_initial = %d\n", priv
->CCKPresentAttentuation
);
3437 if(priv
->ResetProgress
== RESET_TYPE_NORESET
)
3439 dm_initialize_txpower_tracking(dev
);
3441 if(priv
->IC_Cut
>= IC_VersionCut_D
)
3443 tmpRegA
= rtl8192_QueryBBReg(dev
,rOFDM0_XATxIQImbalance
,bMaskDWord
);
3444 tmpRegC
= rtl8192_QueryBBReg(dev
,rOFDM0_XCTxIQImbalance
,bMaskDWord
);
3445 for(i
= 0; i
<TxBBGainTableLength
; i
++)
3447 if(tmpRegA
== priv
->txbbgain_table
[i
].txbbgain_value
)
3449 priv
->rfa_txpowertrackingindex
= (u8
)i
;
3450 priv
->rfa_txpowertrackingindex_real
= (u8
)i
;
3451 priv
->rfa_txpowertracking_default
= priv
->rfa_txpowertrackingindex
;
3456 TempCCk
= rtl8192_QueryBBReg(dev
, rCCK0_TxFilter1
, bMaskByte2
);
3458 for(i
=0 ; i
<CCKTxBBGainTableLength
; i
++)
3460 if(TempCCk
== priv
->cck_txbbgain_table
[i
].ccktxbb_valuearray
[0])
3462 priv
->CCKPresentAttentuation_20Mdefault
=(u8
) i
;
3466 priv
->CCKPresentAttentuation_40Mdefault
= 0;
3467 priv
->CCKPresentAttentuation_difference
= 0;
3468 priv
->CCKPresentAttentuation
= priv
->CCKPresentAttentuation_20Mdefault
;
3469 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_initial = %d\n", priv
->rfa_txpowertrackingindex
);
3470 RT_TRACE(COMP_POWER_TRACKING
, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv
->rfa_txpowertrackingindex_real
);
3471 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv
->CCKPresentAttentuation_difference
);
3472 RT_TRACE(COMP_POWER_TRACKING
, "priv->CCKPresentAttentuation_initial = %d\n", priv
->CCKPresentAttentuation
);
3473 priv
->btxpower_tracking
= FALSE
;//TEMPLY DISABLE
3478 rtl8192_irq_enable(dev
);
3479 priv
->being_init_adapter
= false;
3484 static void rtl8192_prepare_beacon(struct r8192_priv
*priv
)
3486 struct sk_buff
*skb
;
3487 //unsigned long flags;
3490 skb
= ieee80211_get_beacon(priv
->ieee80211
);
3491 tcb_desc
= (cb_desc
*)(skb
->cb
+ 8);
3492 //spin_lock_irqsave(&priv->tx_lock,flags);
3493 /* prepare misc info for the beacon xmit */
3494 tcb_desc
->queue_index
= BEACON_QUEUE
;
3495 /* IBSS does not support HT yet, use 1M defaultly */
3496 tcb_desc
->data_rate
= 2;
3497 tcb_desc
->RATRIndex
= 7;
3498 tcb_desc
->bTxDisableRateFallBack
= 1;
3499 tcb_desc
->bTxUseDriverAssingedRate
= 1;
3501 skb_push(skb
, priv
->ieee80211
->tx_headroom
);
3503 rtl8192_tx(priv
->ieee80211
->dev
,skb
);
3505 //spin_unlock_irqrestore (&priv->tx_lock, flags);
3510 * configure registers for beacon tx and enables it via
3511 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3512 * be used to stop beacon transmission
3514 static void rtl8192_start_beacon(struct net_device
*dev
)
3516 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
3517 struct ieee80211_network
*net
= &priv
->ieee80211
->current_network
;
3522 DMESG("Enabling beacon TX");
3523 //rtl8192_prepare_beacon(dev);
3524 rtl8192_irq_disable(dev
);
3525 //rtl8192_beacon_tx_enable(dev);
3528 write_nic_word(dev
, ATIMWND
, 2);
3530 /* Beacon interval (in unit of TU) */
3531 write_nic_word(dev
, BCN_INTERVAL
, net
->beacon_interval
);
3534 * DrvErlyInt (in unit of TU).
3535 * (Time to send interrupt to notify driver to c
3536 * hange beacon content)
3538 write_nic_word(dev
, BCN_DRV_EARLY_INT
, 10);
3541 * BcnDMATIM(in unit of us).
3542 * Indicates the time before TBTT to perform beacon queue DMA
3544 write_nic_word(dev
, BCN_DMATIME
, 256);
3547 * Force beacon frame transmission even after receiving
3548 * beacon frame from other ad hoc STA
3550 write_nic_byte(dev
, BCN_ERR_THRESH
, 100);
3552 /* Set CW and IFS */
3553 BcnTimeCfg
|= BcnCW
<<BCN_TCFG_CW_SHIFT
;
3554 BcnTimeCfg
|= BcnIFS
<<BCN_TCFG_IFS
;
3555 write_nic_word(dev
, BCN_TCFG
, BcnTimeCfg
);
3558 /* enable the interrupt for ad-hoc process */
3559 rtl8192_irq_enable(dev
);
3562 static bool HalTxCheckStuck8190Pci(struct net_device
*dev
)
3564 u16 RegTxCounter
= read_nic_word(dev
, 0x128);
3565 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3566 bool bStuck
= FALSE
;
3567 RT_TRACE(COMP_RESET
,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__
,RegTxCounter
,priv
->TxCounter
);
3568 if(priv
->TxCounter
==RegTxCounter
)
3571 priv
->TxCounter
= RegTxCounter
;
3577 * Assumption: RT_TX_SPINLOCK is acquired.
3580 TxCheckStuck(struct net_device
*dev
)
3582 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3584 ptx_ring head
=NULL
,tail
=NULL
,txring
= NULL
;
3585 u8 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
3586 bool bCheckFwTxCnt
= false;
3589 // Decide Stuch threshold according to current power save mode
3591 switch (priv
->ieee80211
->dot11PowerSaveMode
)
3593 // The threshold value may required to be adjusted .
3594 case eActive
: // Active/Continuous access.
3595 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_NORMAL
;
3597 case eMaxPs
: // Max power save mode.
3598 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
3600 case eFastPs
: // Fast power save mode.
3601 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
3606 // Check whether specific tcb has been queued for a specific time
3608 for(QueueID
= 0; QueueID
< MAX_TX_QUEUE
; QueueID
++)
3612 if(QueueID
== TXCMD_QUEUE
)
3617 tail
=priv
->txmapringtail
;
3618 head
=priv
->txmapringhead
;
3622 tail
=priv
->txbkpringtail
;
3623 head
=priv
->txbkpringhead
;
3627 tail
=priv
->txbepringtail
;
3628 head
=priv
->txbepringhead
;
3632 tail
=priv
->txvipringtail
;
3633 head
=priv
->txvipringhead
;
3637 tail
=priv
->txvopringtail
;
3638 head
=priv
->txvopringhead
;
3653 RT_TRACE(COMP_ERR
,"%s():txring is NULL , BUG!\n",__FUNCTION__
);
3656 txring
->nStuckCount
++;
3657 bCheckFwTxCnt
= TRUE
;
3663 if(HalTxCheckStuck8190Pci(dev
))
3665 RT_TRACE(COMP_RESET
, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3666 return RESET_TYPE_SILENT
;
3670 return RESET_TYPE_NORESET
;
3674 static bool HalRxCheckStuck8190Pci(struct net_device
*dev
)
3676 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3677 u16 RegRxCounter
= read_nic_word(dev
, 0x130);
3678 bool bStuck
= FALSE
;
3679 static u8 rx_chk_cnt
= 0;
3680 RT_TRACE(COMP_RESET
,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__
,RegRxCounter
,priv
->RxCounter
);
3681 // If rssi is small, we should check rx for long time because of bad rx.
3682 // or maybe it will continuous silent reset every 2 seconds.
3684 if(priv
->undecorated_smoothed_pwdb
>= (RateAdaptiveTH_High
+5))
3686 rx_chk_cnt
= 0; //high rssi, check rx stuck right now.
3688 else if(priv
->undecorated_smoothed_pwdb
< (RateAdaptiveTH_High
+5) &&
3689 ((priv
->CurrentChannelBW
!=HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
>=RateAdaptiveTH_Low_40M
) ||
3690 (priv
->CurrentChannelBW
==HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
>=RateAdaptiveTH_Low_20M
)) )
3702 else if(((priv
->CurrentChannelBW
!=HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
<RateAdaptiveTH_Low_40M
) ||
3703 (priv
->CurrentChannelBW
==HT_CHANNEL_WIDTH_20
&&priv
->undecorated_smoothed_pwdb
<RateAdaptiveTH_Low_20M
)) &&
3704 priv
->undecorated_smoothed_pwdb
>= VeryLowRSSI
)
3708 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3714 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3721 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
3727 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
3730 if(priv
->RxCounter
==RegRxCounter
)
3733 priv
->RxCounter
= RegRxCounter
;
3738 static RESET_TYPE
RxCheckStuck(struct net_device
*dev
)
3741 if(HalRxCheckStuck8190Pci(dev
))
3743 RT_TRACE(COMP_RESET
, "RxStuck Condition\n");
3744 return RESET_TYPE_SILENT
;
3747 return RESET_TYPE_NORESET
;
3751 rtl819x_ifcheck_resetornot(struct net_device
*dev
)
3753 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3754 RESET_TYPE TxResetType
= RESET_TYPE_NORESET
;
3755 RESET_TYPE RxResetType
= RESET_TYPE_NORESET
;
3756 RT_RF_POWER_STATE rfState
;
3758 rfState
= priv
->ieee80211
->eRFPowerState
;
3760 TxResetType
= TxCheckStuck(dev
);
3762 if( rfState
!= eRfOff
&&
3763 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3764 (priv
->ieee80211
->iw_mode
!= IW_MODE_ADHOC
))
3766 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3767 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3768 // if driver is in firmware download failure status, driver should initialize RF in the following
3769 // silent reset procedure Emily, 2008.01.21
3771 // Driver should not check RX stuck in IBSS mode because it is required to
3772 // set Check BSSID in order to send beacon, however, if check BSSID is
3773 // set, STA cannot hear any packet a all. Emily, 2008.04.12
3774 RxResetType
= RxCheckStuck(dev
);
3778 RT_TRACE(COMP_RESET
,"%s(): TxResetType is %d, RxResetType is %d\n",__FUNCTION__
,TxResetType
,RxResetType
);
3779 if(TxResetType
==RESET_TYPE_NORMAL
|| RxResetType
==RESET_TYPE_NORMAL
)
3780 return RESET_TYPE_NORMAL
;
3781 else if(TxResetType
==RESET_TYPE_SILENT
|| RxResetType
==RESET_TYPE_SILENT
)
3782 return RESET_TYPE_SILENT
;
3784 return RESET_TYPE_NORESET
;
3789 static void CamRestoreAllEntry(struct net_device
*dev
)
3792 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3793 const u8
* MacAddr
= priv
->ieee80211
->current_network
.bssid
;
3795 static const u8 CAM_CONST_ADDR
[4][6] = {
3796 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3797 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3798 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3799 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3800 static const u8 CAM_CONST_BROAD
[] =
3801 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3803 RT_TRACE(COMP_SEC
, "CamRestoreAllEntry: \n");
3806 if ((priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_WEP40
)||
3807 (priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_WEP104
))
3810 for(EntryId
=0; EntryId
<4; EntryId
++)
3813 MacAddr
= CAM_CONST_ADDR
[EntryId
];
3817 priv
->ieee80211
->pairwise_key_type
,
3825 else if(priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_TKIP
)
3829 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3833 priv
->ieee80211
->pairwise_key_type
,
3841 priv
->ieee80211
->pairwise_key_type
,
3847 else if(priv
->ieee80211
->pairwise_key_type
== KEY_TYPE_CCMP
)
3851 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3855 priv
->ieee80211
->pairwise_key_type
,
3863 priv
->ieee80211
->pairwise_key_type
,
3872 if(priv
->ieee80211
->group_key_type
== KEY_TYPE_TKIP
)
3874 MacAddr
= CAM_CONST_BROAD
;
3875 for(EntryId
=1 ; EntryId
<4 ; EntryId
++)
3881 priv
->ieee80211
->group_key_type
,
3887 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3891 priv
->ieee80211
->group_key_type
,
3896 else if(priv
->ieee80211
->group_key_type
== KEY_TYPE_CCMP
)
3898 MacAddr
= CAM_CONST_BROAD
;
3899 for(EntryId
=1; EntryId
<4 ; EntryId
++)
3905 priv
->ieee80211
->group_key_type
,
3912 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
3916 priv
->ieee80211
->group_key_type
,
3924 * This function is used to fix Tx/Rx stop bug temporarily.
3925 * This function will do "system reset" to NIC when Tx or Rx is stuck.
3926 * The method checking Tx/Rx stuck of this function is supported by FW,
3927 * which reports Tx and Rx counter to register 0x128 and 0x130.
3929 static void rtl819x_ifsilentreset(struct net_device
*dev
)
3931 struct r8192_priv
*priv
= ieee80211_priv(dev
);
3933 int reset_status
= 0;
3934 struct ieee80211_device
*ieee
= priv
->ieee80211
;
3939 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3940 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3942 if(priv
->ResetProgress
==RESET_TYPE_NORESET
)
3946 //LZM for PS-Poll AID issue. 090429
3947 if(priv
->ieee80211
->state
== IEEE80211_LINKED
)
3948 LeisurePSLeave(dev
);
3951 RT_TRACE(COMP_RESET
,"=========>Reset progress!! \n");
3953 // Set the variable for reset.
3954 priv
->ResetProgress
= RESET_TYPE_SILENT
;
3955 // rtl8192_close(dev);
3957 down(&priv
->wx_sem
);
3960 RT_TRACE(COMP_ERR
,"%s():the driver is not up! return\n",__FUNCTION__
);
3965 RT_TRACE(COMP_RESET
,"%s():======>start to down the driver\n",__FUNCTION__
);
3966 if(!netif_queue_stopped(dev
))
3967 netif_stop_queue(dev
);
3969 dm_backup_dynamic_mechanism_state(dev
);
3971 rtl8192_irq_disable(dev
);
3972 rtl8192_cancel_deferred_work(priv
);
3974 del_timer_sync(&priv
->watch_dog_timer
);
3975 ieee
->sync_scan_hurryup
= 1;
3976 if(ieee
->state
== IEEE80211_LINKED
)
3978 down(&ieee
->wx_sem
);
3979 printk("ieee->state is IEEE80211_LINKED\n");
3980 ieee80211_stop_send_beacons(priv
->ieee80211
);
3981 del_timer_sync(&ieee
->associate_timer
);
3982 cancel_delayed_work(&ieee
->associate_retry_wq
);
3983 ieee80211_stop_scan(ieee
);
3987 printk("ieee->state is NOT LINKED\n");
3988 ieee80211_softmac_stop_protocol(priv
->ieee80211
,true);
3990 rtl8192_halt_adapter(dev
, true);
3992 RT_TRACE(COMP_RESET
,"%s():<==========down process is finished\n",__FUNCTION__
);
3993 RT_TRACE(COMP_RESET
,"%s():===========>start to up the driver\n",__FUNCTION__
);
3994 reset_status
= _rtl8192_up(dev
);
3996 RT_TRACE(COMP_RESET
,"%s():<===========up process is finished\n",__FUNCTION__
);
3997 if(reset_status
== -1)
4006 RT_TRACE(COMP_ERR
," ERR!!! %s(): Reset Failed!!\n",__FUNCTION__
);
4010 ieee
->is_silent_reset
= 1;
4012 EnableHWSecurityConfig8192(dev
);
4014 if(ieee
->state
== IEEE80211_LINKED
&& ieee
->iw_mode
== IW_MODE_INFRA
)
4016 ieee
->set_chan(ieee
->dev
, ieee
->current_network
.channel
);
4019 queue_work(ieee
->wq
, &ieee
->associate_complete_wq
);
4023 else if(ieee
->state
== IEEE80211_LINKED
&& ieee
->iw_mode
== IW_MODE_ADHOC
)
4025 ieee
->set_chan(ieee
->dev
, ieee
->current_network
.channel
);
4026 ieee
->link_change(ieee
->dev
);
4028 // notify_wx_assoc_event(ieee);
4030 ieee80211_start_send_beacons(ieee
);
4032 if (ieee
->data_hard_resume
)
4033 ieee
->data_hard_resume(ieee
->dev
);
4034 netif_carrier_on(ieee
->dev
);
4038 CamRestoreAllEntry(dev
);
4040 // Restore the previous setting for all dynamic mechanism
4041 dm_restore_dynamic_mechanism_state(dev
);
4043 priv
->ResetProgress
= RESET_TYPE_NORESET
;
4044 priv
->reset_count
++;
4046 priv
->bForcedSilentReset
=false;
4047 priv
->bResetInProgress
= false;
4049 // For test --> force write UFWP.
4050 write_nic_byte(dev
, UFWP
, 1);
4051 RT_TRACE(COMP_RESET
, "Reset finished!! ====>[%d]\n", priv
->reset_count
);
4057 void InactivePsWorkItemCallback(struct net_device
*dev
)
4059 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4060 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
4062 RT_TRACE(COMP_POWER
, "InactivePsWorkItemCallback() ---------> \n");
4064 // This flag "bSwRfProcessing", indicates the status of IPS procedure, should be set if the IPS workitem
4065 // is really scheduled.
4066 // The old code, sets this flag before scheduling the IPS workitem and however, at the same time the
4067 // previous IPS workitem did not end yet, fails to schedule the current workitem. Thus, bSwRfProcessing
4068 // blocks the IPS procedure of switching RF.
4069 // By Bruce, 2007-12-25.
4071 pPSC
->bSwRfProcessing
= TRUE
;
4073 RT_TRACE(COMP_RF
, "InactivePsWorkItemCallback(): Set RF to %s.\n",
4074 pPSC
->eInactivePowerState
== eRfOff
?"OFF":"ON");
4077 MgntActSet_RF_State(dev
, pPSC
->eInactivePowerState
, RF_CHANGE_BY_IPS
);
4080 // To solve CAM values miss in RF OFF, rewrite CAM values after RF ON. By Bruce, 2007-09-20.
4082 pPSC
->bSwRfProcessing
= FALSE
;
4083 RT_TRACE(COMP_POWER
, "InactivePsWorkItemCallback() <--------- \n");
4087 /* Change current and default preamble mode. */
4088 bool MgntActSet_802_11_PowerSaveMode(struct net_device
*dev
, u8 rtPsMode
)
4090 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4092 // Currently, we do not change power save mode on IBSS mode.
4093 if(priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
)
4099 // <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
4100 // some AP will not response to our mgnt frames with PwrMgt bit set,
4101 // e.g. cannot associate the AP.
4102 // So I commented out it. 2005.02.16, by rcnjko.
4104 // // Change device's power save mode.
4105 // Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
4107 // Update power save mode configured.
4108 //RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__FUNCTION__,rtPsMode);
4109 if(!priv
->ps_force
) {
4110 priv
->ieee80211
->ps
= rtPsMode
;
4113 // Awake immediately
4114 if(priv
->ieee80211
->sta_sleep
!= 0 && rtPsMode
== IEEE80211_PS_DISABLED
)
4116 unsigned long flags
;
4118 //PlatformSetTimer(Adapter, &(pMgntInfo->AwakeTimer), 0);
4119 // Notify the AP we awke.
4120 rtl8192_hw_wakeup(dev
);
4121 priv
->ieee80211
->sta_sleep
= 0;
4123 spin_lock_irqsave(&(priv
->ieee80211
->mgmt_tx_lock
), flags
);
4124 printk("LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
4125 ieee80211_sta_ps_send_null_frame(priv
->ieee80211
, 0);
4126 spin_unlock_irqrestore(&(priv
->ieee80211
->mgmt_tx_lock
), flags
);
4132 /* Enter the leisure power save mode. */
4133 void LeisurePSEnter(struct net_device
*dev
)
4135 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4136 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
4138 //RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
4139 //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
4140 // pPSC->bLeisurePs, priv->ieee80211->ps,pPSC->LpsIdleCount,RT_CHECK_FOR_HANG_PERIOD);
4142 if(!((priv
->ieee80211
->iw_mode
== IW_MODE_INFRA
) &&
4143 (priv
->ieee80211
->state
== IEEE80211_LINKED
)) ||
4144 (priv
->ieee80211
->iw_mode
== IW_MODE_ADHOC
) ||
4145 (priv
->ieee80211
->iw_mode
== IW_MODE_MASTER
))
4148 if (pPSC
->bLeisurePs
)
4150 // Idle for a while if we connect to AP a while ago.
4151 if(pPSC
->LpsIdleCount
>= RT_CHECK_FOR_HANG_PERIOD
) // 4 Sec
4154 if(priv
->ieee80211
->ps
== IEEE80211_PS_DISABLED
)
4157 //RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter 802.11 power save mode...\n");
4158 MgntActSet_802_11_PowerSaveMode(dev
, IEEE80211_PS_MBCAST
|IEEE80211_PS_UNICAST
);
4163 pPSC
->LpsIdleCount
++;
4168 /* Leave leisure power save mode. */
4169 void LeisurePSLeave(struct net_device
*dev
)
4171 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4172 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
4174 if (pPSC
->bLeisurePs
)
4176 if(priv
->ieee80211
->ps
!= IEEE80211_PS_DISABLED
)
4178 // move to lps_wakecomplete()
4179 //RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n");
4180 MgntActSet_802_11_PowerSaveMode(dev
, IEEE80211_PS_DISABLED
);
4188 /* Enter the inactive power save mode. RF will be off */
4190 IPSEnter(struct net_device
*dev
)
4192 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4193 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
4194 RT_RF_POWER_STATE rtState
;
4196 if (pPSC
->bInactivePs
)
4198 rtState
= priv
->ieee80211
->eRFPowerState
;
4200 // Added by Bruce, 2007-12-25.
4201 // Do not enter IPS in the following conditions:
4202 // (1) RF is already OFF or Sleep
4203 // (2) bSwRfProcessing (indicates the IPS is still under going)
4204 // (3) Connectted (only disconnected can trigger IPS)
4205 // (4) IBSS (send Beacon)
4206 // (5) AP mode (send Beacon)
4208 if (rtState
== eRfOn
&& !pPSC
->bSwRfProcessing
4209 && (priv
->ieee80211
->state
!= IEEE80211_LINKED
) )
4211 RT_TRACE(COMP_RF
,"IPSEnter(): Turn off RF.\n");
4212 //printk("IPSEnter(): Turn off RF.\n");
4213 pPSC
->eInactivePowerState
= eRfOff
;
4214 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4215 InactivePsWorkItemCallback(dev
);
4222 // Leave the inactive power save mode, RF will be on.
4223 // 2007.08.17, by shien chang.
4226 IPSLeave(struct net_device
*dev
)
4228 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4229 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
4230 RT_RF_POWER_STATE rtState
;
4232 if (pPSC
->bInactivePs
)
4234 rtState
= priv
->ieee80211
->eRFPowerState
;
4235 if (rtState
!= eRfOn
&& !pPSC
->bSwRfProcessing
&& priv
->ieee80211
->RfOffReason
<= RF_CHANGE_BY_IPS
)
4237 RT_TRACE(COMP_POWER
, "IPSLeave(): Turn on RF.\n");
4238 //printk("IPSLeave(): Turn on RF.\n");
4239 pPSC
->eInactivePowerState
= eRfOn
;
4240 // queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4241 InactivePsWorkItemCallback(dev
);
4246 void IPSLeave_wq(void *data
)
4248 struct ieee80211_device
*ieee
= container_of(data
,struct ieee80211_device
,ips_leave_wq
);
4249 struct net_device
*dev
= ieee
->dev
;
4251 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4252 down(&priv
->ieee80211
->ips_sem
);
4254 up(&priv
->ieee80211
->ips_sem
);
4257 void ieee80211_ips_leave_wq(struct net_device
*dev
)
4259 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4260 RT_RF_POWER_STATE rtState
;
4261 rtState
= priv
->ieee80211
->eRFPowerState
;
4263 if(priv
->ieee80211
->PowerSaveControl
.bInactivePs
){
4264 if(rtState
== eRfOff
){
4265 if(priv
->ieee80211
->RfOffReason
> RF_CHANGE_BY_IPS
)
4267 RT_TRACE(COMP_ERR
, "%s(): RF is OFF.\n",__FUNCTION__
);
4271 printk("=========>%s(): IPSLeave\n",__FUNCTION__
);
4272 queue_work(priv
->ieee80211
->wq
,&priv
->ieee80211
->ips_leave_wq
);
4277 //added by amy 090331 end
4278 void ieee80211_ips_leave(struct net_device
*dev
)
4280 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4281 down(&priv
->ieee80211
->ips_sem
);
4283 up(&priv
->ieee80211
->ips_sem
);
4287 static void rtl819x_update_rxcounts(
4288 struct r8192_priv
*priv
,
4297 *TotalRxDataNum
= 0;
4299 SlotIndex
= (priv
->ieee80211
->LinkDetectInfo
.SlotIndex
++)%(priv
->ieee80211
->LinkDetectInfo
.SlotNum
);
4300 priv
->ieee80211
->LinkDetectInfo
.RxBcnNum
[SlotIndex
] = priv
->ieee80211
->LinkDetectInfo
.NumRecvBcnInPeriod
;
4301 priv
->ieee80211
->LinkDetectInfo
.RxDataNum
[SlotIndex
] = priv
->ieee80211
->LinkDetectInfo
.NumRecvDataInPeriod
;
4302 for( i
=0; i
<priv
->ieee80211
->LinkDetectInfo
.SlotNum
; i
++ ){
4303 *TotalRxBcnNum
+= priv
->ieee80211
->LinkDetectInfo
.RxBcnNum
[i
];
4304 *TotalRxDataNum
+= priv
->ieee80211
->LinkDetectInfo
.RxDataNum
[i
];
4309 static void rtl819x_watchdog_wqcallback(struct work_struct
*work
)
4311 struct delayed_work
*dwork
= container_of(work
,struct delayed_work
,work
);
4312 struct r8192_priv
*priv
= container_of(dwork
,struct r8192_priv
,watch_dog_wq
);
4313 struct net_device
*dev
= priv
->ieee80211
->dev
;
4314 struct ieee80211_device
* ieee
= priv
->ieee80211
;
4315 RESET_TYPE ResetType
= RESET_TYPE_NORESET
;
4316 static u8 check_reset_cnt
=0;
4317 unsigned long flags
;
4318 bool bBusyTraffic
= false;
4319 static u8 last_time
= 0;
4320 bool bEnterPS
= false;
4322 if ((!priv
->up
) || priv
->bHwRadioOff
)
4327 hal_dm_watchdog(dev
);
4329 // printk("watch_dog ENABLE_IPS\n");
4330 if(ieee
->actscanning
== false){
4331 //printk("%d,%d,%d,%d\n", ieee->eRFPowerState, ieee->is_set_key, ieee->proto_stoppping, ieee->wx_set_enc);
4332 if((ieee
->iw_mode
== IW_MODE_INFRA
) && (ieee
->state
== IEEE80211_NOLINK
) &&
4333 (ieee
->eRFPowerState
== eRfOn
)&&!ieee
->is_set_key
&&
4334 (!ieee
->proto_stoppping
) && !ieee
->wx_set_enc
){
4335 if(ieee
->PowerSaveControl
.ReturnPoint
== IPS_CALLBACK_NONE
){
4336 //printk("====================>haha:IPSEnter()\n");
4338 //ieee80211_stop_scan(priv->ieee80211);
4343 {//to get busy traffic condition
4344 if(ieee
->state
== IEEE80211_LINKED
)
4346 if( ieee
->LinkDetectInfo
.NumRxOkInPeriod
> 100 ||
4347 ieee
->LinkDetectInfo
.NumTxOkInPeriod
> 100 ) {
4348 bBusyTraffic
= true;
4352 //added by amy for Leisure PS
4353 if( ((ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
+ ieee
->LinkDetectInfo
.NumTxOkInPeriod
) > 8 ) ||
4354 (ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
> 2) )
4356 //printk("ieee->LinkDetectInfo.NumRxUnicastOkInPeriod is %d,ieee->LinkDetectInfo.NumTxOkInPeriod is %d\n",
4357 // ieee->LinkDetectInfo.NumRxUnicastOkInPeriod,ieee->LinkDetectInfo.NumTxOkInPeriod);
4365 //printk("***bEnterPS = %d\n", bEnterPS);
4366 // LeisurePS only work in infra mode.
4369 LeisurePSEnter(dev
);
4373 LeisurePSLeave(dev
);
4381 //RT_TRACE(COMP_LPS,"====>no link LPS leave\n");
4382 LeisurePSLeave(dev
);
4386 ieee
->LinkDetectInfo
.NumRxOkInPeriod
= 0;
4387 ieee
->LinkDetectInfo
.NumTxOkInPeriod
= 0;
4388 ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
= 0;
4389 ieee
->LinkDetectInfo
.bBusyTraffic
= bBusyTraffic
;
4393 //added by amy for AP roaming
4396 if(ieee
->state
== IEEE80211_LINKED
&& ieee
->iw_mode
== IW_MODE_INFRA
)
4398 u32 TotalRxBcnNum
= 0;
4399 u32 TotalRxDataNum
= 0;
4401 rtl819x_update_rxcounts(priv
, &TotalRxBcnNum
, &TotalRxDataNum
);
4402 if((TotalRxBcnNum
+TotalRxDataNum
) == 0)
4404 if( ieee
->eRFPowerState
== eRfOff
)
4405 RT_TRACE(COMP_ERR
,"========>%s()\n",__FUNCTION__
);
4406 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__
);
4407 // Dot11d_Reset(dev);
4408 ieee
->state
= IEEE80211_ASSOCIATING
;
4409 notify_wx_assoc_event(priv
->ieee80211
);
4410 RemovePeerTS(priv
->ieee80211
,priv
->ieee80211
->current_network
.bssid
);
4411 ieee
->is_roaming
= true;
4412 ieee
->is_set_key
= false;
4413 ieee
->link_change(dev
);
4414 queue_work(ieee
->wq
, &ieee
->associate_procedure_wq
);
4417 ieee
->LinkDetectInfo
.NumRecvBcnInPeriod
=0;
4418 ieee
->LinkDetectInfo
.NumRecvDataInPeriod
=0;
4421 //check if reset the driver
4422 spin_lock_irqsave(&priv
->tx_lock
,flags
);
4423 if(check_reset_cnt
++ >= 3 && !ieee
->is_roaming
&& (last_time
!= 1))
4425 ResetType
= rtl819x_ifcheck_resetornot(dev
);
4426 check_reset_cnt
= 3;
4427 //DbgPrint("Start to check silent reset\n");
4429 spin_unlock_irqrestore(&priv
->tx_lock
,flags
);
4430 if(!priv
->bDisableNormalResetCheck
&& ResetType
== RESET_TYPE_NORMAL
)
4432 priv
->ResetProgress
= RESET_TYPE_NORMAL
;
4433 RT_TRACE(COMP_RESET
,"%s(): NOMAL RESET\n",__FUNCTION__
);
4436 /* disable silent reset temply 2008.9.11*/
4438 if( ((priv
->force_reset
) || (!priv
->bDisableNormalResetCheck
&& ResetType
==RESET_TYPE_SILENT
))) // This is control by OID set in Pomelo
4441 rtl819x_ifsilentreset(dev
);
4446 priv
->force_reset
= false;
4447 priv
->bForcedSilentReset
= false;
4448 priv
->bResetInProgress
= false;
4449 RT_TRACE(COMP_TRACE
, " <==RtUsbCheckForHangWorkItemCallback()\n");
4453 void watch_dog_timer_callback(unsigned long data
)
4455 struct r8192_priv
*priv
= ieee80211_priv((struct net_device
*) data
);
4456 queue_delayed_work(priv
->priv_wq
,&priv
->watch_dog_wq
,0);
4457 mod_timer(&priv
->watch_dog_timer
, jiffies
+ MSECS(IEEE80211_WATCH_DOG_TIME
));
4461 static int _rtl8192_up(struct net_device
*dev
)
4463 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4465 RT_STATUS init_status
= RT_STATUS_SUCCESS
;
4467 priv
->ieee80211
->ieee_up
=1;
4468 priv
->bdisable_nic
= false; //YJ,add,091111
4469 RT_TRACE(COMP_INIT
, "Bringing up iface");
4471 init_status
= rtl8192_adapter_start(dev
);
4472 if(init_status
!= RT_STATUS_SUCCESS
)
4474 RT_TRACE(COMP_ERR
,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__
);
4477 RT_TRACE(COMP_INIT
, "start adapter finished\n");
4479 if(priv
->ieee80211
->eRFPowerState
!=eRfOn
)
4480 MgntActSet_RF_State(dev
, eRfOn
, priv
->ieee80211
->RfOffReason
);
4482 if(priv
->ieee80211
->state
!= IEEE80211_LINKED
)
4483 ieee80211_softmac_start_protocol(priv
->ieee80211
);
4484 ieee80211_reset_queue(priv
->ieee80211
);
4485 watch_dog_timer_callback((unsigned long) dev
);
4486 if(!netif_queue_stopped(dev
))
4487 netif_start_queue(dev
);
4489 netif_wake_queue(dev
);
4495 static int rtl8192_open(struct net_device
*dev
)
4497 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4500 down(&priv
->wx_sem
);
4501 ret
= rtl8192_up(dev
);
4508 int rtl8192_up(struct net_device
*dev
)
4510 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4512 if (priv
->up
== 1) return -1;
4514 return _rtl8192_up(dev
);
4518 static int rtl8192_close(struct net_device
*dev
)
4520 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4523 down(&priv
->wx_sem
);
4525 ret
= rtl8192_down(dev
);
4533 int rtl8192_down(struct net_device
*dev
)
4535 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4537 if (priv
->up
== 0) return -1;
4540 //LZM for PS-Poll AID issue. 090429
4541 if(priv
->ieee80211
->state
== IEEE80211_LINKED
)
4542 LeisurePSLeave(dev
);
4546 priv
->ieee80211
->ieee_up
= 0;
4547 RT_TRACE(COMP_DOWN
, "==========>%s()\n", __FUNCTION__
);
4549 if (!netif_queue_stopped(dev
))
4550 netif_stop_queue(dev
);
4552 rtl8192_irq_disable(dev
);
4553 rtl8192_cancel_deferred_work(priv
);
4555 del_timer_sync(&priv
->watch_dog_timer
);
4557 ieee80211_softmac_stop_protocol(priv
->ieee80211
,true);
4559 rtl8192_halt_adapter(dev
,false);
4560 memset(&priv
->ieee80211
->current_network
, 0 , offsetof(struct ieee80211_network
, list
));
4562 RT_TRACE(COMP_DOWN
, "<==========%s()\n", __FUNCTION__
);
4568 void rtl8192_commit(struct net_device
*dev
)
4570 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4572 if (priv
->up
== 0) return ;
4575 ieee80211_softmac_stop_protocol(priv
->ieee80211
,true);
4577 rtl8192_irq_disable(dev
);
4578 rtl8192_halt_adapter(dev
,true);
4582 static void rtl8192_restart(struct work_struct
*work
)
4584 struct r8192_priv
*priv
= container_of(work
, struct r8192_priv
, reset_wq
);
4585 struct net_device
*dev
= priv
->ieee80211
->dev
;
4587 down(&priv
->wx_sem
);
4589 rtl8192_commit(dev
);
4594 static void r8192_set_multicast(struct net_device
*dev
)
4596 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4599 //down(&priv->wx_sem);
4603 promisc
= (dev
->flags
& IFF_PROMISC
) ? 1:0;
4605 if (promisc
!= priv
->promisc
) {
4607 // rtl8192_commit(dev);
4610 priv
->promisc
= promisc
;
4612 //schedule_work(&priv->reset_wq);
4613 //up(&priv->wx_sem);
4617 static int r8192_set_mac_adr(struct net_device
*dev
, void *mac
)
4619 struct r8192_priv
*priv
= ieee80211_priv(dev
);
4620 struct sockaddr
*addr
= mac
;
4622 down(&priv
->wx_sem
);
4624 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
4626 schedule_work(&priv
->reset_wq
);
4632 /* based on ipw2200 driver */
4633 static int rtl8192_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
4635 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4636 struct iwreq
*wrq
= (struct iwreq
*)rq
;
4638 struct ieee80211_device
*ieee
= priv
->ieee80211
;
4640 u8 broadcast_addr
[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4641 struct iw_point
*p
= &wrq
->u
.data
;
4642 struct ieee_param
*ipw
= NULL
;//(struct ieee_param *)wrq->u.data.pointer;
4644 down(&priv
->wx_sem
);
4647 if (p
->length
< sizeof(struct ieee_param
) || !p
->pointer
){
4652 ipw
= kmalloc(p
->length
, GFP_KERNEL
);
4657 if (copy_from_user(ipw
, p
->pointer
, p
->length
)) {
4664 case RTL_IOCTL_WPA_SUPPLICANT
:
4665 //parse here for HW security
4666 if (ipw
->cmd
== IEEE_CMD_SET_ENCRYPTION
)
4668 if (ipw
->u
.crypt
.set_tx
)
4670 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
4671 ieee
->pairwise_key_type
= KEY_TYPE_CCMP
;
4672 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
4673 ieee
->pairwise_key_type
= KEY_TYPE_TKIP
;
4674 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0)
4676 if (ipw
->u
.crypt
.key_len
== 13)
4677 ieee
->pairwise_key_type
= KEY_TYPE_WEP104
;
4678 else if (ipw
->u
.crypt
.key_len
== 5)
4679 ieee
->pairwise_key_type
= KEY_TYPE_WEP40
;
4682 ieee
->pairwise_key_type
= KEY_TYPE_NA
;
4684 if (ieee
->pairwise_key_type
)
4686 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
4687 EnableHWSecurityConfig8192(dev
);
4688 //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!
4690 setKey(dev
, 4, ipw
->u
.crypt
.idx
, ieee
->pairwise_key_type
, (u8
*)ieee
->ap_mac_addr
, 0, key
);
4691 if (ieee
->auth_mode
!= 2) //LEAP WEP will never set this.
4692 setKey(dev
, ipw
->u
.crypt
.idx
, ipw
->u
.crypt
.idx
, ieee
->pairwise_key_type
, (u8
*)ieee
->ap_mac_addr
, 0, key
);
4694 if ((ieee
->pairwise_key_type
== KEY_TYPE_CCMP
) && ieee
->pHTInfo
->bCurrentHTSupport
){
4695 write_nic_byte(dev
, 0x173, 1); //fix aes bug
4699 else //if (ipw->u.crypt.idx) //group key use idx > 0
4701 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
4702 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
4703 ieee
->group_key_type
= KEY_TYPE_CCMP
;
4704 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
4705 ieee
->group_key_type
= KEY_TYPE_TKIP
;
4706 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0)
4708 if (ipw
->u
.crypt
.key_len
== 13)
4709 ieee
->group_key_type
= KEY_TYPE_WEP104
;
4710 else if (ipw
->u
.crypt
.key_len
== 5)
4711 ieee
->group_key_type
= KEY_TYPE_WEP40
;
4714 ieee
->group_key_type
= KEY_TYPE_NA
;
4716 if (ieee
->group_key_type
)
4720 ipw
->u
.crypt
.idx
, //KeyIndex
4721 ieee
->group_key_type
, //KeyType
4722 broadcast_addr
, //MacAddr
4732 printk("@@ wrq->u pointer = ");
4733 for(i
=0;i
<wrq
->u
.data
.length
;i
++){
4734 if(i
%10==0) printk("\n");
4735 printk( "%8x|", ((u32
*)wrq
->u
.data
.pointer
)[i
] );
4739 #endif /*JOHN_DEBUG*/
4740 ret
= ieee80211_wpa_supplicant_ioctl(priv
->ieee80211
, &wrq
->u
.data
);
4755 static u8
HwRateToMRate90(bool bIsHT
, u8 rate
)
4761 case DESC90_RATE1M
: ret_rate
= MGN_1M
; break;
4762 case DESC90_RATE2M
: ret_rate
= MGN_2M
; break;
4763 case DESC90_RATE5_5M
: ret_rate
= MGN_5_5M
; break;
4764 case DESC90_RATE11M
: ret_rate
= MGN_11M
; break;
4765 case DESC90_RATE6M
: ret_rate
= MGN_6M
; break;
4766 case DESC90_RATE9M
: ret_rate
= MGN_9M
; break;
4767 case DESC90_RATE12M
: ret_rate
= MGN_12M
; break;
4768 case DESC90_RATE18M
: ret_rate
= MGN_18M
; break;
4769 case DESC90_RATE24M
: ret_rate
= MGN_24M
; break;
4770 case DESC90_RATE36M
: ret_rate
= MGN_36M
; break;
4771 case DESC90_RATE48M
: ret_rate
= MGN_48M
; break;
4772 case DESC90_RATE54M
: ret_rate
= MGN_54M
; break;
4775 RT_TRACE(COMP_RECV
, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate
, bIsHT
);
4781 case DESC90_RATEMCS0
: ret_rate
= MGN_MCS0
; break;
4782 case DESC90_RATEMCS1
: ret_rate
= MGN_MCS1
; break;
4783 case DESC90_RATEMCS2
: ret_rate
= MGN_MCS2
; break;
4784 case DESC90_RATEMCS3
: ret_rate
= MGN_MCS3
; break;
4785 case DESC90_RATEMCS4
: ret_rate
= MGN_MCS4
; break;
4786 case DESC90_RATEMCS5
: ret_rate
= MGN_MCS5
; break;
4787 case DESC90_RATEMCS6
: ret_rate
= MGN_MCS6
; break;
4788 case DESC90_RATEMCS7
: ret_rate
= MGN_MCS7
; break;
4789 case DESC90_RATEMCS8
: ret_rate
= MGN_MCS8
; break;
4790 case DESC90_RATEMCS9
: ret_rate
= MGN_MCS9
; break;
4791 case DESC90_RATEMCS10
: ret_rate
= MGN_MCS10
; break;
4792 case DESC90_RATEMCS11
: ret_rate
= MGN_MCS11
; break;
4793 case DESC90_RATEMCS12
: ret_rate
= MGN_MCS12
; break;
4794 case DESC90_RATEMCS13
: ret_rate
= MGN_MCS13
; break;
4795 case DESC90_RATEMCS14
: ret_rate
= MGN_MCS14
; break;
4796 case DESC90_RATEMCS15
: ret_rate
= MGN_MCS15
; break;
4797 case DESC90_RATEMCS32
: ret_rate
= (0x80|0x20); break;
4800 RT_TRACE(COMP_RECV
, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate
, bIsHT
);
4808 /* Record the TSF time stamp when receiving a packet */
4809 static void UpdateRxPktTimeStamp8190 (struct net_device
*dev
, struct ieee80211_rx_stats
*stats
)
4811 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
4813 if(stats
->bIsAMPDU
&& !stats
->bFirstMPDU
) {
4814 stats
->mac_time
[0] = priv
->LastRxDescTSFLow
;
4815 stats
->mac_time
[1] = priv
->LastRxDescTSFHigh
;
4817 priv
->LastRxDescTSFLow
= stats
->mac_time
[0];
4818 priv
->LastRxDescTSFHigh
= stats
->mac_time
[1];
4822 static long rtl819x_translate_todbm(u8 signal_strength_index
)// 0-100 index.
4824 long signal_power
; // in dBm.
4826 // Translate to dBm (x=0.5y-95).
4827 signal_power
= (long)((signal_strength_index
+ 1) >> 1);
4830 return signal_power
;
4834 * Update Rx signal related information in the packet reeived
4835 * to RxStats. User application can query RxStats to realize
4836 * current Rx signal status.
4838 * In normal operation, user only care about the information of the BSS
4839 * and we shall invoke this function if the packet received is from the BSS.
4842 rtl819x_update_rxsignalstatistics8190pci(
4843 struct r8192_priv
* priv
,
4844 struct ieee80211_rx_stats
* pprevious_stats
4849 //2 <ToDo> Update Rx Statistics (such as signal strength and signal quality).
4852 if(priv
->stats
.recv_signal_power
== 0)
4853 priv
->stats
.recv_signal_power
= pprevious_stats
->RecvSignalPower
;
4855 // To avoid the past result restricting the statistics sensitivity, weight the current power (5/6) to speed up the
4856 // reaction of smoothed Signal Power.
4857 if(pprevious_stats
->RecvSignalPower
> priv
->stats
.recv_signal_power
)
4859 else if(pprevious_stats
->RecvSignalPower
< priv
->stats
.recv_signal_power
)
4862 // We need more correct power of received packets and the "SignalStrength" of RxStats have been beautified or translated,
4863 // so we record the correct power in Dbm here. By Bruce, 2008-03-07.
4865 priv
->stats
.recv_signal_power
= (priv
->stats
.recv_signal_power
* 5 + pprevious_stats
->RecvSignalPower
+ weighting
) / 6;
4869 rtl8190_process_cck_rxpathsel(
4870 struct r8192_priv
* priv
,
4871 struct ieee80211_rx_stats
* pprevious_stats
4874 #ifdef RTL8190P //Only 90P 2T4R need to check
4875 char last_cck_adc_pwdb
[4]={0,0,0,0};
4877 //cosa add for Rx path selection
4878 if(priv
->rf_type
== RF_2T4R
&& DM_RxPathSelTable
.Enable
)
4880 if(pprevious_stats
->bIsCCK
&&
4881 (pprevious_stats
->bPacketToSelf
||pprevious_stats
->bPacketBeacon
))
4883 /* record the cck adc_pwdb to the sliding window. */
4884 if(priv
->stats
.cck_adc_pwdb
.TotalNum
++ >= PHY_RSSI_SLID_WIN_MAX
)
4886 priv
->stats
.cck_adc_pwdb
.TotalNum
= PHY_RSSI_SLID_WIN_MAX
;
4887 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
4889 last_cck_adc_pwdb
[i
] = priv
->stats
.cck_adc_pwdb
.elements
[i
][priv
->stats
.cck_adc_pwdb
.index
];
4890 priv
->stats
.cck_adc_pwdb
.TotalVal
[i
] -= last_cck_adc_pwdb
[i
];
4893 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
4895 priv
->stats
.cck_adc_pwdb
.TotalVal
[i
] += pprevious_stats
->cck_adc_pwdb
[i
];
4896 priv
->stats
.cck_adc_pwdb
.elements
[i
][priv
->stats
.cck_adc_pwdb
.index
] = pprevious_stats
->cck_adc_pwdb
[i
];
4898 priv
->stats
.cck_adc_pwdb
.index
++;
4899 if(priv
->stats
.cck_adc_pwdb
.index
>= PHY_RSSI_SLID_WIN_MAX
)
4900 priv
->stats
.cck_adc_pwdb
.index
= 0;
4902 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
4904 DM_RxPathSelTable
.cck_pwdb_sta
[i
] = priv
->stats
.cck_adc_pwdb
.TotalVal
[i
]/priv
->stats
.cck_adc_pwdb
.TotalNum
;
4907 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
4909 if(pprevious_stats
->cck_adc_pwdb
[i
] > (char)priv
->undecorated_smoothed_cck_adc_pwdb
[i
])
4911 priv
->undecorated_smoothed_cck_adc_pwdb
[i
] =
4912 ( (priv
->undecorated_smoothed_cck_adc_pwdb
[i
]*(Rx_Smooth_Factor
-1)) +
4913 (pprevious_stats
->cck_adc_pwdb
[i
])) /(Rx_Smooth_Factor
);
4914 priv
->undecorated_smoothed_cck_adc_pwdb
[i
] = priv
->undecorated_smoothed_cck_adc_pwdb
[i
] + 1;
4918 priv
->undecorated_smoothed_cck_adc_pwdb
[i
] =
4919 ( (priv
->undecorated_smoothed_cck_adc_pwdb
[i
]*(Rx_Smooth_Factor
-1)) +
4920 (pprevious_stats
->cck_adc_pwdb
[i
])) /(Rx_Smooth_Factor
);
4929 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
4930 be a local static. Otherwise, it may increase when we return from S3/S4. The
4931 value will be kept in memory or disk. We must delcare the value in adapter
4932 and it will be reinitialized when return from S3/S4. */
4933 static void rtl8192_process_phyinfo(struct r8192_priv
* priv
, u8
* buffer
,struct ieee80211_rx_stats
* pprevious_stats
, struct ieee80211_rx_stats
* pcurrent_stats
)
4935 bool bcheck
= false;
4937 u32 nspatial_stream
, tmp_val
;
4939 static u32 slide_rssi_index
=0, slide_rssi_statistics
=0;
4940 static u32 slide_evm_index
=0, slide_evm_statistics
=0;
4941 static u32 last_rssi
=0, last_evm
=0;
4942 //cosa add for rx path selection
4943 // static long slide_cck_adc_pwdb_index=0, slide_cck_adc_pwdb_statistics=0;
4944 // static char last_cck_adc_pwdb[4]={0,0,0,0};
4945 //cosa add for beacon rssi smoothing
4946 static u32 slide_beacon_adc_pwdb_index
=0, slide_beacon_adc_pwdb_statistics
=0;
4947 static u32 last_beacon_adc_pwdb
=0;
4949 struct ieee80211_hdr_3addr
*hdr
;
4951 unsigned int frag
,seq
;
4952 hdr
= (struct ieee80211_hdr_3addr
*)buffer
;
4953 sc
= le16_to_cpu(hdr
->seq_ctl
);
4954 frag
= WLAN_GET_SEQ_FRAG(sc
);
4955 seq
= WLAN_GET_SEQ_SEQ(sc
);
4956 //cosa add 04292008 to record the sequence number
4957 pcurrent_stats
->Seq_Num
= seq
;
4959 // Check whether we should take the previous packet into accounting
4961 if(!pprevious_stats
->bIsAMPDU
)
4963 // if previous packet is not aggregated packet
4967 //remve for that we don't use AMPDU to calculate PWDB,because the reported PWDB of some AP is fault.
4969 // if previous packet is aggregated packet, and current packet
4971 // (2) is the first packet of one AMPDU
4972 // that means the previous packet is the last one aggregated packet
4973 if( !pcurrent_stats
->bIsAMPDU
|| pcurrent_stats
->bFirstMPDU
)
4978 if(slide_rssi_statistics
++ >= PHY_RSSI_SLID_WIN_MAX
)
4980 slide_rssi_statistics
= PHY_RSSI_SLID_WIN_MAX
;
4981 last_rssi
= priv
->stats
.slide_signal_strength
[slide_rssi_index
];
4982 priv
->stats
.slide_rssi_total
-= last_rssi
;
4984 priv
->stats
.slide_rssi_total
+= pprevious_stats
->SignalStrength
;
4986 priv
->stats
.slide_signal_strength
[slide_rssi_index
++] = pprevious_stats
->SignalStrength
;
4987 if(slide_rssi_index
>= PHY_RSSI_SLID_WIN_MAX
)
4988 slide_rssi_index
= 0;
4990 // <1> Showed on UI for user, in dbm
4991 tmp_val
= priv
->stats
.slide_rssi_total
/slide_rssi_statistics
;
4992 priv
->stats
.signal_strength
= rtl819x_translate_todbm((u8
)tmp_val
);
4993 pcurrent_stats
->rssi
= priv
->stats
.signal_strength
;
4995 // If the previous packet does not match the criteria, neglect it
4997 if(!pprevious_stats
->bPacketMatchBSSID
)
4999 if(!pprevious_stats
->bToSelfBA
)
5006 rtl8190_process_cck_rxpathsel(priv
,pprevious_stats
);
5011 priv
->stats
.num_process_phyinfo
++;
5013 /* record the general signal strength to the sliding window. */
5014 if(slide_rssi_statistics
++ >= PHY_RSSI_SLID_WIN_MAX
)
5016 slide_rssi_statistics
= PHY_RSSI_SLID_WIN_MAX
;
5017 last_rssi
= priv
->stats
.slide_signal_strength
[slide_rssi_index
];
5018 priv
->stats
.slide_rssi_total
-= last_rssi
;
5020 priv
->stats
.slide_rssi_total
+= pprevious_stats
->SignalStrength
;
5022 priv
->stats
.slide_signal_strength
[slide_rssi_index
++] = pprevious_stats
->SignalStrength
;
5023 if(slide_rssi_index
>= PHY_RSSI_SLID_WIN_MAX
)
5024 slide_rssi_index
= 0;
5026 // <1> Showed on UI for user, in dbm
5027 tmp_val
= priv
->stats
.slide_rssi_total
/slide_rssi_statistics
;
5028 priv
->stats
.signal_strength
= rtl819x_translate_todbm((u8
)tmp_val
);
5031 // <2> Showed on UI for engineering
5032 // hardware does not provide rssi information for each rf path in CCK
5033 if(!pprevious_stats
->bIsCCK
&& pprevious_stats
->bPacketToSelf
)
5035 for (rfpath
= RF90_PATH_A
; rfpath
< RF90_PATH_C
; rfpath
++)
5037 if (!rtl8192_phy_CheckIsLegalRFPath(priv
->ieee80211
->dev
, rfpath
))
5039 RT_TRACE(COMP_DBG
,"Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath] = %d \n" ,pprevious_stats
->RxMIMOSignalStrength
[rfpath
] );
5040 //Fixed by Jacken 2008-03-20
5041 if(priv
->stats
.rx_rssi_percentage
[rfpath
] == 0)
5043 priv
->stats
.rx_rssi_percentage
[rfpath
] = pprevious_stats
->RxMIMOSignalStrength
[rfpath
];
5044 //DbgPrint("MIMO RSSI initialize \n");
5046 if(pprevious_stats
->RxMIMOSignalStrength
[rfpath
] > priv
->stats
.rx_rssi_percentage
[rfpath
])
5048 priv
->stats
.rx_rssi_percentage
[rfpath
] =
5049 ( (priv
->stats
.rx_rssi_percentage
[rfpath
]*(Rx_Smooth_Factor
-1)) +
5050 (pprevious_stats
->RxMIMOSignalStrength
[rfpath
])) /(Rx_Smooth_Factor
);
5051 priv
->stats
.rx_rssi_percentage
[rfpath
] = priv
->stats
.rx_rssi_percentage
[rfpath
] + 1;
5055 priv
->stats
.rx_rssi_percentage
[rfpath
] =
5056 ( (priv
->stats
.rx_rssi_percentage
[rfpath
]*(Rx_Smooth_Factor
-1)) +
5057 (pprevious_stats
->RxMIMOSignalStrength
[rfpath
])) /(Rx_Smooth_Factor
);
5059 RT_TRACE(COMP_DBG
,"Jacken -> priv->RxStats.RxRSSIPercentage[rfPath] = %d \n" ,priv
->stats
.rx_rssi_percentage
[rfpath
] );
5067 //cosa add for beacon rssi smoothing by average.
5068 if(pprevious_stats
->bPacketBeacon
)
5070 /* record the beacon pwdb to the sliding window. */
5071 if(slide_beacon_adc_pwdb_statistics
++ >= PHY_Beacon_RSSI_SLID_WIN_MAX
)
5073 slide_beacon_adc_pwdb_statistics
= PHY_Beacon_RSSI_SLID_WIN_MAX
;
5074 last_beacon_adc_pwdb
= priv
->stats
.Slide_Beacon_pwdb
[slide_beacon_adc_pwdb_index
];
5075 priv
->stats
.Slide_Beacon_Total
-= last_beacon_adc_pwdb
;
5076 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
5077 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
5079 priv
->stats
.Slide_Beacon_Total
+= pprevious_stats
->RxPWDBAll
;
5080 priv
->stats
.Slide_Beacon_pwdb
[slide_beacon_adc_pwdb_index
] = pprevious_stats
->RxPWDBAll
;
5081 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
5082 slide_beacon_adc_pwdb_index
++;
5083 if(slide_beacon_adc_pwdb_index
>= PHY_Beacon_RSSI_SLID_WIN_MAX
)
5084 slide_beacon_adc_pwdb_index
= 0;
5085 pprevious_stats
->RxPWDBAll
= priv
->stats
.Slide_Beacon_Total
/slide_beacon_adc_pwdb_statistics
;
5086 if(pprevious_stats
->RxPWDBAll
>= 3)
5087 pprevious_stats
->RxPWDBAll
-= 3;
5090 RT_TRACE(COMP_RXDESC
, "Smooth %s PWDB = %d\n",
5091 pprevious_stats
->bIsCCK
? "CCK": "OFDM",
5092 pprevious_stats
->RxPWDBAll
);
5094 if(pprevious_stats
->bPacketToSelf
|| pprevious_stats
->bPacketBeacon
|| pprevious_stats
->bToSelfBA
)
5096 if(priv
->undecorated_smoothed_pwdb
< 0) // initialize
5098 priv
->undecorated_smoothed_pwdb
= pprevious_stats
->RxPWDBAll
;
5099 //DbgPrint("First pwdb initialize \n");
5102 if(pprevious_stats
->RxPWDBAll
> (u32
)priv
->undecorated_smoothed_pwdb
)
5104 priv
->undecorated_smoothed_pwdb
=
5105 ( ((priv
->undecorated_smoothed_pwdb
)*(Rx_Smooth_Factor
-1)) +
5106 (pprevious_stats
->RxPWDBAll
)) /(Rx_Smooth_Factor
);
5107 priv
->undecorated_smoothed_pwdb
= priv
->undecorated_smoothed_pwdb
+ 1;
5111 priv
->undecorated_smoothed_pwdb
=
5112 ( ((priv
->undecorated_smoothed_pwdb
)*(Rx_Smooth_Factor
-1)) +
5113 (pprevious_stats
->RxPWDBAll
)) /(Rx_Smooth_Factor
);
5116 //Fixed by Jacken 2008-03-20
5117 if(pPreviousRfd
->Status
.RxPWDBAll
> (u32
)pHalData
->UndecoratedSmoothedPWDB
)
5119 pHalData
->UndecoratedSmoothedPWDB
=
5120 ( ((pHalData
->UndecoratedSmoothedPWDB
)* 5) + (pPreviousRfd
->Status
.RxPWDBAll
)) / 6;
5121 pHalData
->UndecoratedSmoothedPWDB
= pHalData
->UndecoratedSmoothedPWDB
+ 1;
5125 pHalData
->UndecoratedSmoothedPWDB
=
5126 ( ((pHalData
->UndecoratedSmoothedPWDB
)* 5) + (pPreviousRfd
->Status
.RxPWDBAll
)) / 6;
5129 rtl819x_update_rxsignalstatistics8190pci(priv
,pprevious_stats
);
5135 /* record the general EVM to the sliding window. */
5136 if(pprevious_stats
->SignalQuality
== 0)
5141 if(pprevious_stats
->bPacketToSelf
|| pprevious_stats
->bPacketBeacon
|| pprevious_stats
->bToSelfBA
){
5142 if(slide_evm_statistics
++ >= PHY_RSSI_SLID_WIN_MAX
){
5143 slide_evm_statistics
= PHY_RSSI_SLID_WIN_MAX
;
5144 last_evm
= priv
->stats
.slide_evm
[slide_evm_index
];
5145 priv
->stats
.slide_evm_total
-= last_evm
;
5148 priv
->stats
.slide_evm_total
+= pprevious_stats
->SignalQuality
;
5150 priv
->stats
.slide_evm
[slide_evm_index
++] = pprevious_stats
->SignalQuality
;
5151 if(slide_evm_index
>= PHY_RSSI_SLID_WIN_MAX
)
5152 slide_evm_index
= 0;
5154 // <1> Showed on UI for user, in percentage.
5155 tmp_val
= priv
->stats
.slide_evm_total
/slide_evm_statistics
;
5156 priv
->stats
.signal_quality
= tmp_val
;
5157 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
5158 priv
->stats
.last_signal_strength_inpercent
= tmp_val
;
5161 // <2> Showed on UI for engineering
5162 if(pprevious_stats
->bPacketToSelf
|| pprevious_stats
->bPacketBeacon
|| pprevious_stats
->bToSelfBA
)
5164 for(nspatial_stream
= 0; nspatial_stream
<2 ; nspatial_stream
++) // 2 spatial stream
5166 if(pprevious_stats
->RxMIMOSignalQuality
[nspatial_stream
] != -1)
5168 if(priv
->stats
.rx_evm_percentage
[nspatial_stream
] == 0) // initialize
5170 priv
->stats
.rx_evm_percentage
[nspatial_stream
] = pprevious_stats
->RxMIMOSignalQuality
[nspatial_stream
];
5172 priv
->stats
.rx_evm_percentage
[nspatial_stream
] =
5173 ( (priv
->stats
.rx_evm_percentage
[nspatial_stream
]* (Rx_Smooth_Factor
-1)) +
5174 (pprevious_stats
->RxMIMOSignalQuality
[nspatial_stream
]* 1)) / (Rx_Smooth_Factor
);
5182 static u8
rtl819x_query_rxpwrpercentage(
5186 if ((antpower
<= -100) || (antpower
>= 20))
5190 else if (antpower
>= 0)
5196 return (100+antpower
);
5202 rtl819x_evm_dbtopercentage(
5214 ret_val
= 0 - ret_val
;
5221 /* We want good-looking for signal strength/quality */
5222 static long rtl819x_signal_scale_mapping(long currsig
)
5226 // Step 1. Scale mapping.
5227 if(currsig
>= 61 && currsig
<= 100)
5229 retsig
= 90 + ((currsig
- 60) / 4);
5231 else if(currsig
>= 41 && currsig
<= 60)
5233 retsig
= 78 + ((currsig
- 40) / 2);
5235 else if(currsig
>= 31 && currsig
<= 40)
5237 retsig
= 66 + (currsig
- 30);
5239 else if(currsig
>= 21 && currsig
<= 30)
5241 retsig
= 54 + (currsig
- 20);
5243 else if(currsig
>= 5 && currsig
<= 20)
5245 retsig
= 42 + (((currsig
- 5) * 2) / 3);
5247 else if(currsig
== 4)
5251 else if(currsig
== 3)
5255 else if(currsig
== 2)
5259 else if(currsig
== 1)
5271 static void rtl8192_query_rxphystatus(
5272 struct r8192_priv
* priv
,
5273 struct ieee80211_rx_stats
* pstats
,
5274 prx_desc_819x_pci pdesc
,
5275 prx_fwinfo_819x_pci pdrvinfo
,
5276 struct ieee80211_rx_stats
* precord_stats
,
5277 bool bpacket_match_bssid
,
5278 bool bpacket_toself
,
5283 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
5284 phy_sts_ofdm_819xpci_t
* pofdm_buf
;
5285 phy_sts_cck_819xpci_t
* pcck_buf
;
5286 phy_ofdm_rx_status_rxsc_sgien_exintfflag
* prxsc
;
5288 u8 i
,max_spatial_stream
, tmp_rxsnr
, tmp_rxevm
, rxsc_sgien_exflg
;
5289 char rx_pwr
[4], rx_pwr_all
=0;
5290 //long rx_avg_pwr = 0;
5291 char rx_snrX
, rx_evmX
;
5293 u32 RSSI
, total_rssi
=0;//, total_evm=0;
5294 // long signal_strength_index = 0;
5298 /* 2007/07/04 MH For OFDM RSSI. For high power or not. */
5299 static u8 check_reg824
= 0;
5300 static u32 reg824_bit9
= 0;
5302 priv
->stats
.numqry_phystatus
++;
5304 is_cck_rate
= rx_hal_is_cck_rate(pdrvinfo
);
5306 // Record it for next packet processing
5307 memset(precord_stats
, 0, sizeof(struct ieee80211_rx_stats
));
5308 pstats
->bPacketMatchBSSID
= precord_stats
->bPacketMatchBSSID
= bpacket_match_bssid
;
5309 pstats
->bPacketToSelf
= precord_stats
->bPacketToSelf
= bpacket_toself
;
5310 pstats
->bIsCCK
= precord_stats
->bIsCCK
= is_cck_rate
;//RX_HAL_IS_CCK_RATE(pDrvInfo);
5311 pstats
->bPacketBeacon
= precord_stats
->bPacketBeacon
= bPacketBeacon
;
5312 pstats
->bToSelfBA
= precord_stats
->bToSelfBA
= bToSelfBA
;
5313 /*2007.08.30 requested by SD3 Jerry */
5314 if(check_reg824
== 0)
5316 reg824_bit9
= rtl8192_QueryBBReg(priv
->ieee80211
->dev
, rFPGA0_XA_HSSIParameter2
, 0x200);
5321 prxpkt
= (u8
*)pdrvinfo
;
5323 /* Move pointer to the 16th bytes. Phy status start address. */
5324 prxpkt
+= sizeof(rx_fwinfo_819x_pci
);
5326 /* Initial the cck and ofdm buffer pointer */
5327 pcck_buf
= (phy_sts_cck_819xpci_t
*)prxpkt
;
5328 pofdm_buf
= (phy_sts_ofdm_819xpci_t
*)prxpkt
;
5330 pstats
->RxMIMOSignalQuality
[0] = -1;
5331 pstats
->RxMIMOSignalQuality
[1] = -1;
5332 precord_stats
->RxMIMOSignalQuality
[0] = -1;
5333 precord_stats
->RxMIMOSignalQuality
[1] = -1;
5338 // (1)Hardware does not provide RSSI for CCK
5342 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5344 u8 report
;//, cck_agc_rpt;
5347 char cck_adc_pwdb
[4];
5349 priv
->stats
.numqry_phystatusCCK
++;
5351 #ifdef RTL8190P //Only 90P 2T4R need to check
5352 if(priv
->rf_type
== RF_2T4R
&& DM_RxPathSelTable
.Enable
&& bpacket_match_bssid
)
5354 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
5356 tmp_pwdb
= pcck_buf
->adc_pwdb_X
[i
];
5357 cck_adc_pwdb
[i
] = (char)tmp_pwdb
;
5358 cck_adc_pwdb
[i
] /= 2;
5359 pstats
->cck_adc_pwdb
[i
] = precord_stats
->cck_adc_pwdb
[i
] = cck_adc_pwdb
[i
];
5360 //DbgPrint("RF-%d tmp_pwdb = 0x%x, cck_adc_pwdb = %d", i, tmp_pwdb, cck_adc_pwdb[i]);
5367 report
= pcck_buf
->cck_agc_rpt
& 0xc0;
5371 //Fixed by Jacken from Bryant 2008-03-20
5372 //Original value is -38 , -26 , -14 , -2
5373 //Fixed value is -35 , -23 , -11 , 6
5375 rx_pwr_all
= -35 - (pcck_buf
->cck_agc_rpt
& 0x3e);
5378 rx_pwr_all
= -23 - (pcck_buf
->cck_agc_rpt
& 0x3e);
5381 rx_pwr_all
= -11 - (pcck_buf
->cck_agc_rpt
& 0x3e);
5384 rx_pwr_all
= 8 - (pcck_buf
->cck_agc_rpt
& 0x3e);
5390 report
= pcck_buf
->cck_agc_rpt
& 0x60;
5395 rx_pwr_all
= -35 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1) ;
5398 rx_pwr_all
= -23 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1);
5401 rx_pwr_all
= -11 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1) ;
5404 rx_pwr_all
= -8 - ((pcck_buf
->cck_agc_rpt
& 0x1f)<<1) ;
5409 pwdb_all
= rtl819x_query_rxpwrpercentage(rx_pwr_all
);
5410 pstats
->RxPWDBAll
= precord_stats
->RxPWDBAll
= pwdb_all
;
5411 pstats
->RecvSignalPower
= rx_pwr_all
;
5414 // (3) Get Signal Quality (EVM)
5416 if(bpacket_match_bssid
)
5420 if(pstats
->RxPWDBAll
> 40)
5425 sq
= pcck_buf
->sq_rpt
;
5427 if(pcck_buf
->sq_rpt
> 64)
5429 else if (pcck_buf
->sq_rpt
< 20)
5432 sq
= ((64-sq
) * 100) / 44;
5434 pstats
->SignalQuality
= precord_stats
->SignalQuality
= sq
;
5435 pstats
->RxMIMOSignalQuality
[0] = precord_stats
->RxMIMOSignalQuality
[0] = sq
;
5436 pstats
->RxMIMOSignalQuality
[1] = precord_stats
->RxMIMOSignalQuality
[1] = -1;
5441 priv
->stats
.numqry_phystatusHT
++;
5443 // (1)Get RSSI for HT rate
5445 for(i
=RF90_PATH_A
; i
<RF90_PATH_MAX
; i
++)
5447 // 2008/01/30 MH we will judge RF RX path now.
5448 if (priv
->brfpath_rxenable
[i
])
5453 //Fixed by Jacken from Bryant 2008-03-20
5454 //Original value is 106
5455 #ifdef RTL8190P //Modify by Jacken 2008/03/31
5456 rx_pwr
[i
] = ((pofdm_buf
->trsw_gain_X
[i
]&0x3F)*2) - 106;
5458 rx_pwr
[i
] = ((pofdm_buf
->trsw_gain_X
[i
]&0x3F)*2) - 110;
5461 //Get Rx snr value in DB
5462 tmp_rxsnr
= pofdm_buf
->rxsnr_X
[i
];
5463 rx_snrX
= (char)(tmp_rxsnr
);
5465 priv
->stats
.rxSNRdB
[i
] = (long)rx_snrX
;
5467 /* Translate DBM to percentage. */
5468 RSSI
= rtl819x_query_rxpwrpercentage(rx_pwr
[i
]);
5469 if (priv
->brfpath_rxenable
[i
])
5472 /* Record Signal Strength for next packet */
5473 if(bpacket_match_bssid
)
5475 pstats
->RxMIMOSignalStrength
[i
] =(u8
) RSSI
;
5476 precord_stats
->RxMIMOSignalStrength
[i
] =(u8
) RSSI
;
5482 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5484 //Fixed by Jacken from Bryant 2008-03-20
5485 //Original value is 106
5486 rx_pwr_all
= (((pofdm_buf
->pwdb_all
) >> 1 )& 0x7f) -106;
5487 pwdb_all
= rtl819x_query_rxpwrpercentage(rx_pwr_all
);
5489 pstats
->RxPWDBAll
= precord_stats
->RxPWDBAll
= pwdb_all
;
5490 pstats
->RxPower
= precord_stats
->RxPower
= rx_pwr_all
;
5491 pstats
->RecvSignalPower
= rx_pwr_all
;
5493 // (3)EVM of HT rate
5495 if(pdrvinfo
->RxHT
&& pdrvinfo
->RxRate
>=DESC90_RATEMCS8
&&
5496 pdrvinfo
->RxRate
<=DESC90_RATEMCS15
)
5497 max_spatial_stream
= 2; //both spatial stream make sense
5499 max_spatial_stream
= 1; //only spatial stream 1 makes sense
5501 for(i
=0; i
<max_spatial_stream
; i
++)
5503 tmp_rxevm
= pofdm_buf
->rxevm_X
[i
];
5504 rx_evmX
= (char)(tmp_rxevm
);
5506 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5507 // fill most significant bit to "zero" when doing shifting operation which may change a negative
5508 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5511 evm
= rtl819x_evm_dbtopercentage(rx_evmX
);
5513 EVM
= SignalScaleMapping(EVM
);//make it good looking, from 0~100
5515 if(bpacket_match_bssid
)
5517 if(i
==0) // Fill value in RFD, Get the first spatial stream only
5518 pstats
->SignalQuality
= precord_stats
->SignalQuality
= (u8
)(evm
& 0xff);
5519 pstats
->RxMIMOSignalQuality
[i
] = precord_stats
->RxMIMOSignalQuality
[i
] = (u8
)(evm
& 0xff);
5524 /* record rx statistics for debug */
5525 rxsc_sgien_exflg
= pofdm_buf
->rxsc_sgien_exflg
;
5526 prxsc
= (phy_ofdm_rx_status_rxsc_sgien_exintfflag
*)&rxsc_sgien_exflg
;
5527 if(pdrvinfo
->BW
) //40M channel
5528 priv
->stats
.received_bwtype
[1+prxsc
->rxsc
]++;
5530 priv
->stats
.received_bwtype
[0]++;
5533 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5534 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5537 pstats
->SignalStrength
= precord_stats
->SignalStrength
= (u8
)(rtl819x_signal_scale_mapping((long)pwdb_all
));//PWDB_ALL;
5542 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u1Byte)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u1Byte)(total_rssi/=RF90_PATH_MAX);
5543 // We can judge RX path number now.
5545 pstats
->SignalStrength
= precord_stats
->SignalStrength
= (u8
)(rtl819x_signal_scale_mapping((long)(total_rssi
/=rf_rx_num
)));
5550 rtl8192_record_rxdesc_forlateruse(
5551 struct ieee80211_rx_stats
* psrc_stats
,
5552 struct ieee80211_rx_stats
* ptarget_stats
5555 ptarget_stats
->bIsAMPDU
= psrc_stats
->bIsAMPDU
;
5556 ptarget_stats
->bFirstMPDU
= psrc_stats
->bFirstMPDU
;
5557 //ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5562 static void TranslateRxSignalStuff819xpci(struct net_device
*dev
,
5563 struct sk_buff
*skb
,
5564 struct ieee80211_rx_stats
* pstats
,
5565 prx_desc_819x_pci pdesc
,
5566 prx_fwinfo_819x_pci pdrvinfo
)
5568 // TODO: We must only check packet for current MAC address. Not finish
5569 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5570 bool bpacket_match_bssid
, bpacket_toself
;
5571 bool bPacketBeacon
=false, bToSelfBA
=false;
5572 static struct ieee80211_rx_stats previous_stats
;
5573 struct ieee80211_hdr_3addr
*hdr
;
5576 // Get Signal Quality for only RX data queue (but not command queue)
5581 /* Get MAC frame start address. */
5582 tmp_buf
= skb
->data
;
5584 hdr
= (struct ieee80211_hdr_3addr
*)tmp_buf
;
5585 fc
= le16_to_cpu(hdr
->frame_ctl
);
5586 type
= WLAN_FC_GET_TYPE(fc
);
5587 praddr
= hdr
->addr1
;
5589 /* Check if the received packet is acceptabe. */
5590 bpacket_match_bssid
= ((IEEE80211_FTYPE_CTL
!= type
) &&
5591 (eqMacAddr(priv
->ieee80211
->current_network
.bssid
, (fc
& IEEE80211_FCTL_TODS
)? hdr
->addr1
: (fc
& IEEE80211_FCTL_FROMDS
)? hdr
->addr2
: hdr
->addr3
))
5592 && (!pstats
->bHwError
) && (!pstats
->bCRC
)&& (!pstats
->bICV
));
5593 bpacket_toself
= bpacket_match_bssid
& (eqMacAddr(praddr
, priv
->ieee80211
->dev
->dev_addr
));
5595 if(WLAN_FC_GET_FRAMETYPE(fc
)== IEEE80211_STYPE_BEACON
)
5597 bPacketBeacon
= true;
5598 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5600 if(WLAN_FC_GET_FRAMETYPE(fc
) == IEEE80211_STYPE_BLOCKACK
)
5602 if((eqMacAddr(praddr
,dev
->dev_addr
)))
5604 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5608 if(bpacket_match_bssid
)
5610 priv
->stats
.numpacket_matchbssid
++;
5613 priv
->stats
.numpacket_toself
++;
5616 // Process PHY information for previous packet (RSSI/PWDB/EVM)
5618 // Because phy information is contained in the last packet of AMPDU only, so driver
5619 // should process phy information of previous packet
5620 rtl8192_process_phyinfo(priv
, tmp_buf
,&previous_stats
, pstats
);
5621 rtl8192_query_rxphystatus(priv
, pstats
, pdesc
, pdrvinfo
, &previous_stats
, bpacket_match_bssid
,
5622 bpacket_toself
,bPacketBeacon
, bToSelfBA
);
5623 rtl8192_record_rxdesc_forlateruse(pstats
, &previous_stats
);
5628 static void rtl8192_tx_resume(struct net_device
*dev
)
5630 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5631 struct ieee80211_device
*ieee
= priv
->ieee80211
;
5632 struct sk_buff
*skb
;
5635 for(queue_index
= BK_QUEUE
; queue_index
< TXCMD_QUEUE
;queue_index
++) {
5636 while((!skb_queue_empty(&ieee
->skb_waitQ
[queue_index
]))&&
5637 (priv
->ieee80211
->check_nic_enough_desc(dev
,queue_index
) > 0)) {
5638 /* 1. dequeue the packet from the wait queue */
5639 skb
= skb_dequeue(&ieee
->skb_waitQ
[queue_index
]);
5640 /* 2. tx the packet directly */
5641 ieee
->softmac_data_hard_start_xmit(skb
,dev
,0/* rate useless now*/);
5643 if(queue_index
!=MGNT_QUEUE
) {
5644 ieee
->stats
.tx_packets
++;
5645 ieee
->stats
.tx_bytes
+= skb
->len
;
5652 static void rtl8192_irq_tx_tasklet(struct r8192_priv
*priv
)
5654 rtl8192_tx_resume(priv
->ieee80211
->dev
);
5657 /* Record the received data rate */
5658 static void UpdateReceivedRateHistogramStatistics8190(
5659 struct net_device
*dev
,
5660 struct ieee80211_rx_stats
* pstats
5663 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5664 u32 rcvType
=1; //0: Total, 1:OK, 2:CRC, 3:ICV
5666 u32 preamble_guardinterval
; //1: short preamble/GI, 0: long preamble/GI
5670 else if(pstats
->bICV
)
5673 if(pstats
->bShortPreamble
)
5674 preamble_guardinterval
= 1;// short
5676 preamble_guardinterval
= 0;// long
5678 switch(pstats
->rate
)
5683 case MGN_1M
: rateIndex
= 0; break;
5684 case MGN_2M
: rateIndex
= 1; break;
5685 case MGN_5_5M
: rateIndex
= 2; break;
5686 case MGN_11M
: rateIndex
= 3; break;
5690 case MGN_6M
: rateIndex
= 4; break;
5691 case MGN_9M
: rateIndex
= 5; break;
5692 case MGN_12M
: rateIndex
= 6; break;
5693 case MGN_18M
: rateIndex
= 7; break;
5694 case MGN_24M
: rateIndex
= 8; break;
5695 case MGN_36M
: rateIndex
= 9; break;
5696 case MGN_48M
: rateIndex
= 10; break;
5697 case MGN_54M
: rateIndex
= 11; break;
5699 // 11n High throughput rate
5701 case MGN_MCS0
: rateIndex
= 12; break;
5702 case MGN_MCS1
: rateIndex
= 13; break;
5703 case MGN_MCS2
: rateIndex
= 14; break;
5704 case MGN_MCS3
: rateIndex
= 15; break;
5705 case MGN_MCS4
: rateIndex
= 16; break;
5706 case MGN_MCS5
: rateIndex
= 17; break;
5707 case MGN_MCS6
: rateIndex
= 18; break;
5708 case MGN_MCS7
: rateIndex
= 19; break;
5709 case MGN_MCS8
: rateIndex
= 20; break;
5710 case MGN_MCS9
: rateIndex
= 21; break;
5711 case MGN_MCS10
: rateIndex
= 22; break;
5712 case MGN_MCS11
: rateIndex
= 23; break;
5713 case MGN_MCS12
: rateIndex
= 24; break;
5714 case MGN_MCS13
: rateIndex
= 25; break;
5715 case MGN_MCS14
: rateIndex
= 26; break;
5716 case MGN_MCS15
: rateIndex
= 27; break;
5717 default: rateIndex
= 28; break;
5719 priv
->stats
.received_preamble_GI
[preamble_guardinterval
][rateIndex
]++;
5720 priv
->stats
.received_rate_histogram
[0][rateIndex
]++; //total
5721 priv
->stats
.received_rate_histogram
[rcvType
][rateIndex
]++;
5724 static void rtl8192_rx(struct net_device
*dev
)
5726 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
5727 struct ieee80211_hdr_1addr
*ieee80211_hdr
= NULL
;
5728 bool unicast_packet
= false;
5729 struct ieee80211_rx_stats stats
= {
5733 .freq
= IEEE80211_24GHZ_BAND
,
5735 unsigned int count
= priv
->rxringcount
;
5737 stats
.nic_type
= NIC_8192E
;
5740 rx_desc_819x_pci
*pdesc
= &priv
->rx_ring
[priv
->rx_idx
];//rx descriptor
5741 struct sk_buff
*skb
= priv
->rx_buf
[priv
->rx_idx
];//rx pkt
5744 /* wait data to be filled by hardware */
5747 stats
.bICV
= pdesc
->ICV
;
5748 stats
.bCRC
= pdesc
->CRC32
;
5749 stats
.bHwError
= pdesc
->CRC32
| pdesc
->ICV
;
5751 stats
.Length
= pdesc
->Length
;
5752 if(stats
.Length
< 24)
5753 stats
.bHwError
|= 1;
5755 if(stats
.bHwError
) {
5756 stats
.bShift
= false;
5759 if (pdesc
->Length
<500)
5760 priv
->stats
.rxcrcerrmin
++;
5761 else if (pdesc
->Length
>1000)
5762 priv
->stats
.rxcrcerrmax
++;
5764 priv
->stats
.rxcrcerrmid
++;
5768 prx_fwinfo_819x_pci pDrvInfo
= NULL
;
5769 struct sk_buff
*new_skb
= dev_alloc_skb(priv
->rxbuffersize
);
5771 if (unlikely(!new_skb
)) {
5775 stats
.RxDrvInfoSize
= pdesc
->RxDrvInfoSize
;
5776 stats
.RxBufShift
= ((pdesc
->Shift
)&0x03);
5777 stats
.Decrypted
= !pdesc
->SWDec
;
5779 pci_dma_sync_single_for_cpu(priv
->pdev
,
5780 *((dma_addr_t
*)skb
->cb
),
5782 PCI_DMA_FROMDEVICE
);
5783 skb_put(skb
, pdesc
->Length
);
5784 pDrvInfo
= (rx_fwinfo_819x_pci
*)(skb
->data
+ stats
.RxBufShift
);
5785 skb_reserve(skb
, stats
.RxDrvInfoSize
+ stats
.RxBufShift
);
5787 stats
.rate
= HwRateToMRate90((bool)pDrvInfo
->RxHT
, (u8
)pDrvInfo
->RxRate
);
5788 stats
.bShortPreamble
= pDrvInfo
->SPLCP
;
5790 /* it is debug only. It should be disabled in released driver.
5791 * 2007.1.11 by Emily
5793 UpdateReceivedRateHistogramStatistics8190(dev
, &stats
);
5795 stats
.bIsAMPDU
= (pDrvInfo
->PartAggr
==1);
5796 stats
.bFirstMPDU
= (pDrvInfo
->PartAggr
==1) && (pDrvInfo
->FirstAGGR
==1);
5798 stats
.TimeStampLow
= pDrvInfo
->TSFL
;
5799 stats
.TimeStampHigh
= read_nic_dword(dev
, TSFR
+4);
5801 UpdateRxPktTimeStamp8190(dev
, &stats
);
5804 // Get Total offset of MPDU Frame Body
5806 if((stats
.RxBufShift
+ stats
.RxDrvInfoSize
) > 0)
5809 stats
.RxIs40MHzPacket
= pDrvInfo
->BW
;
5812 TranslateRxSignalStuff819xpci(dev
,skb
, &stats
, pdesc
, pDrvInfo
);
5815 if(pDrvInfo
->FirstAGGR
==1 || pDrvInfo
->PartAggr
== 1)
5816 RT_TRACE(COMP_RXDESC
, "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
5817 pDrvInfo
->FirstAGGR
, pDrvInfo
->PartAggr
);
5818 skb_trim(skb
, skb
->len
- 4/*sCrcLng*/);
5819 /* rx packets statistics */
5820 ieee80211_hdr
= (struct ieee80211_hdr_1addr
*)skb
->data
;
5821 unicast_packet
= false;
5823 if(is_broadcast_ether_addr(ieee80211_hdr
->addr1
)) {
5825 }else if(is_multicast_ether_addr(ieee80211_hdr
->addr1
)){
5828 /* unicast packet */
5829 unicast_packet
= true;
5832 stats
.packetlength
= stats
.Length
-4;
5833 stats
.fraglength
= stats
.packetlength
;
5834 stats
.fragoffset
= 0;
5835 stats
.ntotalfrag
= 1;
5837 if(!ieee80211_rtl_rx(priv
->ieee80211
, skb
, &stats
)){
5838 dev_kfree_skb_any(skb
);
5841 if(unicast_packet
) {
5842 priv
->stats
.rxbytesunicast
+= skb
->len
;
5847 priv
->rx_buf
[priv
->rx_idx
] = skb
;
5848 *((dma_addr_t
*) skb
->cb
) = pci_map_single(priv
->pdev
, skb_tail_pointer(skb
), priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
5853 pdesc
->BufferAddress
= cpu_to_le32(*((dma_addr_t
*)skb
->cb
));
5855 pdesc
->Length
= priv
->rxbuffersize
;
5856 if (priv
->rx_idx
== priv
->rxringcount
-1)
5858 priv
->rx_idx
= (priv
->rx_idx
+ 1) % priv
->rxringcount
;
5863 static void rtl8192_irq_rx_tasklet(struct r8192_priv
*priv
)
5865 rtl8192_rx(priv
->ieee80211
->dev
);
5867 write_nic_dword(priv
->ieee80211
->dev
, INTA_MASK
,read_nic_dword(priv
->ieee80211
->dev
, INTA_MASK
) | IMR_RDU
);
5870 static const struct net_device_ops rtl8192_netdev_ops
= {
5871 .ndo_open
= rtl8192_open
,
5872 .ndo_stop
= rtl8192_close
,
5873 .ndo_tx_timeout
= tx_timeout
,
5874 .ndo_do_ioctl
= rtl8192_ioctl
,
5875 .ndo_set_multicast_list
= r8192_set_multicast
,
5876 .ndo_set_mac_address
= r8192_set_mac_adr
,
5877 .ndo_start_xmit
= ieee80211_rtl_xmit
,
5880 static int __devinit
rtl8192_pci_probe(struct pci_dev
*pdev
,
5881 const struct pci_device_id
*id
)
5883 unsigned long ioaddr
= 0;
5884 struct net_device
*dev
= NULL
;
5885 struct r8192_priv
*priv
= NULL
;
5889 #ifdef CONFIG_RTL8192_IO_MAP
5890 unsigned long pio_start
, pio_len
, pio_flags
;
5892 unsigned long pmem_start
, pmem_len
, pmem_flags
;
5893 #endif //end #ifdef RTL_IO_MAP
5895 RT_TRACE(COMP_INIT
,"Configuring chip resources");
5897 if( pci_enable_device (pdev
) ){
5898 RT_TRACE(COMP_ERR
,"Failed to enable PCI device");
5902 pci_set_master(pdev
);
5903 //pci_set_wmi(pdev);
5904 pci_set_dma_mask(pdev
, 0xffffff00ULL
);
5905 pci_set_consistent_dma_mask(pdev
,0xffffff00ULL
);
5906 dev
= alloc_ieee80211(sizeof(struct r8192_priv
));
5912 pci_set_drvdata(pdev
, dev
);
5913 SET_NETDEV_DEV(dev
, &pdev
->dev
);
5914 priv
= ieee80211_priv(dev
);
5915 priv
->ieee80211
= netdev_priv(dev
);
5917 if((pdev
->subsystem_vendor
== PCI_VENDOR_ID_DLINK
)&&(pdev
->subsystem_device
== 0x3304)){
5918 priv
->ieee80211
->bSupportRemoteWakeUp
= 1;
5921 priv
->ieee80211
->bSupportRemoteWakeUp
= 0;
5924 #ifdef CONFIG_RTL8192_IO_MAP
5926 pio_start
= (unsigned long)pci_resource_start (pdev
, 0);
5927 pio_len
= (unsigned long)pci_resource_len (pdev
, 0);
5928 pio_flags
= (unsigned long)pci_resource_flags (pdev
, 0);
5930 if (!(pio_flags
& IORESOURCE_IO
)) {
5931 RT_TRACE(COMP_ERR
,"region #0 not a PIO resource, aborting");
5935 //DMESG("IO space @ 0x%08lx", pio_start );
5936 if( ! request_region( pio_start
, pio_len
, RTL819xE_MODULE_NAME
) ){
5937 RT_TRACE(COMP_ERR
,"request_region failed!");
5942 dev
->base_addr
= ioaddr
; // device I/O address
5946 pmem_start
= pci_resource_start(pdev
, 1);
5947 pmem_len
= pci_resource_len(pdev
, 1);
5948 pmem_flags
= pci_resource_flags (pdev
, 1);
5950 if (!(pmem_flags
& IORESOURCE_MEM
)) {
5951 RT_TRACE(COMP_ERR
,"region #1 not a MMIO resource, aborting");
5955 //DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
5956 if( ! request_mem_region(pmem_start
, pmem_len
, RTL819xE_MODULE_NAME
)) {
5957 RT_TRACE(COMP_ERR
,"request_mem_region failed!");
5962 ioaddr
= (unsigned long)ioremap_nocache( pmem_start
, pmem_len
);
5963 if( ioaddr
== (unsigned long)NULL
){
5964 RT_TRACE(COMP_ERR
,"ioremap failed!");
5965 // release_mem_region( pmem_start, pmem_len );
5969 dev
->mem_start
= ioaddr
; // shared mem start
5970 dev
->mem_end
= ioaddr
+ pci_resource_len(pdev
, 0); // shared mem end
5972 #endif //end #ifdef RTL_IO_MAP
5974 /* We disable the RETRY_TIMEOUT register (0x41) to keep
5975 * PCI Tx retries from interfering with C3 CPU state */
5976 pci_write_config_byte(pdev
, 0x41, 0x00);
5979 pci_read_config_byte(pdev
, 0x05, &unit
);
5980 pci_write_config_byte(pdev
, 0x05, unit
& (~0x04));
5982 dev
->irq
= pdev
->irq
;
5985 dev
->netdev_ops
= &rtl8192_netdev_ops
;
5987 dev
->open
= rtl8192_open
;
5988 dev
->stop
= rtl8192_close
;
5989 //dev->hard_start_xmit = rtl8192_8023_hard_start_xmit;
5990 dev
->tx_timeout
= tx_timeout
;
5991 //dev->wireless_handlers = &r8192_wx_handlers_def;
5992 dev
->do_ioctl
= rtl8192_ioctl
;
5993 dev
->set_multicast_list
= r8192_set_multicast
;
5994 dev
->set_mac_address
= r8192_set_mac_adr
;
5997 //DMESG("Oops: i'm coming\n");
5998 #if WIRELESS_EXT >= 12
5999 #if WIRELESS_EXT < 17
6000 dev
->get_wireless_stats
= r8192_get_wireless_stats
;
6002 dev
->wireless_handlers
= (struct iw_handler_def
*) &r8192_wx_handlers_def
;
6004 //dev->get_wireless_stats = r8192_get_wireless_stats;
6005 dev
->type
=ARPHRD_ETHER
;
6007 dev
->watchdog_timeo
= HZ
*3; //modified by john, 0805
6009 if (dev_alloc_name(dev
, ifname
) < 0){
6010 RT_TRACE(COMP_INIT
, "Oops: devname already taken! Trying wlan%%d...\n");
6011 strcpy(ifname
, "wlan%d");
6012 dev_alloc_name(dev
, ifname
);
6015 RT_TRACE(COMP_INIT
, "Driver probe completed1\n");
6016 if(rtl8192_init(dev
)!=0){
6017 RT_TRACE(COMP_ERR
, "Initialization failed");
6021 netif_carrier_off(dev
);
6022 netif_stop_queue(dev
);
6024 register_netdev(dev
);
6025 RT_TRACE(COMP_INIT
, "dev name=======> %s\n",dev
->name
);
6026 rtl8192_proc_init_one(dev
);
6029 RT_TRACE(COMP_INIT
, "Driver probe completed\n");
6034 #ifdef CONFIG_RTL8180_IO_MAP
6036 if( dev
->base_addr
!= 0 ){
6038 release_region(dev
->base_addr
,
6039 pci_resource_len(pdev
, 0) );
6042 if( dev
->mem_start
!= (unsigned long)NULL
){
6043 iounmap( (void *)dev
->mem_start
);
6044 release_mem_region( pci_resource_start(pdev
, 1),
6045 pci_resource_len(pdev
, 1) );
6047 #endif //end #ifdef RTL_IO_MAP
6053 free_irq(dev
->irq
, dev
);
6056 free_ieee80211(dev
);
6060 pci_disable_device(pdev
);
6062 DMESG("wlan driver load failed\n");
6063 pci_set_drvdata(pdev
, NULL
);
6068 /* detach all the work and timer structure declared or inititialized
6069 * in r8192_init function.
6071 static void rtl8192_cancel_deferred_work(struct r8192_priv
* priv
)
6073 /* call cancel_work_sync instead of cancel_delayed_work if and only if Linux_version_code
6074 * is or is newer than 2.6.20 and work structure is defined to be struct work_struct.
6075 * Otherwise call cancel_delayed_work is enough.
6076 * FIXME (2.6.20 should 2.6.22, work_struct should not cancel)
6078 cancel_delayed_work(&priv
->watch_dog_wq
);
6079 cancel_delayed_work(&priv
->update_beacon_wq
);
6080 cancel_delayed_work(&priv
->ieee80211
->hw_wakeup_wq
);
6081 cancel_delayed_work(&priv
->ieee80211
->hw_sleep_wq
);
6083 cancel_delayed_work(&priv
->gpio_change_rf_wq
);
6085 cancel_work_sync(&priv
->reset_wq
);
6086 cancel_work_sync(&priv
->qos_activate
);
6087 //cancel_work_sync(&priv->SetBWModeWorkItem);
6088 //cancel_work_sync(&priv->SwChnlWorkItem);
6093 static void __devexit
rtl8192_pci_disconnect(struct pci_dev
*pdev
)
6095 struct net_device
*dev
= pci_get_drvdata(pdev
);
6096 struct r8192_priv
*priv
;
6100 unregister_netdev(dev
);
6102 priv
=ieee80211_priv(dev
);
6104 rtl8192_proc_remove_one(dev
);
6107 if (priv
->pFirmware
)
6109 vfree(priv
->pFirmware
);
6110 priv
->pFirmware
= NULL
;
6112 // priv->rf_close(dev);
6113 // rtl8192_usb_deleteendpoints(dev);
6114 destroy_workqueue(priv
->priv_wq
);
6115 /* redundant with rtl8192_down */
6116 // rtl8192_irq_disable(dev);
6117 // rtl8192_reset(dev);
6121 /* free tx/rx rings */
6122 rtl8192_free_rx_ring(dev
);
6123 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
6124 rtl8192_free_tx_ring(dev
, i
);
6129 printk("Freeing irq %d\n",dev
->irq
);
6130 free_irq(dev
->irq
, dev
);
6137 // free_beacon_desc_ring(dev,priv->txbeaconcount);
6139 #ifdef CONFIG_RTL8180_IO_MAP
6141 if( dev
->base_addr
!= 0 ){
6143 release_region(dev
->base_addr
,
6144 pci_resource_len(pdev
, 0) );
6147 if( dev
->mem_start
!= (unsigned long)NULL
){
6148 iounmap( (void *)dev
->mem_start
);
6149 release_mem_region( pci_resource_start(pdev
, 1),
6150 pci_resource_len(pdev
, 1) );
6152 #endif /*end #ifdef RTL_IO_MAP*/
6153 free_ieee80211(dev
);
6157 pci_disable_device(pdev
);
6158 RT_TRACE(COMP_DOWN
, "wlan driver removed\n");
6161 extern int ieee80211_rtl_init(void);
6162 extern void ieee80211_rtl_exit(void);
6164 static int __init
rtl8192_pci_module_init(void)
6168 retval
= ieee80211_rtl_init();
6172 printk(KERN_INFO
"\nLinux kernel driver for RTL8192 based WLAN cards\n");
6173 printk(KERN_INFO
"Copyright (c) 2007-2008, Realsil Wlan\n");
6174 RT_TRACE(COMP_INIT
, "Initializing module");
6175 RT_TRACE(COMP_INIT
, "Wireless extensions version %d", WIRELESS_EXT
);
6176 rtl8192_proc_module_init();
6177 if(0!=pci_register_driver(&rtl8192_pci_driver
))
6179 DMESG("No device found");
6180 /*pci_unregister_driver (&rtl8192_pci_driver);*/
6187 static void __exit
rtl8192_pci_module_exit(void)
6189 pci_unregister_driver(&rtl8192_pci_driver
);
6191 RT_TRACE(COMP_DOWN
, "Exiting");
6192 rtl8192_proc_module_remove();
6193 ieee80211_rtl_exit();
6196 //warning message WB
6197 static irqreturn_t
rtl8192_interrupt(int irq
, void *netdev
)
6199 struct net_device
*dev
= (struct net_device
*) netdev
;
6200 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
6201 unsigned long flags
;
6203 /* We should return IRQ_NONE, but for now let me keep this */
6204 if(priv
->irq_enabled
== 0){
6208 spin_lock_irqsave(&priv
->irq_th_lock
,flags
);
6212 inta
= read_nic_dword(dev
, ISR
);// & priv->IntrMask;
6213 write_nic_dword(dev
,ISR
,inta
); // reset int situation
6215 priv
->stats
.shints
++;
6216 //DMESG("Enter interrupt, ISR value = 0x%08x", inta);
6218 spin_unlock_irqrestore(&priv
->irq_th_lock
,flags
);
6221 most probably we can safely return IRQ_NONE,
6222 but for now is better to avoid problems
6228 spin_unlock_irqrestore(&priv
->irq_th_lock
,flags
);
6234 DMESG("NIC irq %x",inta
);
6236 //priv->irqpending = inta;
6239 if(!netif_running(dev
)) {
6240 spin_unlock_irqrestore(&priv
->irq_th_lock
,flags
);
6244 if(inta
& IMR_TIMEOUT0
){
6245 // write_nic_dword(dev, TimerInt, 0);
6246 //DMESG("=================>waking up");
6247 // rtl8180_hw_wakeup(dev);
6250 if(inta
& IMR_TBDOK
){
6251 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
6252 rtl8192_tx_isr(dev
, BEACON_QUEUE
);
6253 priv
->stats
.txbeaconokint
++;
6256 if(inta
& IMR_TBDER
){
6257 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
6258 rtl8192_tx_isr(dev
, BEACON_QUEUE
);
6259 priv
->stats
.txbeaconerr
++;
6262 if(inta
& IMR_MGNTDOK
) {
6263 RT_TRACE(COMP_INTR
, "Manage ok interrupt!\n");
6264 priv
->stats
.txmanageokint
++;
6265 rtl8192_tx_isr(dev
,MGNT_QUEUE
);
6269 if(inta
& IMR_COMDOK
)
6271 priv
->stats
.txcmdpktokint
++;
6272 rtl8192_tx_isr(dev
,TXCMD_QUEUE
);
6277 DMESG("Frame arrived !");
6279 priv
->stats
.rxint
++;
6280 tasklet_schedule(&priv
->irq_rx_tasklet
);
6283 if(inta
& IMR_BcnInt
) {
6284 RT_TRACE(COMP_INTR
, "prepare beacon for interrupt!\n");
6285 tasklet_schedule(&priv
->irq_prepare_beacon_tasklet
);
6289 RT_TRACE(COMP_INTR
, "rx descriptor unavailable!\n");
6290 priv
->stats
.rxrdu
++;
6291 /* reset int situation */
6292 write_nic_dword(dev
,INTA_MASK
,read_nic_dword(dev
, INTA_MASK
) & ~IMR_RDU
);
6293 tasklet_schedule(&priv
->irq_rx_tasklet
);
6296 if(inta
& IMR_RXFOVW
){
6297 RT_TRACE(COMP_INTR
, "rx overflow !\n");
6298 priv
->stats
.rxoverflow
++;
6299 tasklet_schedule(&priv
->irq_rx_tasklet
);
6302 if(inta
& IMR_TXFOVW
) priv
->stats
.txoverflow
++;
6304 if(inta
& IMR_BKDOK
){
6305 RT_TRACE(COMP_INTR
, "BK Tx OK interrupt!\n");
6306 priv
->stats
.txbkokint
++;
6307 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
6308 rtl8192_tx_isr(dev
,BK_QUEUE
);
6309 rtl8192_try_wake_queue(dev
, BK_QUEUE
);
6312 if(inta
& IMR_BEDOK
){
6313 RT_TRACE(COMP_INTR
, "BE TX OK interrupt!\n");
6314 priv
->stats
.txbeokint
++;
6315 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
6316 rtl8192_tx_isr(dev
,BE_QUEUE
);
6317 rtl8192_try_wake_queue(dev
, BE_QUEUE
);
6320 if(inta
& IMR_VIDOK
){
6321 RT_TRACE(COMP_INTR
, "VI TX OK interrupt!\n");
6322 priv
->stats
.txviokint
++;
6323 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
6324 rtl8192_tx_isr(dev
,VI_QUEUE
);
6325 rtl8192_try_wake_queue(dev
, VI_QUEUE
);
6328 if(inta
& IMR_VODOK
){
6329 priv
->stats
.txvookint
++;
6330 priv
->ieee80211
->LinkDetectInfo
.NumTxOkInPeriod
++;
6331 rtl8192_tx_isr(dev
,VO_QUEUE
);
6332 rtl8192_try_wake_queue(dev
, VO_QUEUE
);
6335 spin_unlock_irqrestore(&priv
->irq_th_lock
,flags
);
6340 static void rtl8192_try_wake_queue(struct net_device
*dev
, int pri
)
6345 void EnableHWSecurityConfig8192(struct net_device
*dev
)
6347 u8 SECR_value
= 0x0;
6348 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
6349 struct ieee80211_device
* ieee
= priv
->ieee80211
;
6351 SECR_value
= SCR_TxEncEnable
| SCR_RxDecEnable
;
6353 if (((KEY_TYPE_WEP40
== ieee
->pairwise_key_type
) || (KEY_TYPE_WEP104
== ieee
->pairwise_key_type
)) && (priv
->ieee80211
->auth_mode
!= 2))
6355 SECR_value
|= SCR_RxUseDK
;
6356 SECR_value
|= SCR_TxUseDK
;
6358 else if ((ieee
->iw_mode
== IW_MODE_ADHOC
) && (ieee
->pairwise_key_type
& (KEY_TYPE_CCMP
| KEY_TYPE_TKIP
)))
6360 SECR_value
|= SCR_RxUseDK
;
6361 SECR_value
|= SCR_TxUseDK
;
6366 //add HWSec active enable here.
6367 //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
6368 ieee
->hwsec_active
= 1;
6370 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
6372 ieee
->hwsec_active
= 0;
6373 SECR_value
&= ~SCR_RxDecEnable
;
6376 RT_TRACE(COMP_SEC
,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__
,
6377 ieee
->hwsec_active
, ieee
->pairwise_key_type
, SECR_value
);
6379 write_nic_byte(dev
, SECR
, SECR_value
);//SECR_value | SCR_UseDK );
6383 #define TOTAL_CAM_ENTRY 32
6384 //#define CAM_CONTENT_COUNT 8
6385 void setKey( struct net_device
*dev
,
6393 u32 TargetCommand
= 0;
6394 u32 TargetContent
= 0;
6398 struct r8192_priv
*priv
= (struct r8192_priv
*)ieee80211_priv(dev
);
6399 RT_RF_POWER_STATE rtState
;
6400 rtState
= priv
->ieee80211
->eRFPowerState
;
6401 if(priv
->ieee80211
->PowerSaveControl
.bInactivePs
){
6402 if(rtState
== eRfOff
){
6403 if(priv
->ieee80211
->RfOffReason
> RF_CHANGE_BY_IPS
)
6405 RT_TRACE(COMP_ERR
, "%s(): RF is OFF.\n",__FUNCTION__
);
6406 //up(&priv->wx_sem);
6410 down(&priv
->ieee80211
->ips_sem
);
6412 up(&priv
->ieee80211
->ips_sem
);
6416 priv
->ieee80211
->is_set_key
= true;
6418 if (EntryNo
>= TOTAL_CAM_ENTRY
)
6419 RT_TRACE(COMP_ERR
, "cam entry exceeds in setKey()\n");
6421 RT_TRACE(COMP_SEC
, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev
,EntryNo
, KeyIndex
, KeyType
, MacAddr
);
6424 usConfig
|= BIT15
| (KeyType
<<2);
6426 usConfig
|= BIT15
| (KeyType
<<2) | KeyIndex
;
6427 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
6430 for(i
=0 ; i
<CAM_CONTENT_COUNT
; i
++){
6431 TargetCommand
= i
+CAM_CONTENT_COUNT
*EntryNo
;
6432 TargetCommand
|= BIT31
|BIT16
;
6434 if(i
==0){//MAC|Config
6435 TargetContent
= (u32
)(*(MacAddr
+0)) << 16|
6436 (u32
)(*(MacAddr
+1)) << 24|
6439 write_nic_dword(dev
, WCAMI
, TargetContent
);
6440 write_nic_dword(dev
, RWCAM
, TargetCommand
);
6441 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6444 TargetContent
= (u32
)(*(MacAddr
+2)) |
6445 (u32
)(*(MacAddr
+3)) << 8|
6446 (u32
)(*(MacAddr
+4)) << 16|
6447 (u32
)(*(MacAddr
+5)) << 24;
6448 write_nic_dword(dev
, WCAMI
, TargetContent
);
6449 write_nic_dword(dev
, RWCAM
, TargetCommand
);
6451 else { //Key Material
6452 if(KeyContent
!= NULL
)
6454 write_nic_dword(dev
, WCAMI
, (u32
)(*(KeyContent
+i
-2)) );
6455 write_nic_dword(dev
, RWCAM
, TargetCommand
);
6459 RT_TRACE(COMP_SEC
,"=========>after set key, usconfig:%x\n", usConfig
);
6462 bool NicIFEnableNIC(struct net_device
* dev
)
6464 RT_STATUS init_status
= RT_STATUS_SUCCESS
;
6465 struct r8192_priv
* priv
= ieee80211_priv(dev
);
6466 PRT_POWER_SAVE_CONTROL pPSC
= (PRT_POWER_SAVE_CONTROL
)(&(priv
->ieee80211
->PowerSaveControl
));
6470 RT_TRACE(COMP_ERR
, "ERR!!! %s(): Driver is already down!\n",__FUNCTION__
);
6471 priv
->bdisable_nic
= false; //YJ,add,091111
6474 // <1> Reset memory: descriptor, buffer,..
6475 //NicIFResetMemory(Adapter);
6477 // <2> Enable Adapter
6478 //priv->bfirst_init = true;
6479 init_status
= rtl8192_adapter_start(dev
);
6480 if (init_status
!= RT_STATUS_SUCCESS
) {
6481 RT_TRACE(COMP_ERR
,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__
);
6482 priv
->bdisable_nic
= false; //YJ,add,091111
6485 //printk("start adapter finished\n");
6486 RT_CLEAR_PS_LEVEL(pPSC
, RT_RF_OFF_LEVL_HALT_NIC
);
6487 //priv->bfirst_init = false;
6489 // <3> Enable Interrupt
6490 rtl8192_irq_enable(dev
);
6491 priv
->bdisable_nic
= false;
6493 return (init_status
== RT_STATUS_SUCCESS
);
6496 bool NicIFDisableNIC(struct net_device
* dev
)
6499 struct r8192_priv
* priv
= ieee80211_priv(dev
);
6501 // <1> Disable Interrupt
6503 priv
->bdisable_nic
= true; //YJ,move,091109
6504 tmp_state
= priv
->ieee80211
->state
;
6506 ieee80211_softmac_stop_protocol(priv
->ieee80211
, false);
6508 priv
->ieee80211
->state
= tmp_state
;
6509 rtl8192_cancel_deferred_work(priv
);
6510 rtl8192_irq_disable(dev
);
6511 // <2> Stop all timer
6513 // <3> Disable Adapter
6514 rtl8192_halt_adapter(dev
, false);
6515 // priv->bdisable_nic = true;
6520 module_init(rtl8192_pci_module_init
);
6521 module_exit(rtl8192_pci_module_exit
);